Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.util;
006
007
008import java.util.ArrayList;
009import java.util.HashSet;
010import java.util.Iterator;
011import java.util.List;
012import java.util.Set;
013
014import junit.framework.Test;
015import junit.framework.TestCase;
016import junit.framework.TestSuite;
017
018import edu.jas.arith.BigInteger;
019
020
021/**
022 * Iterator tests with JUnit.
023 * @author Heinz Kredel
024 */
025
026public class IteratorsTest extends TestCase {
027
028
029    /**
030     * main.
031     */
032    public static void main(String[] args) {
033        junit.textui.TestRunner.run(suite());
034    }
035
036
037    /**
038     * Constructs a <CODE>ListUtilTest</CODE> object.
039     * @param name String.
040     */
041    public IteratorsTest(String name) {
042        super(name);
043    }
044
045
046    /**
047     */
048    public static Test suite() {
049        TestSuite suite = new TestSuite(IteratorsTest.class);
050        return suite;
051    }
052
053
054    @Override
055    protected void setUp() {
056    }
057
058
059    @Override
060    protected void tearDown() {
061    }
062
063
064    /**
065     * Test cartesian product.
066     * 
067     */
068    public void testCartesianProduct() {
069        BigInteger ai = new BigInteger();
070        int s1 = 5;
071        int s2 = 3;
072        int s = 1;
073        for (int i = 0; i < s1; i++) {
074            s *= s2;
075        }
076        //System.out.println("s = " + s);
077        List<Iterable<BigInteger>> tlist = new ArrayList<Iterable<BigInteger>>(s1);
078        for (int i = 0; i < s1; i++) {
079            List<BigInteger> list = new ArrayList<BigInteger>(s2);
080            for (int j = 0; j < s2; j++) {
081                list.add(ai.fromInteger(j));
082            }
083            tlist.add(list);
084        }
085        //System.out.println("tlist = " + tlist);
086        int t = 0;
087        for (List<BigInteger> tuple : new CartesianProduct<BigInteger>(tlist)) {
088            t++;
089            //System.out.println("tuple = " + tuple);
090            assertTrue("|tuple| == " + s1 + " ", s1 == tuple.size());
091        }
092        assertTrue("#tuple == " + s + " == " + t + " ", t == s);
093    }
094
095
096    /**
097     * Test power set.
098     * 
099     */
100    public void testPowerSet() {
101        BigInteger ai = new BigInteger();
102        int s1 = 5;
103        int s = 1;
104        for (int i = 0; i < s1; i++) {
105            s *= 2;
106        }
107        //System.out.println("s = " + s);
108        List<BigInteger> tlist = new ArrayList<BigInteger>(s1);
109        for (int j = 0; j < s1; j++) {
110            tlist.add(ai.random(7));
111        }
112        //System.out.println("tlist = " + tlist);
113        int t = 0;
114        for (List<BigInteger> tuple : new PowerSet<BigInteger>(tlist)) {
115            t++;
116            //System.out.println("tuple = " + tuple);
117            assertFalse("tuple != null", tuple == null);
118        }
119        assertTrue("#tuple == " + s + " == " + t + " ", t == s);
120    }
121
122
123    /**
124     * Test k-subset set.
125     * 
126     */
127    public void testKsubSet() {
128        BigInteger ai = new BigInteger();
129        int s1 = 5;
130        int s = 1;
131        for (int i = 0; i < s1; i++) {
132            s *= 2;
133        }
134        //System.out.println("s = " + s);
135        List<BigInteger> tlist = new ArrayList<BigInteger>(s1);
136        for (int j = 0; j < s1; j++) {
137            tlist.add(ai.random(7));
138        }
139        //System.out.println("tlist = " + tlist);
140        int t = 0;
141        for (int k = 0; k <= s1; k++) {
142            for (List<BigInteger> tuple : new KsubSet<BigInteger>(tlist, k)) {
143                t++;
144                //System.out.println("tuple = " + tuple);
145                assertTrue("|tuple| == " + k + " ", k == tuple.size());
146            }
147        }
148        assertTrue("#tuple == " + s + " == " + t + " ", t == s);
149    }
150
151
152    /**
153     * Test infinite cartesian product.
154     * 
155     */
156    public void testInfiniteCartesianProductTwoList() {
157        BigInteger ai = new BigInteger();
158        ai.setNonNegativeIterator();
159        int s1 = 2;
160        //System.out.println("s1 = " + s1);
161        List<Iterable<BigInteger>> tlist = new ArrayList<Iterable<BigInteger>>(s1);
162        for (int i = 0; i < s1; i++) {
163            tlist.add(ai);
164        }
165        //System.out.println("tlist = " + tlist);
166        Set<List<BigInteger>> set = new HashSet<List<BigInteger>>();
167
168        int s2 = 5;
169        //int s = 1;
170        //for (int i = 0; i < s1; i++) {
171        //    s *= s2;
172        //}
173        //System.out.println("s = " + s);
174        List<Iterable<BigInteger>> ftlist = new ArrayList<Iterable<BigInteger>>(s1);
175        for (int i = 0; i < s1; i++) {
176            List<BigInteger> list = new ArrayList<BigInteger>(s2);
177            for (int j = 0; j < s2; j++) {
178                list.add(ai.fromInteger(j));
179            }
180            ftlist.add(list);
181        }
182        //System.out.println("tlist = " + tlist);
183        int r = 0;
184        for (List<BigInteger> tuple : new CartesianProduct<BigInteger>(ftlist)) {
185            r++;
186            set.add(tuple);
187        }
188        //System.out.println("set = " + set.size());
189        //System.out.println("set = " + r);
190
191        int t = 0;
192        int h = 0;
193        Iterable<List<BigInteger>> ib = new CartesianProductInfinite<BigInteger>(tlist);
194        Iterator<List<BigInteger>> iter = ib.iterator();
195        while (iter.hasNext()) {
196            List<BigInteger> tuple = iter.next();
197            t++;
198            //System.out.println("tuple = " + tuple);
199            //assertTrue("|tuple| == " + s1 + " ", s1 == tuple.size());
200            if (set.contains(tuple)) {
201                h++;
202            }
203            if (h >= r) {
204                break;
205            }
206            assertTrue("#tuple <= 125 " + t, t <= 125);
207        }
208        //System.out.println("#tuple = " + t + ", #set = " + r);
209    }
210
211
212    /**
213     * Test infinite cartesian product.
214     * 
215     */
216    public void testInfiniteCartesianProduct() {
217        BigInteger ai = new BigInteger();
218        ai.setNonNegativeIterator();
219        int s1 = 4;
220        //System.out.println("s1 = " + s1);
221        List<Iterable<BigInteger>> tlist = new ArrayList<Iterable<BigInteger>>(s1);
222        for (int i = 0; i < s1; i++) {
223            tlist.add(ai);
224        }
225        //System.out.println("tlist = " + tlist);
226        Set<List<BigInteger>> set = new HashSet<List<BigInteger>>();
227
228        int s2 = 5;
229        //int s = 1;
230        //for (int i = 0; i < s1; i++) {
231        //    s *= s2;
232        //}
233        //System.out.println("s = " + s);
234        List<Iterable<BigInteger>> ftlist = new ArrayList<Iterable<BigInteger>>(s1);
235        for (int i = 0; i < s1; i++) {
236            List<BigInteger> list = new ArrayList<BigInteger>(s2);
237            for (int j = 0; j < s2; j++) {
238                list.add(ai.fromInteger(j));
239            }
240            ftlist.add(list);
241        }
242        //System.out.println("tlist = " + tlist);
243        int r = 0;
244        for (List<BigInteger> tuple : new CartesianProduct<BigInteger>(ftlist)) {
245            r++;
246            set.add(tuple);
247        }
248        //System.out.println("set = " + set.size());
249        //System.out.println("set = " + r);
250
251        int t = 0;
252        int h = 0;
253        Iterable<List<BigInteger>> ib = new CartesianProductInfinite<BigInteger>(tlist);
254        Iterator<List<BigInteger>> iter = ib.iterator();
255        while (iter.hasNext()) {
256            List<BigInteger> tuple = iter.next();
257            t++;
258            //System.out.println("tuple = " + tuple);
259            //assertTrue("|tuple| == " + s1 + " ", s1 == tuple.size());
260            if (set.contains(tuple)) {
261                h++;
262            }
263            if (h >= r) {
264                break;
265            }
266            assertTrue("#tuple <= 3281 " + t, t <= 3281);
267        }
268        //System.out.println("#tuple = " + t + ", #set = " + r);
269    }
270
271
272    /**
273     * Test Long iterator.
274     * 
275     */
276    public void testLong() {
277        LongIterable li = new LongIterable();
278        li.setNonNegativeIterator();
279        long s = 0L;
280        long t = 0L;
281        for (Long i : li) {
282            //System.out.println("i = " + i);
283            s = i;
284            assertTrue("t == i", t == i);
285            t++;
286            if (t > 1000L) { //% 100000000L == 0L ) {
287                //System.out.println("i = " + i);
288                break;
289            }
290        }
291        //System.out.println("t = " + t);
292        assertTrue("i == 1000", s == 1000L);
293
294        li.setAllIterator();
295        s = 0L;
296        t = 0L;
297        for (Long i : li) {
298            //System.out.println("i = " + i);
299            s = i;
300            //assertTrue("t == i", t == i );
301            t++;
302            if (t >= 1000L) { //% 100000000L == 0L ) {
303                //System.out.println("i = " + i);
304                break;
305            }
306        }
307        //System.out.println("t = " + t);
308        assertTrue("i == 500", s == 500L);
309    }
310
311}