Permutations for test data

//--------------------------------------
// Systematically generate permutations. 
//-------------------------------------- 
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List; 
public class PermutationGenerator { 
	private int[] a;
	private BigInteger numLeft;
	private BigInteger total; 
	// -----------------------------------------------------------
	// Constructor. WARNING: Don't make n too large.
	// Recall that the number of permutations is n!
	// which can be very large, even when n is as small as 20 --
	// 20! = 2,432,902,008,176,640,000 and
	// 21! is too big to fit into a Java long, which is
	// why we use BigInteger instead.
	// ---------------------------------------------------------- 
	public PermutationGenerator(int n) {
		if (n < 1) {
			throw new IllegalArgumentException("Min 1");
		}
		a = new int[n];
		total = getFactorial(n);
		reset();
	} 
	// ------
	// Reset
	// ------ 
	public void reset() {
		for (int i = 0; i < a.length; i++) {
			a[i] = i;
		}
		numLeft = new BigInteger(total.toString());
	} 
	// ------------------------------------------------
	// Return number of permutations not yet generated
	// ------------------------------------------------ 
	public BigInteger getNumLeft() {
		return numLeft;
	} 
	// ------------------------------------
	// Return total number of permutations
	// ------------------------------------ 
	public BigInteger getTotal() {
		return total;
	} 
	// -----------------------------
	// Are there more permutations?
	// ----------------------------- 
	public boolean hasMore() {
		return numLeft.compareTo(BigInteger.ZERO) == 1;
	} 
	// ------------------
	// Compute factorial
	// ------------------ 
	private static BigInteger getFactorial(int n) {
		BigInteger fact = BigInteger.ONE;
		for (int i = n; i > 1; i--) {
			fact = fact.multiply(new BigInteger(Integer.toString(i)));
		}
		return fact;
	} 
	// --------------------------------------------------------
	// Generate next permutation (algorithm from Rosen p. 284)
	// -------------------------------------------------------- 
	public int[] getNext() { 
		if (numLeft.equals(total)) {
			numLeft = numLeft.subtract(BigInteger.ONE);
			return a;
		} 
		int temp; 
		// Find largest index j with a[j] < a[j+1] 
		int j = a.length - 2;
		while (a[j] > a[j + 1]) {
			j--;
		} 
		// Find index k such that a[k] is smallest integer
		// greater than a[j] to the right of a[j] 
		int k = a.length - 1;
		while (a[j] > a[k]) {
			k--;
		} 
		// Interchange a[j] and a[k] 
		temp = a[k];
		a[k] = a[j];
		a[j] = temp; 
		// Put tail end of permutation after jth position in increasing order 
		int r = a.length - 1;
		int s = j + 1; 
		while (r > s) {
			temp = a[s];
			a[s] = a[r];
			a[r] = temp;
			r--;
			s++;
		} 
		numLeft = numLeft.subtract(BigInteger.ONE);
		return a; 
	} 
	private static <T extends Comparable<? super T>> List<List<T>> powerSet(List<T> A, int length) {
		List<List<T>> ans = new ArrayList<List<T>>();
		int ansSize = (int) Math.pow(2, A.size());
		for (Integer i = 0; i < ansSize; ++i) {
			String bin = Integer.toString(i, 2);
			while (bin.length() < A.size())
				bin = "0" + bin;
			if (bin.replaceAll("[^1]", "").length() == length) {
				List<T> thisComb = new ArrayList<T>();
				for (int j = 0; j < A.size(); ++j) {
					if (bin.charAt(j) == '1')
						thisComb.add(A.get(j));
				}
				Collections.sort(thisComb);
				ans.add(thisComb);
			}
		}
		return ans;
	} 
	public static void main(String[] args) {
		int[] indices;
		int numberOfElements = Integer.valueOf(args[0]);
		List<String> elements = Arrays.asList(new String[] { "a", "b", "c", "d" });
		PermutationGenerator x = new PermutationGenerator(numberOfElements); // number of elements in permutation
		StringBuffer permutation;
		List<List<String>> subsets = powerSet(elements, numberOfElements); 
		for (List<String> aux : subsets) {
			x.reset();
			while (x.hasMore()) {
				permutation = new StringBuffer();
				indices = x.getNext();
				for (int i = 0; i < indices.length; i++) {
					permutation.append(aux.get(indices[i]));
				}
				System.out.println(permutation.toString());
			}
		}
	}
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174: