001package daikon.test;
002
003import static org.junit.Assert.assertEquals;
004import static org.junit.Assert.assertFalse;
005import static org.junit.Assert.assertNull;
006import static org.junit.Assert.assertTrue;
007
008import daikon.*;
009import java.util.Arrays;
010import junit.framework.*;
011import org.junit.Test;
012
013@SuppressWarnings({"nullness", "UnusedVariable"}) // testing code
014public final class TestQuant {
015
016  public static final void assert_arrays_equals(int[] a1, int[] a2) {
017    boolean result = Arrays.equals(a1, a2);
018    if (!result) {
019      System.out.println("Arrays differ: " + Arrays.toString(a1) + ", " + Arrays.toString(a2));
020    }
021    assertTrue(result);
022  }
023
024  private static int[] removeAdjacentDups(int[] a) {
025    if (a.length == 0) {
026      return new int[] {};
027    }
028    int[] intermediate = new int[a.length];
029    int length = 0;
030    for (int i = 0; i < a.length - 1; i++) {
031      if (a[i] != a[i + 1]) {
032        intermediate[length++] = a[i];
033      }
034    }
035    intermediate[length++] = a[a.length - 1];
036    int[] retval = new int[length];
037    for (int i = 0; i < length; i++) {
038      retval[i] = intermediate[i];
039    }
040    return retval;
041  }
042
043  // These methods aren't used to express any invariants; no need for them.
044  //   public static void test_min() {
045  //     assertEquals(1, Quant.min(new int[] { 1,2,3 }));
046  //     assertEquals(1, Quant.min(new int[] { 2,33,1 }));
047  //     assertEquals(-2, Quant.min(new int[] { 3,-2,1 }));
048  //     assertEquals(3, Quant.min(new int[] { 3 }));
049  //   }
050
051  //   public static void test_max() {
052  //     assertEquals(3, Quant.max(new int[] { 1,2,3 }));
053  //     assertEquals(33, Quant.max(new int[] { 2,33,1 }));
054  //     assertEquals(3, Quant.max(new int[] { 3,-2,1 }));
055  //     assertEquals(3, Quant.max(new int[] { 3 }));
056  //   }
057
058  @Test
059  public void test_concat() {
060    assert_arrays_equals(Quant.concat(new int[] {}, new int[] {}), new int[] {});
061    assert_arrays_equals(Quant.concat(new int[] {1}, new int[] {}), new int[] {1});
062    assert_arrays_equals(Quant.concat(new int[] {}, new int[] {1}), new int[] {1});
063    assert_arrays_equals(Quant.concat(new int[] {1}, new int[] {1}), new int[] {1, 1});
064    assert_arrays_equals(
065        Quant.concat(new int[] {1, 2, 3}, new int[] {3, 4, 5}), new int[] {1, 2, 3, 3, 4, 5});
066    assert_arrays_equals(
067        Quant.concat(
068            new int[] {
069              -1,
070            },
071            new int[] {2, 3, 4, 5}),
072        new int[] {-1, 2, 3, 4, 5});
073    assert_arrays_equals(
074        Quant.concat(new int[] {-1, 2, 3, 4}, new int[] {5}), new int[] {-1, 2, 3, 4, 5});
075  }
076
077  @Test
078  public void test_union() {
079    {
080      int[] u = Quant.union(new int[] {}, new int[] {});
081      Arrays.sort(u);
082      assert_arrays_equals(removeAdjacentDups(u), new int[] {});
083    }
084    {
085      int[] u = Quant.union(new int[] {1}, new int[] {});
086      Arrays.sort(u);
087      assert_arrays_equals(removeAdjacentDups(u), new int[] {1});
088    }
089    {
090      int[] u = Quant.union(new int[] {}, new int[] {1});
091      Arrays.sort(u);
092      assert_arrays_equals(removeAdjacentDups(u), new int[] {1});
093    }
094    {
095      int[] u = Quant.union(new int[] {1}, new int[] {1});
096      Arrays.sort(u);
097      assert_arrays_equals(removeAdjacentDups(u), new int[] {1});
098    }
099    {
100      int[] u = Quant.union(new int[] {1, 2, 3}, new int[] {3, 4, 5});
101      Arrays.sort(u);
102      assert_arrays_equals(removeAdjacentDups(u), new int[] {1, 2, 3, 4, 5});
103    }
104    {
105      int[] u = Quant.union(new int[] {1, 2, 3}, new int[] {1, 2, 3});
106      Arrays.sort(u);
107      assert_arrays_equals(removeAdjacentDups(u), new int[] {1, 2, 3});
108    }
109    {
110      int[] u = Quant.union(new int[] {-1}, new int[] {2, 3, 4, 5});
111      Arrays.sort(u);
112      assert_arrays_equals(removeAdjacentDups(u), new int[] {-1, 2, 3, 4, 5});
113    }
114    {
115      int[] u = Quant.union(new int[] {-1, 2, 3, 4}, new int[] {5});
116      Arrays.sort(u);
117      assert_arrays_equals(removeAdjacentDups(u), new int[] {-1, 2, 3, 4, 5});
118    }
119  }
120
121  @Test
122  public void test_intersection() {
123    {
124      int[] u = Quant.intersection(new int[] {}, new int[] {});
125      Arrays.sort(u);
126      assert_arrays_equals(removeAdjacentDups(u), new int[] {});
127    }
128    {
129      int[] u = Quant.intersection(new int[] {1}, new int[] {});
130      Arrays.sort(u);
131      assert_arrays_equals(removeAdjacentDups(u), new int[] {});
132    }
133    {
134      int[] u = Quant.intersection(new int[] {}, new int[] {1});
135      Arrays.sort(u);
136      assert_arrays_equals(removeAdjacentDups(u), new int[] {});
137    }
138    {
139      int[] u = Quant.intersection(new int[] {1}, new int[] {1});
140      Arrays.sort(u);
141      assert_arrays_equals(removeAdjacentDups(u), new int[] {1});
142    }
143    {
144      int[] u = Quant.intersection(new int[] {1, 2, 3}, new int[] {1, 2, 3});
145      Arrays.sort(u);
146      assert_arrays_equals(removeAdjacentDups(u), new int[] {1, 2, 3});
147    }
148    {
149      int[] u = Quant.intersection(new int[] {1, 2, 3}, new int[] {3, 4, 5});
150      Arrays.sort(u);
151      assert_arrays_equals(removeAdjacentDups(u), new int[] {3});
152    }
153    {
154      int[] u = Quant.intersection(new int[] {-1}, new int[] {2, 3, 4, 5});
155      Arrays.sort(u);
156      assert_arrays_equals(removeAdjacentDups(u), new int[] {});
157    }
158    {
159      int[] u = Quant.intersection(new int[] {-1, 2, 3, 4}, new int[] {5});
160      Arrays.sort(u);
161      assert_arrays_equals(removeAdjacentDups(u), new int[] {});
162    }
163  }
164
165  @Test
166  public void test_setDiff() {
167    assert_arrays_equals(Quant.setDiff(new int[] {}, new int[] {}), new int[] {});
168    assert_arrays_equals(Quant.setDiff(new int[] {1}, new int[] {}), new int[] {1});
169    assert_arrays_equals(Quant.setDiff(new int[] {}, new int[] {1}), new int[] {});
170    assert_arrays_equals(Quant.setDiff(new int[] {1}, new int[] {1}), new int[] {});
171    assert_arrays_equals(Quant.setDiff(new int[] {1, 2, 3}, new int[] {1, 2, 3}), new int[] {});
172    assert_arrays_equals(Quant.setDiff(new int[] {1, 2, 3}, new int[] {3, 4, 5}), new int[] {1, 2});
173    assert_arrays_equals(
174        Quant.setDiff(
175            new int[] {
176              -1,
177            },
178            new int[] {2, 3, 4, 5}),
179        new int[] {-1});
180    assert_arrays_equals(
181        Quant.setDiff(new int[] {-1, 2, 3, 4}, new int[] {5}), new int[] {-1, 2, 3, 4});
182  }
183
184  @Test
185  public void test_setEqual() {
186    assertTrue(Quant.setEqual(new int[] {}, new int[] {}));
187    assertFalse(Quant.setEqual(new int[] {1}, new int[] {}));
188    assertFalse(Quant.setEqual(new int[] {}, new int[] {1}));
189    assertTrue(Quant.setEqual(new int[] {1}, new int[] {1}));
190    assertTrue(Quant.setEqual(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
191    assertTrue(Quant.setEqual(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
192    assertTrue(Quant.setEqual(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
193    assertFalse(Quant.setEqual(new int[] {1, 2, 3}, new int[] {3, 4, 5}));
194    assertFalse(
195        Quant.setEqual(
196            new int[] {
197              -1,
198            },
199            new int[] {2, 3, 4, 5}));
200    assertFalse(Quant.setEqual(new int[] {-1, 2, 3, 4}, new int[] {5}));
201  }
202
203  @Test
204  public void test_subsetOf() {
205    assertTrue(Quant.subsetOf(new int[] {-1}, new int[] {-1, 1}));
206    assertFalse(Quant.subsetOf(new int[] {-1, 0, 1}, new int[] {-1, 1}));
207    assertTrue(Quant.subsetOf(new int[] {-1, 1}, new int[] {-1, 1}));
208    assertFalse(Quant.subsetOf(new int[] {-1, 2, 3, 4}, new int[] {5}));
209    assertFalse(
210        Quant.subsetOf(
211            new int[] {
212              -1,
213            },
214            new int[] {2, 3, 4, 5}));
215    assertTrue(Quant.subsetOf(new int[] {1}, new int[] {-1, 1}));
216    assertTrue(Quant.subsetOf(new int[] {1}, new int[] {1}));
217    assertTrue(Quant.subsetOf(new int[] {1}, new int[] {1, 2, 3}));
218    assertFalse(Quant.subsetOf(new int[] {1}, new int[] {}));
219    assertFalse(Quant.subsetOf(new int[] {1, 2}, new int[] {1}));
220    assertTrue(Quant.subsetOf(new int[] {1, 2}, new int[] {1, 2, 3}));
221    assertFalse(Quant.subsetOf(new int[] {1, 2}, new int[] {}));
222    assertTrue(Quant.subsetOf(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
223    assertFalse(Quant.subsetOf(new int[] {1, 2, 3}, new int[] {2}));
224    assertFalse(Quant.subsetOf(new int[] {1, 2, 3}, new int[] {2, 3}));
225    assertTrue(Quant.subsetOf(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
226    assertTrue(Quant.subsetOf(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
227    assertFalse(Quant.subsetOf(new int[] {1, 2, 3}, new int[] {3, 4, 5}));
228    assertTrue(Quant.subsetOf(new int[] {2, 1}, new int[] {1, 2, 3}));
229    assertFalse(Quant.subsetOf(new int[] {2, 3}, new int[] {3, 3, 3, 3}));
230    assertTrue(Quant.subsetOf(new int[] {3, 1}, new int[] {1, 2, 3}));
231    assertTrue(Quant.subsetOf(new int[] {3, 3}, new int[] {3, 3, 3, 3}));
232    assertTrue(Quant.subsetOf(new int[] {}, new int[] {-1, 1}));
233    assertTrue(Quant.subsetOf(new int[] {}, new int[] {1}));
234    assertTrue(Quant.subsetOf(new int[] {}, new int[] {2, 3, 1}));
235    assertTrue(Quant.subsetOf(new int[] {}, new int[] {}));
236  }
237
238  @Test
239  public void test_subsetOf_different_types() {
240    assertTrue(Quant.subsetOf(new byte[] {}, new int[] {}));
241    assertTrue(Quant.subsetOf(new long[] {}, new long[] {}));
242    assertFalse(Quant.subsetOf(new byte[] {1}, new long[] {}));
243    assertFalse(Quant.subsetOf(new short[] {1, 2}, new short[] {}));
244    assertTrue(Quant.subsetOf(new long[] {}, new short[] {1}));
245    assertTrue(Quant.subsetOf(new int[] {1}, new short[] {1}));
246    assertFalse(Quant.subsetOf(new float[] {1, 2}, new double[] {1}));
247    assertTrue(Quant.subsetOf(new double[] {}, new double[] {-1, 1}));
248    assertTrue(Quant.subsetOf(new float[] {1}, new float[] {-1, 1}));
249    assertTrue(Quant.subsetOf(new double[] {-1}, new float[] {-1, 1}));
250    assertTrue(Quant.subsetOf(new byte[] {-1, 1}, new short[] {-1, 1}));
251    assertFalse(Quant.subsetOf(new short[] {-1, 0, 1}, new byte[] {-1, 1}));
252    assertTrue(Quant.subsetOf(new int[] {1, 2}, new byte[] {1, 2, 3}));
253    assertTrue(Quant.subsetOf(new long[] {}, new short[] {2, 3, 1}));
254  }
255
256  @Test
257  public void test_isReverse() {
258    assertTrue(Quant.isReverse(new int[] {}, new int[] {}));
259    assertFalse(Quant.isReverse(new int[] {1}, new int[] {}));
260    assertFalse(Quant.isReverse(new int[] {}, new int[] {1}));
261    assertTrue(Quant.isReverse(new int[] {1}, new int[] {1}));
262    assertFalse(Quant.isReverse(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
263    assertFalse(Quant.isReverse(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
264    assertTrue(Quant.isReverse(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
265    assertFalse(Quant.isReverse(new int[] {1, 2, 3}, new int[] {3, 4, 5}));
266    assertFalse(
267        Quant.isReverse(
268            new int[] {
269              -1,
270            },
271            new int[] {2, 3, 4, 5}));
272    assertFalse(Quant.isReverse(new int[] {-1, 2, 3, 4}, new int[] {5}));
273  }
274
275  @Test
276  public void test_noDups() {
277    assertTrue(Quant.noDups(new int[] {}));
278    assertTrue(Quant.noDups(new int[] {1}));
279    assertTrue(Quant.noDups(new int[] {-1}));
280    assertTrue(Quant.noDups(new int[] {-1, 1}));
281    assertTrue(Quant.noDups(new int[] {1, 2, 3}));
282    assertTrue(Quant.noDups(new int[] {2, 3, 1}));
283    assertFalse(Quant.noDups(new int[] {2, 3, 2, 3}));
284    assertFalse(Quant.noDups(new int[] {2, 3, 3, 2}));
285    assertFalse(Quant.noDups(new int[] {3, 3, 3, 3}));
286    assertFalse(Quant.noDups(new int[] {3, 3, 3, 2}));
287    assertFalse(Quant.noDups(new int[] {1, 1, 1, -1}));
288    assertTrue(Quant.noDups(new int[] {-1, 1, 2, 3, 4, 5, 6}));
289  }
290
291  @Test
292  public void test_memberOf() {
293    assertFalse(Quant.memberOf(1, new int[] {}));
294    assertTrue(Quant.memberOf(1, new int[] {1}));
295    assertFalse(Quant.memberOf(-1, new int[] {1}));
296    assertFalse(Quant.memberOf(1, new int[] {-1}));
297    assertTrue(Quant.memberOf(-1, new int[] {-1}));
298    assertTrue(Quant.memberOf(1, new int[] {-1, 1}));
299    assertTrue(Quant.memberOf(-1, new int[] {-1, 1}));
300    assertFalse(Quant.memberOf(2, new int[] {-1, 1}));
301    assertTrue(Quant.memberOf(1, new int[] {1, 2, 3}));
302    assertTrue(Quant.memberOf(2, new int[] {1, 2, 3}));
303    assertTrue(Quant.memberOf(3, new int[] {1, 2, 3}));
304    assertFalse(Quant.memberOf(4, new int[] {1, 2, 3}));
305    assertTrue(Quant.memberOf(1, new int[] {2, 3, 1}));
306    assertTrue(Quant.memberOf(2, new int[] {2, 3, 1}));
307    assertTrue(Quant.memberOf(3, new int[] {2, 3, 1}));
308    assertFalse(Quant.memberOf(4, new int[] {2, 3, 1}));
309    assertTrue(Quant.memberOf(3, new int[] {3, 3, 3, 3}));
310    assertFalse(Quant.memberOf(2, new int[] {3, 3, 3, 3}));
311    assertTrue(Quant.memberOf(-1, new int[] {-1, 1, 2, 3, 4, 5, 6}));
312    assertTrue(Quant.memberOf(1, new int[] {-1, 1, 2, 3, 4, 5, 6}));
313    assertTrue(Quant.memberOf(6, new int[] {-1, 1, 2, 3, 4, 5, 6}));
314  }
315
316  @Test
317  public void test_slice() {
318    assert_arrays_equals(Quant.slice(new int[] {}, 0, 0), new int[] {});
319    assert_arrays_equals(Quant.slice(new int[] {1}, 0, 0), new int[] {1});
320    assert_arrays_equals(Quant.slice(new int[] {1}, 0, 1), new int[] {});
321    assert_arrays_equals(Quant.slice(new int[] {1, 2, 3}, 0, 0), new int[] {1});
322    assert_arrays_equals(Quant.slice(new int[] {1, 2, 3}, 0, 1), new int[] {1, 2});
323    assert_arrays_equals(Quant.slice(new int[] {1, 2, 3}, 0, 2), new int[] {1, 2, 3});
324    assert_arrays_equals(Quant.slice(new int[] {1, 2, 3}, 0, 3), new int[] {});
325    assert_arrays_equals(Quant.slice(new int[] {1, 2, 3}, 1, 1), new int[] {2});
326    assert_arrays_equals(Quant.slice(new int[] {1, 2, 3}, 1, 2), new int[] {2, 3});
327    assert_arrays_equals(Quant.slice(new int[] {1, 2, 3}, 2, 2), new int[] {3});
328  }
329
330  @Test
331  public void test_eltsEqual() {
332    assertTrue(Quant.eltsEqual(new int[] {}, 0));
333    assertFalse(Quant.eltsEqual(new int[] {1}, -1));
334    assertTrue(Quant.eltsEqual(new int[] {1}, 1));
335    assertFalse(Quant.eltsEqual(new int[] {-1}, 1));
336    assertTrue(Quant.eltsEqual(new int[] {-1}, -1));
337    assertFalse(Quant.eltsEqual(new int[] {-1, 1}, 1));
338    assertFalse(Quant.eltsEqual(new int[] {-1, 1}, -1));
339    assertFalse(Quant.eltsEqual(new int[] {1, 2, 3}, 1));
340    assertFalse(Quant.eltsEqual(new int[] {1, 2, 3}, 2));
341    assertFalse(Quant.eltsEqual(new int[] {1, 2, 3}, 3));
342    assertFalse(Quant.eltsEqual(new int[] {2, 3, 2, 3}, 2));
343    assertFalse(Quant.eltsEqual(new int[] {2, 3, 2, 3}, 3));
344    assertTrue(Quant.eltsEqual(new int[] {3, 3, 3, 3}, 3));
345    assertFalse(Quant.eltsEqual(new int[] {1, 1, 1, -1}, 1));
346    assertTrue(Quant.eltsEqual(new int[] {1, 1, 1, 1}, 1));
347  }
348
349  @Test
350  public void test_eltsNotEqual() {
351    assertTrue(Quant.eltsNotEqual(new int[] {}, 0));
352    assertTrue(Quant.eltsNotEqual(new int[] {1}, -1));
353    assertFalse(Quant.eltsNotEqual(new int[] {1}, 1));
354    assertTrue(Quant.eltsNotEqual(new int[] {-1}, 1));
355    assertFalse(Quant.eltsNotEqual(new int[] {-1}, -1));
356    assertFalse(Quant.eltsNotEqual(new int[] {-1, 1}, 1));
357    assertFalse(Quant.eltsNotEqual(new int[] {-1, 1}, -1));
358    assertFalse(Quant.eltsNotEqual(new int[] {1, 2, 3}, 1));
359    assertFalse(Quant.eltsNotEqual(new int[] {1, 2, 3}, 2));
360    assertFalse(Quant.eltsNotEqual(new int[] {1, 2, 3}, 3));
361    assertFalse(Quant.eltsNotEqual(new int[] {2, 3, 2, 3}, 2));
362    assertFalse(Quant.eltsNotEqual(new int[] {2, 3, 2, 3}, 3));
363    assertFalse(Quant.eltsNotEqual(new int[] {3, 3, 3, 3}, 3));
364    assertFalse(Quant.eltsNotEqual(new int[] {1, 1, 1, -1}, 1));
365    assertTrue(Quant.eltsNotEqual(new int[] {-1, -1, -1, -1}, 1));
366    assertFalse(Quant.eltsNotEqual(new int[] {1, 1, 1, 1}, 1));
367  }
368
369  @Test
370  public void test_eltsGT() {
371    assertTrue(Quant.eltsGT(new int[] {}, 0));
372    assertTrue(Quant.eltsGT(new int[] {1}, -1));
373    assertFalse(Quant.eltsGT(new int[] {1}, 1));
374    assertFalse(Quant.eltsGT(new int[] {-1}, 1));
375    assertFalse(Quant.eltsGT(new int[] {-1}, -1));
376    assertFalse(Quant.eltsGT(new int[] {-1, 1}, 1));
377    assertFalse(Quant.eltsGT(new int[] {-1, 1}, -1));
378    assertTrue(Quant.eltsGT(new int[] {1, 2, 3}, 0));
379    assertFalse(Quant.eltsGT(new int[] {1, 2, 3}, 1));
380    assertFalse(Quant.eltsGT(new int[] {1, 2, 3}, 2));
381    assertFalse(Quant.eltsGT(new int[] {1, 2, 3}, 3));
382    assertFalse(Quant.eltsGT(new int[] {1, 2, 3}, 4));
383    assertTrue(Quant.eltsGT(new int[] {2, 3, 2, 3}, 1));
384    assertFalse(Quant.eltsGT(new int[] {2, 3, 2, 3}, 2));
385    assertFalse(Quant.eltsGT(new int[] {2, 3, 2, 3}, 3));
386    assertTrue(Quant.eltsGT(new int[] {3, 3, 3, 3}, 2));
387    assertFalse(Quant.eltsGT(new int[] {3, 3, 3, 3}, 3));
388  }
389
390  @Test
391  public void test_eltsGTE() {
392    assertTrue(Quant.eltsGTE(new int[] {}, 0));
393    assertTrue(Quant.eltsGTE(new int[] {1}, -1));
394    assertTrue(Quant.eltsGTE(new int[] {1}, 1));
395    assertFalse(Quant.eltsGTE(new int[] {-1}, 1));
396    assertTrue(Quant.eltsGTE(new int[] {-1}, -1));
397    assertFalse(Quant.eltsGTE(new int[] {-1, 1}, 1));
398    assertTrue(Quant.eltsGTE(new int[] {-1, 1}, -1));
399    assertTrue(Quant.eltsGTE(new int[] {1, 2, 3}, 0));
400    assertTrue(Quant.eltsGTE(new int[] {1, 2, 3}, 1));
401    assertFalse(Quant.eltsGTE(new int[] {1, 2, 3}, 2));
402    assertFalse(Quant.eltsGTE(new int[] {1, 2, 3}, 3));
403    assertFalse(Quant.eltsGTE(new int[] {1, 2, 3}, 4));
404    assertTrue(Quant.eltsGTE(new int[] {2, 3, 2, 3}, 1));
405    assertTrue(Quant.eltsGTE(new int[] {2, 3, 2, 3}, 2));
406    assertFalse(Quant.eltsGTE(new int[] {2, 3, 2, 3}, 3));
407    assertTrue(Quant.eltsGTE(new int[] {3, 3, 3, 3}, 2));
408    assertTrue(Quant.eltsGTE(new int[] {3, 3, 3, 3}, 3));
409  }
410
411  @Test
412  public void test_eltsLT() {
413    assertTrue(Quant.eltsLT(new int[] {}, 0));
414    assertFalse(Quant.eltsLT(new int[] {1}, -1));
415    assertFalse(Quant.eltsLT(new int[] {1}, 1));
416    assertTrue(Quant.eltsLT(new int[] {-1}, 1));
417    assertFalse(Quant.eltsLT(new int[] {-1}, -1));
418    assertFalse(Quant.eltsLT(new int[] {-1, 1}, 1));
419    assertFalse(Quant.eltsLT(new int[] {-1, 1}, -1));
420    assertFalse(Quant.eltsLT(new int[] {1, 2, 3}, 0));
421    assertFalse(Quant.eltsLT(new int[] {1, 2, 3}, 1));
422    assertFalse(Quant.eltsLT(new int[] {1, 2, 3}, 2));
423    assertFalse(Quant.eltsLT(new int[] {1, 2, 3}, 3));
424    assertTrue(Quant.eltsLT(new int[] {1, 2, 3}, 4));
425    assertFalse(Quant.eltsLT(new int[] {2, 3, 2, 3}, 1));
426    assertFalse(Quant.eltsLT(new int[] {2, 3, 2, 3}, 2));
427    assertFalse(Quant.eltsLT(new int[] {2, 3, 2, 3}, 3));
428    assertFalse(Quant.eltsLT(new int[] {3, 3, 3, 3}, 2));
429    assertFalse(Quant.eltsLT(new int[] {3, 3, 3, 3}, 3));
430  }
431
432  @Test
433  public void test_eltsLTE() {
434    assertTrue(Quant.eltsLTE(new int[] {}, 0));
435    assertFalse(Quant.eltsLTE(new int[] {1}, -1));
436    assertTrue(Quant.eltsLTE(new int[] {1}, 1));
437    assertTrue(Quant.eltsLTE(new int[] {-1}, 1));
438    assertTrue(Quant.eltsLTE(new int[] {-1}, -1));
439    assertTrue(Quant.eltsLTE(new int[] {-1, 1}, 1));
440    assertFalse(Quant.eltsLTE(new int[] {-1, 1}, -1));
441    assertFalse(Quant.eltsLTE(new int[] {1, 2, 3}, 0));
442    assertFalse(Quant.eltsLTE(new int[] {1, 2, 3}, 1));
443    assertFalse(Quant.eltsLTE(new int[] {1, 2, 3}, 2));
444    assertTrue(Quant.eltsLTE(new int[] {1, 2, 3}, 3));
445    assertTrue(Quant.eltsLTE(new int[] {1, 2, 3}, 4));
446    assertFalse(Quant.eltsLTE(new int[] {2, 3, 2, 3}, 1));
447    assertFalse(Quant.eltsLTE(new int[] {2, 3, 2, 3}, 2));
448    assertTrue(Quant.eltsLTE(new int[] {2, 3, 2, 3}, 3));
449    assertFalse(Quant.eltsLTE(new int[] {3, 3, 3, 3}, 2));
450    assertTrue(Quant.eltsLTE(new int[] {3, 3, 3, 3}, 3));
451  }
452
453  @Test
454  public void test_pairwiseEqual() {
455    assertTrue(Quant.pairwiseEqual(new int[] {}, new int[] {}));
456    assertFalse(Quant.pairwiseEqual(new int[] {1}, new int[] {}));
457    assertFalse(Quant.pairwiseEqual(new int[] {}, new int[] {1}));
458    assertTrue(Quant.pairwiseEqual(new int[] {1}, new int[] {1}));
459    assertFalse(Quant.pairwiseEqual(new int[] {1, 2}, new int[] {1, 2, 3}));
460    assertTrue(Quant.pairwiseEqual(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
461    assertFalse(Quant.pairwiseEqual(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
462    assertFalse(Quant.pairwiseEqual(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
463    assertFalse(Quant.pairwiseEqual(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
464  }
465
466  @Test
467  public void test_pairwiseNotEqual() {
468    assertTrue(Quant.pairwiseNotEqual(new int[] {}, new int[] {}));
469    assertFalse(Quant.pairwiseNotEqual(new int[] {1}, new int[] {}));
470    assertFalse(Quant.pairwiseNotEqual(new int[] {}, new int[] {1}));
471    assertFalse(Quant.pairwiseNotEqual(new int[] {1}, new int[] {1}));
472    assertFalse(Quant.pairwiseNotEqual(new int[] {1, 2}, new int[] {1, 2, 3}));
473    assertFalse(Quant.pairwiseNotEqual(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
474    assertFalse(Quant.pairwiseNotEqual(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
475    assertTrue(Quant.pairwiseNotEqual(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
476    assertFalse(Quant.pairwiseNotEqual(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
477  }
478
479  @Test
480  public void test_pairwiseLT() {
481    assertTrue(Quant.pairwiseLT(new int[] {}, new int[] {}));
482    assertFalse(Quant.pairwiseLT(new int[] {1}, new int[] {}));
483    assertFalse(Quant.pairwiseLT(new int[] {}, new int[] {1}));
484    assertFalse(Quant.pairwiseLT(new int[] {1}, new int[] {1}));
485    assertFalse(Quant.pairwiseLT(new int[] {1, 2}, new int[] {1, 2, 3}));
486    assertFalse(Quant.pairwiseLT(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
487    assertTrue(Quant.pairwiseLT(new int[] {1, 2, 3}, new int[] {2, 3, 4}));
488    assertFalse(Quant.pairwiseLT(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
489    assertFalse(Quant.pairwiseLT(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
490    assertFalse(Quant.pairwiseLT(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
491  }
492
493  @Test
494  public void test_pairwiseLTE() {
495    assertTrue(Quant.pairwiseLTE(new int[] {}, new int[] {}));
496    assertFalse(Quant.pairwiseLTE(new int[] {1}, new int[] {}));
497    assertFalse(Quant.pairwiseLTE(new int[] {}, new int[] {1}));
498    assertTrue(Quant.pairwiseLTE(new int[] {1}, new int[] {1}));
499    assertFalse(Quant.pairwiseLTE(new int[] {1, 2}, new int[] {1, 2, 3}));
500    assertTrue(Quant.pairwiseLTE(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
501    assertTrue(Quant.pairwiseLTE(new int[] {1, 2, 3}, new int[] {2, 3, 4}));
502    assertFalse(Quant.pairwiseLTE(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
503    assertFalse(Quant.pairwiseLTE(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
504    assertFalse(Quant.pairwiseLTE(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
505  }
506
507  @Test
508  public void test_pairwiseGT() {
509    assertTrue(Quant.pairwiseGT(new int[] {}, new int[] {}));
510    assertFalse(Quant.pairwiseGT(new int[] {1}, new int[] {}));
511    assertFalse(Quant.pairwiseGT(new int[] {}, new int[] {1}));
512    assertFalse(Quant.pairwiseGT(new int[] {1}, new int[] {1}));
513    assertFalse(Quant.pairwiseGT(new int[] {1, 2}, new int[] {1, 2, 3}));
514    assertFalse(Quant.pairwiseGT(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
515    assertFalse(Quant.pairwiseGT(new int[] {1, 2, 3}, new int[] {2, 3, 4}));
516    assertTrue(Quant.pairwiseGT(new int[] {2, 3, 4}, new int[] {1, 2, 3}));
517    assertFalse(Quant.pairwiseGT(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
518    assertFalse(Quant.pairwiseGT(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
519    assertFalse(Quant.pairwiseGT(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
520  }
521
522  @Test
523  public void test_pairwiseGTE() {
524    assertTrue(Quant.pairwiseGTE(new int[] {}, new int[] {}));
525    assertFalse(Quant.pairwiseGTE(new int[] {1}, new int[] {}));
526    assertFalse(Quant.pairwiseGTE(new int[] {}, new int[] {1}));
527    assertTrue(Quant.pairwiseGTE(new int[] {1}, new int[] {1}));
528    assertFalse(Quant.pairwiseGTE(new int[] {1, 2}, new int[] {1, 2, 3}));
529    assertTrue(Quant.pairwiseGTE(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
530    assertFalse(Quant.pairwiseGTE(new int[] {1, 2, 3}, new int[] {2, 3, 4}));
531    assertTrue(Quant.pairwiseGTE(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
532    assertFalse(Quant.pairwiseGTE(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
533    assertFalse(Quant.pairwiseGTE(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
534  }
535
536  @Test
537  public void test_eltwiseEqual() {
538    assertTrue(Quant.eltwiseEqual(new int[] {}));
539    assertTrue(Quant.eltwiseEqual(new int[] {1}));
540    assertTrue(Quant.eltwiseEqual(new int[] {-1}));
541    assertFalse(Quant.eltwiseEqual(new int[] {-1, 1}));
542    assertTrue(Quant.eltwiseEqual(new int[] {1, 1}));
543    assertFalse(Quant.eltwiseEqual(new int[] {1, 2, 3}));
544    assertFalse(Quant.eltwiseEqual(new int[] {2, 3, 1}));
545    assertFalse(Quant.eltwiseEqual(new int[] {3, 2, 1}));
546    assertFalse(Quant.eltwiseEqual(new int[] {2, 3, 3, 3}));
547    assertFalse(Quant.eltwiseEqual(new int[] {2, 3, 3, 4}));
548    assertFalse(Quant.eltwiseEqual(new int[] {3, 3, 3, 2}));
549    assertFalse(Quant.eltwiseEqual(new int[] {4, 3, 3, 2}));
550    assertTrue(Quant.eltwiseEqual(new int[] {3, 3, 3, 3}));
551    assertFalse(Quant.eltwiseEqual(new int[] {2, 3, 2, 3}));
552    assertFalse(Quant.eltwiseEqual(new int[] {-1, 1, 2, 3, 4, 5, 6}));
553  }
554
555  @Test
556  public void test_eltwiseNotEqual() {
557    assertTrue(Quant.eltwiseNotEqual(new int[] {}));
558    assertTrue(Quant.eltwiseNotEqual(new int[] {1}));
559    assertTrue(Quant.eltwiseNotEqual(new int[] {-1}));
560    assertTrue(Quant.eltwiseNotEqual(new int[] {-1, 1}));
561    assertFalse(Quant.eltwiseNotEqual(new int[] {1, 1}));
562    assertTrue(Quant.eltwiseNotEqual(new int[] {1, 2, 3}));
563    assertTrue(Quant.eltwiseNotEqual(new int[] {2, 3, 1}));
564    assertTrue(Quant.eltwiseNotEqual(new int[] {3, 2, 1}));
565    assertFalse(Quant.eltwiseNotEqual(new int[] {2, 3, 3, 3}));
566    assertFalse(Quant.eltwiseNotEqual(new int[] {2, 3, 3, 4}));
567    assertFalse(Quant.eltwiseNotEqual(new int[] {3, 3, 3, 2}));
568    assertFalse(Quant.eltwiseNotEqual(new int[] {4, 3, 3, 2}));
569    assertFalse(Quant.eltwiseNotEqual(new int[] {3, 3, 3, 3}));
570    assertTrue(Quant.eltwiseNotEqual(new int[] {2, 3, 2, 3}));
571    assertTrue(Quant.eltwiseNotEqual(new int[] {-1, 1, 2, 3, 4, 5, 6}));
572  }
573
574  @Test
575  public void test_eltwiseLT() {
576    assertTrue(Quant.eltwiseLT(new int[] {}));
577    assertTrue(Quant.eltwiseLT(new int[] {1}));
578    assertTrue(Quant.eltwiseLT(new int[] {-1}));
579    assertTrue(Quant.eltwiseLT(new int[] {-1, 1}));
580    assertFalse(Quant.eltwiseLT(new int[] {1, 1}));
581    assertTrue(Quant.eltwiseLT(new int[] {1, 2, 3}));
582    assertFalse(Quant.eltwiseLT(new int[] {2, 3, 1}));
583    assertFalse(Quant.eltwiseLT(new int[] {3, 2, 1}));
584    assertFalse(Quant.eltwiseLT(new int[] {2, 3, 3, 3}));
585    assertFalse(Quant.eltwiseLT(new int[] {2, 3, 3, 4}));
586    assertFalse(Quant.eltwiseLT(new int[] {3, 3, 3, 2}));
587    assertFalse(Quant.eltwiseLT(new int[] {4, 3, 3, 2}));
588    assertFalse(Quant.eltwiseLT(new int[] {3, 3, 3, 3}));
589    assertFalse(Quant.eltwiseLT(new int[] {2, 3, 2, 3}));
590    assertTrue(Quant.eltwiseLT(new int[] {-1, 1, 2, 3, 4, 5, 6}));
591  }
592
593  @Test
594  public void test_eltwiseLTE() {
595    assertTrue(Quant.eltwiseLTE(new int[] {}));
596    assertTrue(Quant.eltwiseLTE(new int[] {1}));
597    assertTrue(Quant.eltwiseLTE(new int[] {-1}));
598    assertTrue(Quant.eltwiseLTE(new int[] {-1, 1}));
599    assertTrue(Quant.eltwiseLTE(new int[] {1, 1}));
600    assertTrue(Quant.eltwiseLTE(new int[] {1, 2, 3}));
601    assertFalse(Quant.eltwiseLTE(new int[] {2, 3, 1}));
602    assertFalse(Quant.eltwiseLTE(new int[] {3, 2, 1}));
603    assertTrue(Quant.eltwiseLTE(new int[] {2, 3, 3, 3}));
604    assertTrue(Quant.eltwiseLTE(new int[] {2, 3, 3, 4}));
605    assertFalse(Quant.eltwiseLTE(new int[] {3, 3, 3, 2}));
606    assertFalse(Quant.eltwiseLTE(new int[] {4, 3, 3, 2}));
607    assertTrue(Quant.eltwiseLTE(new int[] {3, 3, 3, 3}));
608    assertFalse(Quant.eltwiseLTE(new int[] {2, 3, 2, 3}));
609    assertTrue(Quant.eltwiseLTE(new int[] {-1, 1, 2, 3, 4, 5, 6}));
610  }
611
612  @Test
613  public void test_eltwiseGT() {
614    assertTrue(Quant.eltwiseGT(new int[] {}));
615    assertTrue(Quant.eltwiseGT(new int[] {1}));
616    assertTrue(Quant.eltwiseGT(new int[] {-1}));
617    assertFalse(Quant.eltwiseGT(new int[] {-1, 1}));
618    assertFalse(Quant.eltwiseGT(new int[] {1, 1}));
619    assertFalse(Quant.eltwiseGT(new int[] {1, 2, 3}));
620    assertFalse(Quant.eltwiseGT(new int[] {2, 3, 1}));
621    assertTrue(Quant.eltwiseGT(new int[] {3, 2, 1}));
622    assertFalse(Quant.eltwiseGT(new int[] {2, 3, 3, 3}));
623    assertFalse(Quant.eltwiseGT(new int[] {2, 3, 3, 4}));
624    assertFalse(Quant.eltwiseGT(new int[] {3, 3, 3, 2}));
625    assertFalse(Quant.eltwiseGT(new int[] {4, 3, 3, 2}));
626    assertFalse(Quant.eltwiseGT(new int[] {3, 3, 3, 3}));
627    assertFalse(Quant.eltwiseGT(new int[] {2, 3, 2, 3}));
628    assertFalse(Quant.eltwiseGT(new int[] {-1, 1, 2, 3, 4, 5, 6}));
629  }
630
631  @Test
632  public void test_eltwiseGTE() {
633    assertTrue(Quant.eltwiseGTE(new int[] {}));
634    assertTrue(Quant.eltwiseGTE(new int[] {1}));
635    assertTrue(Quant.eltwiseGTE(new int[] {-1}));
636    assertFalse(Quant.eltwiseGTE(new int[] {-1, 1}));
637    assertTrue(Quant.eltwiseGTE(new int[] {1, 1}));
638    assertFalse(Quant.eltwiseGTE(new int[] {1, 2, 3}));
639    assertFalse(Quant.eltwiseGTE(new int[] {2, 3, 1}));
640    assertTrue(Quant.eltwiseGTE(new int[] {3, 2, 1}));
641    assertFalse(Quant.eltwiseGTE(new int[] {2, 3, 3, 3}));
642    assertFalse(Quant.eltwiseGTE(new int[] {2, 3, 3, 4}));
643    assertTrue(Quant.eltwiseGTE(new int[] {3, 3, 3, 2}));
644    assertTrue(Quant.eltwiseGTE(new int[] {4, 3, 3, 2}));
645    assertTrue(Quant.eltwiseGTE(new int[] {3, 3, 3, 3}));
646    assertFalse(Quant.eltwiseGTE(new int[] {2, 3, 2, 3}));
647    assertFalse(Quant.eltwiseGTE(new int[] {-1, 1, 2, 3, 4, 5, 6}));
648  }
649
650  @Test
651  public void test_eltsEqualIndex() {
652    assertTrue(Quant.eltsEqualIndex(new int[] {}));
653    assertTrue(Quant.eltsEqualIndex(new int[] {0}));
654    assertFalse(Quant.eltsEqualIndex(new int[] {1}));
655    assertFalse(Quant.eltsEqualIndex(new int[] {-1}));
656    assertFalse(Quant.eltsEqualIndex(new int[] {-1, -1, 1}));
657    assertFalse(Quant.eltsEqualIndex(new int[] {-1, 0, 1}));
658    assertFalse(Quant.eltsEqualIndex(new int[] {-1, 1, 1}));
659    assertFalse(Quant.eltsEqualIndex(new int[] {0, 0, 2}));
660    assertTrue(Quant.eltsEqualIndex(new int[] {0, 1, 2}));
661    assertFalse(Quant.eltsEqualIndex(new int[] {0, 2, 2}));
662    assertFalse(Quant.eltsEqualIndex(new int[] {1, 1, 3}));
663    assertFalse(Quant.eltsEqualIndex(new int[] {1, 2, 3}));
664    assertFalse(Quant.eltsEqualIndex(new int[] {1, 3, 3}));
665  }
666
667  @Test
668  public void test_eltsNotEqualIndex() {
669    assertTrue(Quant.eltsNotEqualIndex(new int[] {}));
670    assertFalse(Quant.eltsNotEqualIndex(new int[] {0}));
671    assertTrue(Quant.eltsNotEqualIndex(new int[] {1}));
672    assertTrue(Quant.eltsNotEqualIndex(new int[] {-1}));
673    assertTrue(Quant.eltsNotEqualIndex(new int[] {-1, -1, 1}));
674    assertTrue(Quant.eltsNotEqualIndex(new int[] {-1, 0, 1}));
675    assertFalse(Quant.eltsNotEqualIndex(new int[] {-1, 1, 1}));
676    assertFalse(Quant.eltsNotEqualIndex(new int[] {0, 0, 2}));
677    assertFalse(Quant.eltsNotEqualIndex(new int[] {0, 1, 2}));
678    assertFalse(Quant.eltsNotEqualIndex(new int[] {0, 2, 2}));
679    assertFalse(Quant.eltsNotEqualIndex(new int[] {1, 1, 3}));
680    assertTrue(Quant.eltsNotEqualIndex(new int[] {1, 2, 3}));
681    assertTrue(Quant.eltsNotEqualIndex(new int[] {1, 3, 3}));
682  }
683
684  @Test
685  public void test_eltsGteIndex() {
686    assertTrue(Quant.eltsGteIndex(new int[] {}));
687    assertTrue(Quant.eltsGteIndex(new int[] {0}));
688    assertTrue(Quant.eltsGteIndex(new int[] {1}));
689    assertFalse(Quant.eltsGteIndex(new int[] {-1}));
690    assertFalse(Quant.eltsGteIndex(new int[] {-1, -1, 1}));
691    assertFalse(Quant.eltsGteIndex(new int[] {-1, 0, 1}));
692    assertFalse(Quant.eltsGteIndex(new int[] {-1, 1, 1}));
693    assertFalse(Quant.eltsGteIndex(new int[] {0, 0, 2}));
694    assertTrue(Quant.eltsGteIndex(new int[] {0, 1, 2}));
695    assertTrue(Quant.eltsGteIndex(new int[] {0, 2, 2}));
696    assertTrue(Quant.eltsGteIndex(new int[] {1, 1, 3}));
697    assertTrue(Quant.eltsGteIndex(new int[] {1, 2, 3}));
698    assertTrue(Quant.eltsGteIndex(new int[] {1, 3, 3}));
699  }
700
701  @Test
702  public void test_eltsGtIndex() {
703    assertTrue(Quant.eltsGtIndex(new int[] {}));
704    assertFalse(Quant.eltsGtIndex(new int[] {0}));
705    assertTrue(Quant.eltsGtIndex(new int[] {1}));
706    assertFalse(Quant.eltsGtIndex(new int[] {-1}));
707    assertFalse(Quant.eltsGtIndex(new int[] {-1, -1, 1}));
708    assertFalse(Quant.eltsGtIndex(new int[] {-1, 0, 1}));
709    assertFalse(Quant.eltsGtIndex(new int[] {-1, 1, 1}));
710    assertFalse(Quant.eltsGtIndex(new int[] {0, 0, 2}));
711    assertFalse(Quant.eltsGtIndex(new int[] {0, 1, 2}));
712    assertFalse(Quant.eltsGtIndex(new int[] {0, 2, 2}));
713    assertFalse(Quant.eltsGtIndex(new int[] {1, 1, 3}));
714    assertTrue(Quant.eltsGtIndex(new int[] {1, 2, 3}));
715    assertTrue(Quant.eltsGtIndex(new int[] {1, 3, 3}));
716  }
717
718  @Test
719  public void test_eltsLteIndex() {
720    assertTrue(Quant.eltsLteIndex(new int[] {}));
721    assertTrue(Quant.eltsLteIndex(new int[] {0}));
722    assertFalse(Quant.eltsLteIndex(new int[] {1}));
723    assertTrue(Quant.eltsLteIndex(new int[] {-1}));
724    assertTrue(Quant.eltsLteIndex(new int[] {-1, -1, 1}));
725    assertTrue(Quant.eltsLteIndex(new int[] {-1, 0, 1}));
726    assertTrue(Quant.eltsLteIndex(new int[] {-1, 1, 1}));
727    assertTrue(Quant.eltsLteIndex(new int[] {0, 0, 2}));
728    assertTrue(Quant.eltsLteIndex(new int[] {0, 1, 2}));
729    assertFalse(Quant.eltsLteIndex(new int[] {0, 2, 2}));
730    assertFalse(Quant.eltsLteIndex(new int[] {1, 1, 3}));
731    assertFalse(Quant.eltsLteIndex(new int[] {1, 2, 3}));
732    assertFalse(Quant.eltsLteIndex(new int[] {1, 3, 3}));
733  }
734
735  @Test
736  public void test_eltsLtIndex() {
737    assertTrue(Quant.eltsLtIndex(new int[] {}));
738    assertFalse(Quant.eltsLtIndex(new int[] {0}));
739    assertFalse(Quant.eltsLtIndex(new int[] {1}));
740    assertTrue(Quant.eltsLtIndex(new int[] {-1}));
741    assertTrue(Quant.eltsLtIndex(new int[] {-1, -1, 1}));
742    assertTrue(Quant.eltsLtIndex(new int[] {-1, 0, 1}));
743    assertFalse(Quant.eltsLtIndex(new int[] {-1, 1, 1}));
744    assertFalse(Quant.eltsLtIndex(new int[] {0, 0, 2}));
745    assertFalse(Quant.eltsLtIndex(new int[] {0, 1, 2}));
746    assertFalse(Quant.eltsLtIndex(new int[] {0, 2, 2}));
747    assertFalse(Quant.eltsLtIndex(new int[] {1, 1, 3}));
748    assertFalse(Quant.eltsLtIndex(new int[] {1, 2, 3}));
749    assertFalse(Quant.eltsLtIndex(new int[] {1, 3, 3}));
750  }
751
752  @Test
753  public void test_lexEqual() {
754    assertTrue(Quant.lexEqual(new int[] {}, new int[] {}));
755    assertFalse(Quant.lexEqual(new int[] {1}, new int[] {}));
756    assertFalse(Quant.lexEqual(new int[] {}, new int[] {1}));
757    assertTrue(Quant.lexEqual(new int[] {1}, new int[] {1}));
758    assertFalse(Quant.lexEqual(new int[] {1, 2}, new int[] {1, 2, 3}));
759    assertTrue(Quant.lexEqual(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
760    assertFalse(Quant.lexEqual(new int[] {1, 2, 3}, new int[] {2, 3, 4}));
761    assertFalse(Quant.lexEqual(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
762    assertFalse(Quant.lexEqual(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
763    assertFalse(Quant.lexEqual(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
764  }
765
766  @Test
767  public void test_lexNotEqual() {
768    assertFalse(Quant.lexNotEqual(new int[] {}, new int[] {}));
769    assertTrue(Quant.lexNotEqual(new int[] {1}, new int[] {}));
770    assertTrue(Quant.lexNotEqual(new int[] {}, new int[] {1}));
771    assertFalse(Quant.lexNotEqual(new int[] {1}, new int[] {1}));
772    assertTrue(Quant.lexNotEqual(new int[] {1, 2}, new int[] {1, 2, 3}));
773    assertFalse(Quant.lexNotEqual(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
774    assertTrue(Quant.lexNotEqual(new int[] {1, 2, 3}, new int[] {2, 3, 4}));
775    assertTrue(Quant.lexNotEqual(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
776    assertTrue(Quant.lexNotEqual(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
777    assertTrue(Quant.lexNotEqual(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
778  }
779
780  @Test
781  public void test_lexLT() {
782    assertFalse(Quant.lexLT(new int[] {}, new int[] {}));
783    assertFalse(Quant.lexLT(new int[] {1}, new int[] {}));
784    assertTrue(Quant.lexLT(new int[] {}, new int[] {1}));
785    assertFalse(Quant.lexLT(new int[] {1}, new int[] {1}));
786    assertTrue(Quant.lexLT(new int[] {1, 2}, new int[] {1, 2, 3}));
787    assertFalse(Quant.lexLT(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
788    assertTrue(Quant.lexLT(new int[] {1, 2, 3}, new int[] {2, 3, 4}));
789    assertFalse(Quant.lexLT(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
790    assertTrue(Quant.lexLT(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
791    assertTrue(Quant.lexLT(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
792  }
793
794  @Test
795  public void test_lexLTE() {
796    assertTrue(Quant.lexLTE(new int[] {}, new int[] {}));
797    assertFalse(Quant.lexLTE(new int[] {1}, new int[] {}));
798    assertTrue(Quant.lexLTE(new int[] {}, new int[] {1}));
799    assertTrue(Quant.lexLTE(new int[] {1}, new int[] {1}));
800    assertTrue(Quant.lexLTE(new int[] {1, 2}, new int[] {1, 2, 3}));
801    assertTrue(Quant.lexLTE(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
802    assertTrue(Quant.lexLTE(new int[] {1, 2, 3}, new int[] {2, 3, 4}));
803    assertFalse(Quant.lexLTE(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
804    assertTrue(Quant.lexLTE(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
805    assertTrue(Quant.lexLTE(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
806  }
807
808  @Test
809  public void test_lexGT() {
810    assertFalse(Quant.lexGT(new int[] {}, new int[] {}));
811    assertTrue(Quant.lexGT(new int[] {1}, new int[] {}));
812    assertFalse(Quant.lexGT(new int[] {}, new int[] {1}));
813    assertFalse(Quant.lexGT(new int[] {1}, new int[] {1}));
814    assertFalse(Quant.lexGT(new int[] {1, 2}, new int[] {1, 2, 3}));
815    assertFalse(Quant.lexGT(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
816    assertFalse(Quant.lexGT(new int[] {1, 2, 3}, new int[] {2, 3, 4}));
817    assertTrue(Quant.lexGT(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
818    assertFalse(Quant.lexGT(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
819    assertFalse(Quant.lexGT(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
820  }
821
822  @Test
823  public void test_lexGTE() {
824    assertTrue(Quant.lexGTE(new int[] {}, new int[] {}));
825    assertTrue(Quant.lexGTE(new int[] {1}, new int[] {}));
826    assertFalse(Quant.lexGTE(new int[] {}, new int[] {1}));
827    assertTrue(Quant.lexGTE(new int[] {1}, new int[] {1}));
828    assertFalse(Quant.lexGTE(new int[] {1, 2}, new int[] {1, 2, 3}));
829    assertTrue(Quant.lexGTE(new int[] {1, 2, 3}, new int[] {1, 2, 3}));
830    assertFalse(Quant.lexGTE(new int[] {1, 2, 3}, new int[] {2, 3, 4}));
831    assertTrue(Quant.lexGTE(new int[] {1, 2, 3}, new int[] {1, 2, 2}));
832    assertFalse(Quant.lexGTE(new int[] {1, 2, 3}, new int[] {2, 3, 1}));
833    assertFalse(Quant.lexGTE(new int[] {1, 2, 3}, new int[] {3, 2, 1}));
834  }
835
836  @Test
837  public void test_pairwiseDivides() {
838    assertTrue(Quant.pairwiseDivides(new int[] {}, new int[] {}));
839    assertFalse(Quant.pairwiseDivides(new int[] {}, new int[] {1}));
840    assertFalse(Quant.pairwiseDivides(new int[] {1}, new int[] {}));
841    assertTrue(Quant.pairwiseDivides(new int[] {1}, new int[] {1}));
842    assertTrue(Quant.pairwiseDivides(new int[] {4}, new int[] {2}));
843    assertTrue(Quant.pairwiseDivides(new int[] {27}, new int[] {3}));
844    assertFalse(Quant.pairwiseDivides(new int[] {27}, new int[] {4}));
845    assertTrue(Quant.pairwiseDivides(new int[] {1, 6, 6}, new int[] {1, 2, 3}));
846    assertTrue(Quant.pairwiseDivides(new int[] {1, -6, 6}, new int[] {1, 2, 3}));
847    assertFalse(Quant.pairwiseDivides(new int[] {1, 6, 7}, new int[] {1, 2, 3}));
848  }
849
850  @Test
851  public void test_pairwiseSquare() {
852    assertTrue(Quant.pairwiseSquare(new int[] {}, new int[] {}));
853    assertFalse(Quant.pairwiseSquare(new int[] {}, new int[] {1}));
854    assertFalse(Quant.pairwiseSquare(new int[] {1}, new int[] {}));
855    assertTrue(Quant.pairwiseSquare(new int[] {1}, new int[] {1}));
856    assertTrue(Quant.pairwiseSquare(new int[] {4}, new int[] {2}));
857    assertFalse(Quant.pairwiseSquare(new int[] {27}, new int[] {3}));
858    assertFalse(Quant.pairwiseSquare(new int[] {27}, new int[] {4}));
859    assertTrue(Quant.pairwiseSquare(new int[] {1, 4, 9}, new int[] {1, 2, 3}));
860    assertFalse(Quant.pairwiseSquare(new int[] {1, -4, 9}, new int[] {1, 2, 3}));
861    assertFalse(Quant.pairwiseSquare(new int[] {1, 4, 10}, new int[] {1, 2, 3}));
862  }
863
864  @Test
865  public void test_pairwiseBitwiseComplement() {
866    assertTrue(Quant.pairwiseBitwiseComplement(new int[] {}, new int[] {}));
867    assertTrue(Quant.pairwiseBitwiseComplement(new int[] {3, 3}, new int[] {-4, -4}));
868    assertFalse(Quant.pairwiseBitwiseComplement(new int[] {3, 3}, new int[] {3, -4}));
869    assertTrue(Quant.pairwiseBitwiseComplement(new int[] {3, 21, 0}, new int[] {-4, -22, -1}));
870  }
871
872  @Test
873  public void test_pairwiseBitwiseSubset() {
874    assertTrue(Quant.pairwiseBitwiseSubset(new int[] {}, new int[] {}));
875    assertTrue(Quant.pairwiseBitwiseSubset(new int[] {5, 5}, new int[] {4, 1}));
876    assertFalse(Quant.pairwiseBitwiseSubset(new int[] {5, 5}, new int[] {4, 3}));
877  }
878
879  public static class Foo1 {
880    public Bar1 x;
881    public static Bar1 xstatic;
882  }
883
884  public static class Bar1 {
885    private Baz1 y;
886
887    public void set_y(Baz1 o) {
888      y = o;
889    }
890
891    public Baz1f yf;
892  }
893
894  public static class Baz1 {
895    public int[] z;
896  }
897
898  public static class Baz1f {
899    public int z;
900  }
901
902  public static class Foo2 {
903    public Object[] x;
904    private static Object xstatic;
905
906    public static void set_xstatic(Object o) {
907      xstatic = o;
908    }
909  }
910
911  public static class Foo2f {
912    private Object x;
913
914    public void set_x(Object o) {
915      x = o;
916    }
917  }
918
919  public static class Foo3 {
920    private Bar3[] x;
921
922    public void set_x(Bar3[] o) {
923      x = o;
924    }
925  }
926
927  public static class Foo3f {
928    public Bar3 x;
929  }
930
931  public static class Bar3 {
932    public Baz3 y;
933  }
934
935  public static class Baz3 {
936    public int z;
937  }
938
939  public static class Foo3a {
940    private java.util.List<Bar3a> x;
941
942    public void set_x(java.util.List<Bar3a> o) {
943      x = o;
944    }
945  }
946
947  public static class Foo3af {
948    public Bar3a x;
949  }
950
951  public static class Bar3a {
952    public Baz3a y;
953  }
954
955  public static class Baz3a {
956    public int z;
957  }
958
959  public static class Foo4 {
960    public Bar4 x;
961  }
962
963  public static class Bar4 {
964    private Baz4[] y;
965
966    public void set_y(Baz4[] o) {
967      y = o;
968    }
969  }
970
971  public static class Bar4f {
972    public Baz4 y;
973  }
974
975  public static class Baz4 {
976    public String z;
977  }
978
979  @Test
980  public void testCollect() {
981
982    Foo1 f1 = new Foo1();
983    f1.x = new Bar1();
984    f1.x.y = new Baz1();
985    f1.x.y.z = new int[] {1, 2, 3, 4};
986    assert_arrays_equals(Quant.collectint(f1, "x.y.z"), new int[] {1, 2, 3, 4});
987
988    Foo2 f2 = new Foo2();
989    f2.x = new Object[] {null, "hi", "foobar"};
990    Object[] a1 = Quant.collectObject(f2, "x");
991    assertNull(a1[0]);
992    assertEquals("hi", a1[1]);
993    assertEquals("foobar", a1[2]);
994
995    Bar3 b3 = new Bar3();
996    b3.y = new Baz3();
997    b3.y.z = 7;
998    Bar3 b4 = new Bar3();
999    b4.y = new Baz3();
1000    b4.y.z = 8;
1001    Bar3 b5 = new Bar3();
1002    b5.y = new Baz3();
1003    b5.y.z = 9;
1004    Foo3 f3 = new Foo3();
1005    f3.x = new Bar3[] {b3, b4, b5};
1006    assert_arrays_equals(Quant.collectint(f3, "x.y.z"), new int[] {7, 8, 9});
1007
1008    Bar3a b3a = new Bar3a();
1009    b3a.y = new Baz3a();
1010    b3a.y.z = 7;
1011    Bar3a b4a = new Bar3a();
1012    b4a.y = new Baz3a();
1013    b4a.y.z = 8;
1014    Bar3a b5a = new Bar3a();
1015    b5a.y = new Baz3a();
1016    b5a.y.z = 9;
1017    Foo3a f3a = new Foo3a();
1018    f3a.x = new java.util.ArrayList<Bar3a>();
1019    f3a.x.add(b3a);
1020    f3a.x.add(b4a);
1021    f3a.x.add(b5a);
1022    assert_arrays_equals(Quant.collectint(f3a, "x.y.z"), new int[] {7, 8, 9});
1023
1024    Baz4 z1 = new Baz4();
1025    z1.z = "hi1";
1026    Baz4 z2 = new Baz4();
1027    z2.z = "hi2";
1028    Foo4 f4 = new Foo4();
1029    f4.x = new Bar4();
1030    f4.x.y = new Baz4[] {z1, z2};
1031    String[] a3 = Quant.collectString(f4, "x.y.z");
1032    String[] a4 = new String[] {"hi1", "hi2"};
1033    assertEquals(a4[0], a3[0]);
1034    assertEquals(a4[1], a3[1]);
1035  }
1036
1037  @Test
1038  public void testCollect_field() {
1039
1040    Foo1 f1 = new Foo1();
1041    f1.x = new Bar1();
1042    f1.x.yf = new Baz1f();
1043    f1.x.yf.z = 7;
1044
1045    assertEquals(7, Quant.collectint_field(f1, "x.yf.z"));
1046
1047    Foo2f f2 = new Foo2f();
1048    f2.x = "hi";
1049    Object a1 = Quant.collectObject_field(f2, "x");
1050    assertEquals("hi", a1);
1051
1052    Bar3 b3 = new Bar3();
1053    b3.y = new Baz3();
1054    b3.y.z = 7;
1055    Bar3 b4 = new Bar3();
1056    b4.y = new Baz3();
1057    b4.y.z = 8;
1058    Bar3 b5 = new Bar3();
1059    b5.y = new Baz3();
1060    b5.y.z = 9;
1061    assertEquals(7, Quant.collectint_field(b3, "y.z"));
1062    assertEquals(8, Quant.collectint_field(b4, "y.z"));
1063    assertEquals(9, Quant.collectint_field(b5, "y.z"));
1064
1065    Baz4 z1 = new Baz4();
1066    z1.z = "hi1";
1067    Baz4 z2 = new Baz4();
1068    z2.z = "hi2";
1069    assertEquals("hi1", Quant.collectString_field(z1, "z"));
1070    assertEquals("hi2", Quant.collectString_field(z2, "z"));
1071
1072    Foo1.xstatic = new Bar1();
1073    Foo1.xstatic.yf = new Baz1f();
1074    Foo1.xstatic.yf.z = 7;
1075
1076    assertEquals(7, Quant.collectint_field(Foo1.class, "xstatic.yf.z"));
1077
1078    Foo2.set_xstatic("hi");
1079    a1 = Quant.collectObject_field(Foo2.class, "xstatic");
1080    assertEquals("hi", a1);
1081  }
1082}