method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
JosephusProblem { public static int getLastPerson(int n, int k) { if (n <= 0 || k <= 0) { throw new IllegalArgumentException("Input arguments should be positive"); } int lastPerson = 0; for (int i = 2; i <= n; i++) { lastPerson += k; lastPerson %= i; } return lastPerson; } static int getLastPerson(int n, int k); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testGetLastPersonNonPositiveN() { getLastPerson(0, 10); }
@Test(expected = IllegalArgumentException.class) public void testGetLastPersonNonPositiveK() { getLastPerson(10, 0); }
@Test public void testGetLastPerson1() { assertThat(getLastPerson(10, 1), is(9)); }
@Test public void testGetLastPerson2() { assertThat(getLastPerson(10, 2), is(4)); }
@Test public void testGetLastPerson3() { assertThat(getLastPerson(10, 3), is(3)); }
@Test public void testGetLastPerson4() { assertThat(getLastPerson(10, 4), is(4)); }
@Test public void testGetLastPerson5() { assertThat(getLastPerson(10, 5), is(2)); }
@Test public void testGetLastPerson6() { assertThat(getLastPerson(10, 6), is(2)); }
@Test public void testGetLastPerson7() { assertThat(getLastPerson(10, 7), is(8)); }
@Test public void testGetLastPerson8() { assertThat(getLastPerson(10, 8), is(0)); }
@Test public void testGetLastPerson9() { assertThat(getLastPerson(10, 9), is(6)); }
@Test public void testGetLastPerson10() { assertThat(getLastPerson(10, 10), is(7)); }
|
### Question:
RemoveDuplicatesFromArray { public static int[] removeDuplicates(int[] sequence) { if (sequence == null || sequence.length == 0) { return sequence; } Map<Integer, Integer> unique = new HashMap<>(); int cnt = 0; for (int element : sequence) { Integer pos = unique.get(element); if (pos == null) { unique.put(element, cnt); cnt++; } } if (sequence.length == cnt) { return sequence; } int[] result = new int[cnt]; for (Entry<Integer, Integer> entry : unique.entrySet()) { result[entry.getValue()] = entry.getKey(); } return result; } static int[] removeDuplicates(int[] sequence); }### Answer:
@Test public void testRemoveDuplicates() { assertThat(removeDuplicates(actual), is(expected)); }
|
### Question:
StackWithQuickMinOperation { public Integer peekMin() { return minStack.peekFirst(); } StackWithQuickMinOperation(); void push(Integer value); Integer pop(); Integer peek(); Integer peekMin(); int size(); }### Answer:
@Test public void testPeekMin() { StackWithQuickMinOperation stack = new StackWithQuickMinOperation(); stack.push(10); assertThat(stack.peekMin(), is(10)); stack.push(11); assertThat(stack.peekMin(), is(10)); stack.push(12); assertThat(stack.peekMin(), is(10)); stack.push(9); assertThat(stack.peekMin(), is(9)); stack.push(8); assertThat(stack.peekMin(), is(8)); stack.push(15); assertThat(stack.peekMin(), is(8)); stack.push(1); stack.push(2); assertThat(stack.peekMin(), is(1)); }
|
### Question:
Trie { public int getSize() { return size; } Trie(); boolean insertWord(String s); boolean containsWord(String s); boolean containsAsPrefix(String s); boolean containsPrefixOf(String s); int getSize(); }### Answer:
@Test public void testGetSizeEmptyTrie() { Trie trie = new Trie(); assertThat(trie.getSize(), is(0)); }
|
### Question:
DictionaryWordsInTiles { public static String[] findDictionaryWords(String tiles, String[] dictionary) { if (tiles == null || tiles.isEmpty() || dictionary == null || dictionary.length == 0) { return new String[0]; } Map<Character, Integer> tilesMap = new HashMap<>(); for (int i = 0; i < tiles.length(); i++) { Integer cnt = tilesMap.get(tiles.charAt(i)); if (cnt == null) { cnt = 0; } tilesMap.put(tiles.charAt(i), cnt + 1); } List<String> correctWords = new ArrayList<>(); for (String word : dictionary) { boolean accepted = true; Map<Character, Integer> words = new HashMap<>(); for (int j = 0; j < word.length(); j++) { Integer cnt = tilesMap.get(word.charAt(j)); if (cnt == null) { accepted = false; break; } Integer cntInDictionary = words.get(word.charAt(j)); if (cntInDictionary == null) { cntInDictionary = 0; } cntInDictionary++; if (cntInDictionary > cnt) { accepted = false; break; } words.put(word.charAt(j), cntInDictionary); } if (accepted) { correctWords.add(word); } } return correctWords.toArray(new String[correctWords.size()]); } static String[] findDictionaryWords(String tiles, String[] dictionary); }### Answer:
@Test public void testFindDictionaryWords() { String[] acceptedWords = findDictionaryWords(tiles, dictionary); sort(acceptedWords); assertThat("Result does not match for tiles = " + tiles + " and dictionary = " + Arrays.toString(dictionary), acceptedWords, is(expected)); }
|
### Question:
SimpleSpinlock { public V executeWithSpinLock(Callable<V> e) throws Exception { while (true) { while (alreadyLocked()) { } if (!lock()) { continue; } try { return e.call(); } finally { unlock(); } } } V executeWithSpinLock(Callable<V> e); }### Answer:
@Test public void testExecuteWithSpinlockReturnLong() throws Exception { final int THREAD_COUNT = 10; final AtomicInteger cnt = new AtomicInteger(); final ExecutorService executor = Executors .newFixedThreadPool(THREAD_COUNT); for (int i = 0; i < THREAD_COUNT; i++) { executor.submit(new Callable<Long>() { public Long call() throws Exception { long res = simpleSpinlock .executeWithSpinLock(new CallableWithLong()); assertThat("Result is not matched", res, is(0L)); cnt.incrementAndGet(); return res; } }); } executor.shutdown(); executor.awaitTermination(THREAD_COUNT, TimeUnit.SECONDS); assertThat("Only " + cnt.get() + " internal threads were executed", cnt.get(), is(THREAD_COUNT)); }
@Test public void testExecuteWithSpinlockThrowsException() throws Exception { final int THREAD_COUNT = 10; final AtomicInteger cnt = new AtomicInteger(); final ExecutorService executor = Executors .newFixedThreadPool(THREAD_COUNT); for (int i = 0; i < THREAD_COUNT; i++) { executor.submit(new Callable<Long>() { public Long call() throws Exception { try { simpleSpinlock .executeWithSpinLock(new CallableWithException()); fail("Exception should be thrown in CallableWithException.call() invocation"); } catch (Exception ex) { } cnt.incrementAndGet(); return 0L; } }); } executor.shutdown(); executor.awaitTermination(THREAD_COUNT, TimeUnit.SECONDS); assertThat("Only " + cnt.get() + " internal threads were executed", cnt.get(), is(THREAD_COUNT)); }
|
### Question:
ObjectSizeCalculator { public static long sizeOf(Object o) throws IllegalAccessException { return sizeOf(o, CURRENT_JVM_64_BIT); } static long sizeOf(Object o); static long sizeOf(Object o, boolean jvm64bit); }### Answer:
@Test public void testSizeOf() throws IllegalAccessException { long size64bit = sizeOf(object, true); assertThat("SizeOf for " + tcName + " and 64-bit JVM does not match", size64bit, is(result64bit)); long size32bit = sizeOf(object, false); assertThat("SizeOf for " + tcName + " and 32-bit JVM does not match", size32bit, is(result32bit)); }
|
### Question:
UnionFind { public int find(int i) { if (i < 0 || i >= n) { throw new IllegalArgumentException("Input element " + "should be between 0 (inclusive) " + "and " + n + " (exclusive)"); } while (i != roots[i]) { roots[i] = roots[roots[i]]; i = roots[i]; } return i; } UnionFind(int n); int find(int i); int union(int i, int j); int getSubsetSize(int i); int getSubsetsCount(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testFindIllegalArgument1() { UnionFind unionFind = new UnionFind(5); unionFind.find(-1); }
@Test(expected = IllegalArgumentException.class) public void testFindIllegalArgument2() { UnionFind unionFind = new UnionFind(5); unionFind.find(5); }
|
### Question:
UnionFind { public int union(int i, int j) { int firstRoot = find(i); int secondRoot = find(j); if (firstRoot == secondRoot) { return firstRoot; } if (ranks[firstRoot] < ranks[secondRoot]) { roots[firstRoot] = secondRoot; sizes[secondRoot] += sizes[firstRoot]; } else if (ranks[firstRoot] > ranks[secondRoot]) { roots[secondRoot] = firstRoot; sizes[firstRoot] += sizes[secondRoot]; } else { roots[firstRoot] = secondRoot; sizes[secondRoot] += sizes[firstRoot]; ranks[secondRoot]++; } subsetsCount--; return roots[firstRoot]; } UnionFind(int n); int find(int i); int union(int i, int j); int getSubsetSize(int i); int getSubsetsCount(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testUnionIllegalArgument1() { UnionFind unionFind = new UnionFind(5); unionFind.union(0, -1); }
@Test(expected = IllegalArgumentException.class) public void testUnionIllegalArgument2() { UnionFind unionFind = new UnionFind(5); unionFind.union(1, 5); }
|
### Question:
UnionFind { public int getSubsetSize(int i) { return sizes[find(i)]; } UnionFind(int n); int find(int i); int union(int i, int j); int getSubsetSize(int i); int getSubsetsCount(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSubsetSizeIllegalArgument1() { UnionFind unionFind = new UnionFind(5); unionFind.getSubsetSize(-1); }
@Test(expected = IllegalArgumentException.class) public void testSubsetSizeIllegalArgument2() { UnionFind unionFind = new UnionFind(5); unionFind.getSubsetSize(5); }
|
### Question:
NumberUtils { public static List<long[]> findFactoring(long b) { List<long[]> divs = new ArrayList<>(); if (BigInteger.valueOf(b).isProbablePrime(100)) { divs.add(new long[]{b, 1}); return divs; } for (long i = 2; i <= b; i++) { if (b % i == 0) { int deg = 0; while (b % i == 0) { deg++; b /= i; } divs.add(new long[]{i, deg}); if (BigInteger.valueOf(b).isProbablePrime(100)) { divs.add(new long[]{b, 1}); return divs; } } } return divs; } static List<long[]> findFactoring(long b); }### Answer:
@Test public void testFindFactoring() { List<long[]> factoring = findFactoring(value); assertEquals(expected.size(), factoring.size()); for (int i = 0; i < factoring.size(); i++) { assertArrayEquals(expected.get(i), factoring.get(i)); } }
|
### Question:
SegmentTreeMin { public void addValue(int left, int right, int value) { if (left < 0 || right > size) { throw new IllegalArgumentException( "Input left and round bounds should be between zero and segment tree size"); } if (right <= left) { throw new IllegalArgumentException( "Input right bound should be greater than left bound"); } addValue(left, right, value, 0, 0, size); } SegmentTreeMin(int size); void addValue(int left, int right, int value); long getMinimum(int left, int right); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSegmentTreeMinIncorrectBounds1() { SegmentTreeMin tree = new SegmentTreeMin(100); tree.addValue(-1, 10, 100); }
@Test(expected = IllegalArgumentException.class) public void testSegmentTreeMinIncorrectBounds2() { SegmentTreeMin tree = new SegmentTreeMin(100); tree.addValue(1, 101, 10); }
@Test(expected = IllegalArgumentException.class) public void testSegmentTreeMinIncorrectBounds3() { SegmentTreeMin tree = new SegmentTreeMin(100); tree.addValue(10, 10, 101); }
|
### Question:
SegmentTreeSum { public void addValue(int left, int right, long value) { if (left < 0 || right > size) { throw new IllegalArgumentException( "Input left and round bounds should be between zero and segment tree size"); } if (right <= left) { throw new IllegalArgumentException( "Input right bound should be greater than left bound"); } addValue(left, right, value, 0, 0, size); } SegmentTreeSum(int size); void addValue(int left, int right, long value); long getSum(int left, int right); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSegmentTreeSumIncorrectBounds1() { SegmentTreeSum tree = new SegmentTreeSum(100); tree.addValue(-1, 10, 100); }
@Test(expected = IllegalArgumentException.class) public void testSegmentTreeSumIncorrectBounds2() { SegmentTreeSum tree = new SegmentTreeSum(100); tree.addValue(1, 101, 10); }
@Test(expected = IllegalArgumentException.class) public void testSegmentTreeSumIncorrectBounds3() { SegmentTreeSum tree = new SegmentTreeSum(100); tree.addValue(10, 10, 101); }
|
### Question:
MovingSpacesToStartOfString { public static void moveSpaces(char[] str) { if (str == null || str.length == 0) { return; } int i = str.length - 1; int j = str.length - 1; while (i >= 0) { if (str[i] == ' ') { i--; continue; } if (i < j) { char t = str[i]; str[i] = str[j]; str[j] = t; } i--; j--; } while (j >= 0) { str[j--] = ' '; } } static void moveSpaces(char[] str); }### Answer:
@Test public void testMoveSpaces() { String original = str == null ? null : new String(str); moveSpaces(str); assertThat("Result for character array of string = " + original + " is not expected", str, is(expected)); }
|
### Question:
ConvertNumberToExcelNumber { public static String convert(int n) { if (n <= 0) { throw new IllegalArgumentException("Argument is not positive"); } StringBuilder builder = new StringBuilder(); while (n > 0) { n--; int remainder = n % 26; n /= 26; builder.append((char) (remainder + 65)); } return builder.reverse().toString(); } static String convert(int n); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testConvertNegativeN() { convert(-1); }
@Test(expected = IllegalArgumentException.class) public void testConvertZeroN() { convert(0); }
@Test public void testConvert() { assertThat(convert(1), is("A")); assertThat(convert(26), is("Z")); assertThat(convert(27), is("AA")); assertThat(convert(52), is("AZ")); assertThat(convert(53), is("BA")); assertThat(convert(54), is("BB")); assertThat(convert(676), is("YZ")); assertThat(convert(702), is("ZZ")); assertThat(convert(703), is("AAA")); }
|
### Question:
SumOfTwoSquares { public static int findNumberOfWays(int value) { if (value < 0) { return 0; } if (value <= 1) { return 1; } int left = 0; int right = (int) Math.sqrt(value); int numberOfWays = 0; while (left <= right) { long sum = (left + 0L) * left + (right + 0L) * right; if (sum < value) { left++; } else if (sum > value) { right--; } else { numberOfWays++; left++; right--; } } return numberOfWays; } static int findNumberOfWays(int value); }### Answer:
@Test public void testFindNumberOfWays() { int actual = findNumberOfWays(inputValue); assertThat("Result for value = " + inputValue + " does not match with expected = " + expected, actual, is(expected)); }
|
### Question:
GenerateWhile extends LoopGenerator<E> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof GenerateWhile<?>)) { return false; } GenerateWhile<?> other = (GenerateWhile<?>) obj; return other.getWrappedGenerator().equals(getWrappedGenerator()) && other.test.equals(test); } GenerateWhile(Generator<? extends E> wrapped, Predicate<? super E> test); void run(final Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testEquals() { Generator<Integer> anotherGenerate = new GenerateWhile<Integer>( IteratorToGeneratorAdapter.adapt(new IntegerRange(1, 10)), isLessThanFive); assertEquals(generateWhile, generateWhile); assertEquals(generateWhile, anotherGenerate); assertTrue(!generateWhile.equals((GenerateWhile<Integer>)null)); Generator<Integer> aGenerateWithADifferentPredicate = new GenerateWhile<Integer>( IteratorToGeneratorAdapter.adapt(new IntegerRange(1, 10)), new Predicate<Integer>() { public boolean test(Integer obj) { return obj < FIVE; } }); assertTrue(!generateWhile.equals(aGenerateWithADifferentPredicate)); Generator<Integer> aGenerateWithADifferentWrapped = new GenerateWhile<Integer>( IteratorToGeneratorAdapter.adapt(new IntegerRange(1,11)), isLessThanFive); assertTrue(!generateWhile.equals(aGenerateWithADifferentWrapped)); }
|
### Question:
IteratorToGeneratorAdapter extends LoopGenerator<E> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IteratorToGeneratorAdapter<?>)) { return false; } IteratorToGeneratorAdapter<?> that = (IteratorToGeneratorAdapter<?>) obj; return this.iter.equals(that.iter); } IteratorToGeneratorAdapter(Iterator<? extends E> iter); void run(Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IteratorToGeneratorAdapter<E> adapt(Iterator<? extends E> iter); static IteratorToGeneratorAdapter<E> adapt(Iterable<? extends E> iterable); }### Answer:
@Test public void testEquals() { Iterator<String> iter = list.iterator(); Generator<String> gen = new IteratorToGeneratorAdapter<String>(iter); assertObjectsAreEqual(gen,gen); assertObjectsAreEqual(gen,new IteratorToGeneratorAdapter<String>(iter)); }
|
### Question:
LoopGenerator extends BaseGenerator<E> { public void stop() { if (wrappedGenerator != null && wrappedGenerator instanceof LoopGenerator<?>) { ((LoopGenerator<?>) wrappedGenerator).stop(); } stopped = true; } LoopGenerator(); LoopGenerator(Generator<? extends E> generator); void stop(); boolean isStopped(); }### Answer:
@Test public void testStop() { final StringBuilder result = new StringBuilder(); simpleGenerator.run(new Procedure<Integer>() { int i = 0; public void run(Integer obj) { result.append(obj); if (i++ > 1) { simpleGenerator.stop(); } } }); assertEquals("012", result.toString()); }
|
### Question:
GenerateUntil extends LoopGenerator<E> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof GenerateUntil<?>)) { return false; } GenerateUntil<?> other = (GenerateUntil<?>) obj; return other.getWrappedGenerator().equals(getWrappedGenerator()) && other.test.equals(test); } GenerateUntil(Generator<? extends E> wrapped, Predicate<? super E> test); void run(final Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testEquals() { Generator<Integer> anotherGenerate = new GenerateUntil<Integer>( IteratorToGeneratorAdapter.adapt(new IntegerRange(1, 10)), isMoreThanFive); assertEquals(generateUntil, generateUntil); assertEquals(generateUntil, anotherGenerate); assertTrue(!generateUntil.equals((GenerateUntil<Integer>)null)); Generator<Integer> aGenerateWithADifferentPredicate = new GenerateUntil<Integer>( IteratorToGeneratorAdapter.adapt(new IntegerRange(1, 10)), new Predicate<Integer>() { public boolean test(Integer obj) { return obj > FIVE; } }); assertTrue(!generateUntil.equals(aGenerateWithADifferentPredicate)); Generator<Integer> aGenerateWithADifferentWrapped = new GenerateUntil<Integer>( IteratorToGeneratorAdapter.adapt(new IntegerRange(1,2)), isMoreThanFive); assertTrue(!generateUntil.equals(aGenerateWithADifferentWrapped)); }
|
### Question:
GenerateUntil extends LoopGenerator<E> { @Override public int hashCode() { int result = "GenerateUntil".hashCode(); result <<= 2; Generator<?> gen = getWrappedGenerator(); result ^= gen.hashCode(); result <<= 2; result ^= test.hashCode(); return result; } GenerateUntil(Generator<? extends E> wrapped, Predicate<? super E> test); void run(final Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testHashcode() { assertEquals(generateUntil.hashCode(), generateUntil.hashCode()); assertEquals(generateUntil.hashCode(), new GenerateUntil<Integer>(wrappedGenerator, isMoreThanFive).hashCode()); }
|
### Question:
TransformedGenerator extends LoopGenerator<E> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TransformedGenerator<?, ?>)) { return false; } TransformedGenerator<?, ?> other = (TransformedGenerator<?, ?>) obj; return other.getWrappedGenerator().equals(getWrappedGenerator()) && other.func == func; } @SuppressWarnings("unchecked") TransformedGenerator(Generator<? extends I> wrapped, Function<? super I, ? extends E> func); @SuppressWarnings("unchecked") void run(final Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testEquals() { TransformedGenerator<Integer, Integer> anotherTransformedGenerator = new TransformedGenerator<Integer, Integer>(wrappedGenerator, sumsTwo); assertEquals(sumsTwoGenerator, sumsTwoGenerator); assertEquals(sumsTwoGenerator, anotherTransformedGenerator); assertTrue(!sumsTwoGenerator.equals((TransformedGenerator<Integer, Integer>)null)); TransformedGenerator<Integer, Integer> aGenerateWithADifferentFunction = new TransformedGenerator<Integer, Integer>(wrappedGenerator, new Function<Integer, Integer>() { public Integer evaluate( Integer obj ) { return obj; } }); assertTrue( !sumsTwoGenerator.equals(aGenerateWithADifferentFunction)); TransformedGenerator<Integer, Integer> aTransformedGeneratorWithADifferentWrapped = new TransformedGenerator<Integer, Integer>( IteratorToGeneratorAdapter.adapt(new IntegerRange(1,2)), sumsTwo); assertTrue(!sumsTwoGenerator.equals(aTransformedGeneratorWithADifferentWrapped)); }
|
### Question:
TransformedGenerator extends LoopGenerator<E> { @Override public int hashCode() { int result = "TransformedGenerator".hashCode(); result <<= 2; Generator<?> gen = getWrappedGenerator(); result ^= gen.hashCode(); result <<= 2; result ^= func.hashCode(); return result; } @SuppressWarnings("unchecked") TransformedGenerator(Generator<? extends I> wrapped, Function<? super I, ? extends E> func); @SuppressWarnings("unchecked") void run(final Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testHashcode() { assertEquals(sumsTwoGenerator.hashCode(), sumsTwoGenerator.hashCode()); assertEquals(sumsTwoGenerator.hashCode(), new TransformedGenerator<Integer, Integer>(wrappedGenerator, sumsTwo).hashCode()); }
|
### Question:
TransformedGenerator extends LoopGenerator<E> { @SuppressWarnings("unchecked") public void run(final Procedure<? super E> proc) { ((Generator<? extends I>) getWrappedGenerator()).run(new Procedure<I>() { public void run(I obj) { proc.run(func.evaluate(obj)); } }); } @SuppressWarnings("unchecked") TransformedGenerator(Generator<? extends I> wrapped, Function<? super I, ? extends E> func); @SuppressWarnings("unchecked") void run(final Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testGenerate() { final List<Integer> doubledValues = new ArrayList<Integer>(); sumsTwoGenerator.run(new Procedure<Integer>() { public void run( Integer obj ) { doubledValues.add(obj); } }); final List<Integer> expected = Arrays.asList(3, 4, 5, 6, 7, 8, 9, 10 , 11); assertEquals(9, doubledValues.size()); assertEquals(expected, doubledValues); }
|
### Question:
BaseGenerator implements Generator<E> { public final <T> T to(Function<Generator<? extends E>, ? extends T> transformer) { return transformer.evaluate(this); } BaseGenerator(); final T to(Function<Generator<? extends E>, ? extends T> transformer); final C to(C collection); final Collection<E> toCollection(); }### Answer:
@Test public void testTo() { Collection<Integer> col = simpleGenerator.to(CollectionTransformer.<Integer> toCollection()); assertEquals("[0, 1, 2, 3, 4]", col.toString()); Collection<Integer> fillThis = new LinkedList<Integer>(); col = simpleGenerator.to(new CollectionTransformer<Integer, Collection<Integer>>(fillThis)); assertSame(fillThis, col); assertEquals("[0, 1, 2, 3, 4]", col.toString()); col = (Collection<Integer>) simpleGenerator.toCollection(); assertEquals("[0, 1, 2, 3, 4]", col.toString()); assertEquals("[0, 1, 2, 3, 4]", col.toString()); fillThis = new LinkedList<Integer>(); col = (Collection<Integer>) simpleGenerator.to(fillThis); assertSame(fillThis, col); assertEquals("[0, 1, 2, 3, 4]", col.toString()); }
|
### Question:
Offset implements NullaryPredicate, Predicate<Object>,
BinaryPredicate<Object, Object> { public boolean test() { if (state.get() < min) { state.incrementAndGet(); return false; } return true; } Offset(int count); boolean test(); boolean test(Object obj); boolean test(Object a, Object b); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testZero() throws Exception { NullaryPredicate p = new Offset(0); assertTrue( p.test()); assertTrue( p.test()); assertTrue( p.test()); }
@Test public void testTestNullary() throws Exception { NullaryPredicate p = new Offset(3); assertTrue(!p.test()); assertTrue(!p.test()); assertTrue(!p.test()); assertTrue(p.test()); }
@Test public void testTestUnary() throws Exception { Predicate<Object> p = new Offset(3); assertTrue(!p.test(null)); assertTrue(!p.test(null)); assertTrue(!p.test(null)); assertTrue(p.test(null)); }
@Test public void testTestBinary() throws Exception { BinaryPredicate<Object, Object> p = new Offset(3); assertTrue(!p.test(null,null)); assertTrue(!p.test(null,null)); assertTrue(!p.test(null,null)); assertTrue(p.test(null,null)); }
|
### Question:
GenerateWhile extends LoopGenerator<E> { @Override public int hashCode() { int result = "GenerateWhile".hashCode(); result <<= 2; Generator<?> gen = getWrappedGenerator(); result ^= gen.hashCode(); result <<= 2; result ^= test.hashCode(); return result; } GenerateWhile(Generator<? extends E> wrapped, Predicate<? super E> test); void run(final Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testHashcode() { assertEquals(generateWhile.hashCode(), generateWhile.hashCode()); assertEquals(generateWhile.hashCode(), new GenerateWhile<Integer>(wrappedGenerator, isLessThanFive).hashCode()); }
|
### Question:
Offset implements NullaryPredicate, Predicate<Object>,
BinaryPredicate<Object, Object> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof Offset)) { return false; } Offset other = (Offset) obj; return other.min == min; } Offset(int count); boolean test(); boolean test(Object obj); boolean test(Object a, Object b); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { Offset offset = new Offset(1); assertObjectsAreEqual(new Offset(1), offset); assertObjectsAreNotEqual(new Offset(2), offset); assertTrue(!offset.equals(null)); }
|
### Question:
IsNull implements Predicate<A> { public boolean test(A obj) { return (null == obj); } IsNull(); boolean test(A obj); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNull<T> instance(); static BinaryPredicate<A, Object> left(); static BinaryPredicate<Object, A> right(); static final IsNull<Object> INSTANCE; static final BinaryPredicate<Object, Object> LEFT; static final BinaryPredicate<Object, Object> RIGHT; }### Answer:
@Test public void testTest() throws Exception { Predicate<Object> p = new IsNull<Object>(); assertTrue(p.test(null)); assertFalse(p.test("foo")); assertFalse(p.test(Integer.valueOf(3))); }
|
### Question:
IsNull implements Predicate<A> { @Override public boolean equals(Object that) { return that instanceof IsNull<?>; } IsNull(); boolean test(A obj); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNull<T> instance(); static BinaryPredicate<A, Object> left(); static BinaryPredicate<Object, A> right(); static final IsNull<Object> INSTANCE; static final BinaryPredicate<Object, Object> LEFT; static final BinaryPredicate<Object, Object> RIGHT; }### Answer:
@Test public void testEquals() throws Exception { Predicate<Object> p = new IsNull<Object>(); assertEquals(p, p); assertObjectsAreEqual(p, new IsNull<Object>()); assertObjectsAreEqual(p, IsNull.instance()); assertObjectsAreNotEqual(p, Constant.TRUE); }
|
### Question:
IsNull implements Predicate<A> { public static <T> IsNull<T> instance() { return new IsNull<T>(); } IsNull(); boolean test(A obj); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNull<T> instance(); static BinaryPredicate<A, Object> left(); static BinaryPredicate<Object, A> right(); static final IsNull<Object> INSTANCE; static final BinaryPredicate<Object, Object> LEFT; static final BinaryPredicate<Object, Object> RIGHT; }### Answer:
@Test public void testConstant() throws Exception { assertEquals(IsNull.instance(), IsNull.instance()); }
|
### Question:
LeftIdentity { public static <L, R> BinaryFunction<L, R, L> function() { return IgnoreRightFunction.adapt(new Identity<L>()); } LeftIdentity(); static BinaryFunction<L, R, L> function(); static BinaryPredicate<Boolean, R> predicate(); static final BinaryFunction<Object, Object, Object> FUNCTION; static final BinaryPredicate<Boolean, Object> PREDICATE; }### Answer:
@Test public void testEquals() throws Exception { BinaryFunction<Object, Object, Object> f = LeftIdentity.<Object, Object>function(); assertEquals(f,f); assertObjectsAreEqual(f,LeftIdentity.FUNCTION); assertObjectsAreEqual(f,LeftIdentity.FUNCTION); assertObjectsAreNotEqual(f,RightIdentity.FUNCTION); assertObjectsAreNotEqual(f,Constant.of("abcde")); assertObjectsAreNotEqual(f,Constant.of(Boolean.TRUE)); }
@Test public void testConstant() throws Exception { assertEquals(LeftIdentity.function(),LeftIdentity.function()); }
|
### Question:
IsNotNull implements Predicate<T> { public boolean test(Object obj) { return (null != obj); } IsNotNull(); boolean test(Object obj); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNotNull<T> instance(); static BinaryPredicate<A, Object> left(); static BinaryPredicate<Object, A> right(); static final IsNotNull<Object> INSTANCE; static final BinaryPredicate<Object, Object> LEFT; static final BinaryPredicate<Object, Object> RIGHT; }### Answer:
@Test public void testTest() throws Exception { Predicate<Object> p = new IsNotNull<Object>(); assertTrue(!p.test(null)); assertTrue(p.test("foo")); assertTrue(p.test(Integer.valueOf(3))); }
|
### Question:
IsNotNull implements Predicate<T> { @Override public boolean equals(Object that) { return that instanceof IsNotNull<?>; } IsNotNull(); boolean test(Object obj); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNotNull<T> instance(); static BinaryPredicate<A, Object> left(); static BinaryPredicate<Object, A> right(); static final IsNotNull<Object> INSTANCE; static final BinaryPredicate<Object, Object> LEFT; static final BinaryPredicate<Object, Object> RIGHT; }### Answer:
@Test public void testEquals() throws Exception { Predicate<Object> p = new IsNotNull<Object>(); assertEquals(p, p); assertObjectsAreEqual(p, new IsNotNull<Object>()); assertObjectsAreEqual(p, IsNotNull.instance()); assertObjectsAreNotEqual(p, Constant.TRUE); }
|
### Question:
IsNotNull implements Predicate<T> { public static <T> IsNotNull<T> instance() { return new IsNotNull<T>(); } IsNotNull(); boolean test(Object obj); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNotNull<T> instance(); static BinaryPredicate<A, Object> left(); static BinaryPredicate<Object, A> right(); static final IsNotNull<Object> INSTANCE; static final BinaryPredicate<Object, Object> LEFT; static final BinaryPredicate<Object, Object> RIGHT; }### Answer:
@Test public void testConstant() throws Exception { assertEquals(IsNotNull.instance(), IsNotNull.instance()); }
|
### Question:
Constant implements NullaryFunction<T>, Function<Object, T>, BinaryFunction<Object, Object, T>,
NullaryPredicate, Predicate<Object>, BinaryPredicate<Object, Object> { public T evaluate() { return value; } Constant(T value); T evaluate(); T evaluate(Object obj); T evaluate(Object left, Object right); boolean test(); boolean test(Object obj); boolean test(Object left, Object right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Constant<Boolean> truePredicate(); static Constant<Boolean> falsePredicate(); static Constant<Boolean> predicate(boolean value); static Constant<T> of(T value); static final Constant<Boolean> TRUE; static final Constant<Boolean> FALSE; }### Answer:
@Test public void testEvaluate() throws Exception { Constant<Object> f = new Constant<Object>("xyzzy"); assertEquals("xyzzy", f.evaluate()); assertEquals("xyzzy", f.evaluate(null)); assertEquals("xyzzy", f.evaluate(null, null)); assertEquals("xyzzy", f.evaluate()); assertEquals("xyzzy", f.evaluate("foo")); assertEquals("xyzzy", f.evaluate("foo", Integer.valueOf(2))); }
@Test public void testEvaluateConstantNull() throws Exception { Constant<Object> f = new Constant<Object>(null); assertNull(f.evaluate()); assertNull(f.evaluate(null)); assertNull(f.evaluate(null, null)); assertNull(f.evaluate()); assertNull(f.evaluate("foo")); assertNull(f.evaluate("foo", Integer.valueOf(2))); }
|
### Question:
Constant implements NullaryFunction<T>, Function<Object, T>, BinaryFunction<Object, Object, T>,
NullaryPredicate, Predicate<Object>, BinaryPredicate<Object, Object> { public boolean test() { return ((Boolean) evaluate()).booleanValue(); } Constant(T value); T evaluate(); T evaluate(Object obj); T evaluate(Object left, Object right); boolean test(); boolean test(Object obj); boolean test(Object left, Object right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Constant<Boolean> truePredicate(); static Constant<Boolean> falsePredicate(); static Constant<Boolean> predicate(boolean value); static Constant<T> of(T value); static final Constant<Boolean> TRUE; static final Constant<Boolean> FALSE; }### Answer:
@Test public void testConstantTrue() throws Exception { Constant<Object> truePred = new Constant<Object>(Boolean.TRUE); assertTrue(truePred.test()); assertTrue(truePred.test(null)); assertTrue(truePred.test(null, null)); assertTrue(truePred.test()); assertTrue(truePred.test("foo")); assertTrue(truePred.test("foo", Integer.valueOf(2))); }
@Test public void testConstantFalse() throws Exception { Constant<Object> falsePred = new Constant<Object>(Boolean.FALSE); assertTrue(!falsePred.test()); assertTrue(!falsePred.test(null)); assertTrue(!falsePred.test(null, null)); assertTrue(!falsePred.test()); assertTrue(!falsePred.test("foo")); assertTrue(!falsePred.test("foo", Integer.valueOf(2))); }
|
### Question:
Constant implements NullaryFunction<T>, Function<Object, T>, BinaryFunction<Object, Object, T>,
NullaryPredicate, Predicate<Object>, BinaryPredicate<Object, Object> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof Constant<?>)) { return false; } Constant<?> that = (Constant<?>) obj; return null == this.value ? null == that.value : this.value.equals(that.value); } Constant(T value); T evaluate(); T evaluate(Object obj); T evaluate(Object left, Object right); boolean test(); boolean test(Object obj); boolean test(Object left, Object right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Constant<Boolean> truePredicate(); static Constant<Boolean> falsePredicate(); static Constant<Boolean> predicate(boolean value); static Constant<T> of(T value); static final Constant<Boolean> TRUE; static final Constant<Boolean> FALSE; }### Answer:
@Test public void testEquals() throws Exception { Constant<Object> f = new Constant<Object>("xyzzy"); assertEquals(f, f); assertObjectsAreEqual(f, new Constant<Object>("xyzzy")); assertObjectsAreNotEqual(f, new Constant<Object>("abcde")); assertObjectsAreNotEqual(f, new Constant<Object>(null)); assertObjectsAreEqual(new Constant<Object>(null), new Constant<Object>(null)); assertTrue(!f.equals(null)); }
|
### Question:
IsInstance implements BinaryPredicate<T, Class<?>> { public boolean test(T left, Class<?> right) { return right.isInstance(left); } boolean test(T left, Class<?> right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsInstance<T> instance(); static Predicate<T> of(Class<?> clazz); static final IsInstance<Object> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { BinaryPredicate<Object, Class<?>> p = IsInstance.INSTANCE; assertFalse(p.test(null, Number.class)); assertFalse(p.test("foo", Number.class)); assertTrue(p.test(3, Number.class)); assertTrue(p.test(3L, Number.class)); }
@Test public void testInstanceOfNull() throws Exception { BinaryPredicate<Object, Class<?>> p = new IsInstance<Object>(); try { p.test("foo", null); fail("Expected NullPointerException"); } catch(NullPointerException e) { } }
|
### Question:
IsInstance implements BinaryPredicate<T, Class<?>> { @Override public boolean equals(Object that) { return that instanceof IsInstance<?>; } boolean test(T left, Class<?> right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsInstance<T> instance(); static Predicate<T> of(Class<?> clazz); static final IsInstance<Object> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { BinaryPredicate<Object, Class<?>> p = IsInstance.INSTANCE; assertEquals(p, p); assertObjectsAreEqual(p, IsInstance.instance()); assertObjectsAreNotEqual(p,Constant.truePredicate()); }
|
### Question:
IsInstance implements BinaryPredicate<T, Class<?>> { public static <T> Predicate<T> of(Class<?> clazz) { return RightBoundPredicate.bind(new IsInstance<T>(), clazz); } boolean test(T left, Class<?> right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsInstance<T> instance(); static Predicate<T> of(Class<?> clazz); static final IsInstance<Object> INSTANCE; }### Answer:
@Test public void testBoundEquals() throws Exception { Predicate<Object> p = IsInstance.of(Object.class); assertEquals(p,p); assertObjectsAreEqual(p,IsInstance.of(Object.class)); assertObjectsAreNotEqual(p,Constant.truePredicate()); assertObjectsAreNotEqual(p,IsInstance.of(null)); assertObjectsAreNotEqual(p,IsInstance.of(String.class)); }
|
### Question:
CompositeBinaryPredicate implements BinaryPredicate<L, R> { public boolean test(L left, R right) { return helper.test(left, right); } <G, H> CompositeBinaryPredicate(final BinaryPredicate<? super G, ? super H> f,
final Function<? super L, ? extends G> g, final Function<? super R, ? extends H> h); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryPredicate<Boolean, Boolean> f = new CompositeBinaryPredicate<Boolean, Boolean>( RightIdentity.PREDICATE, Constant.FALSE, new Identity<Boolean>()); assertTrue(f.test(Boolean.TRUE,Boolean.TRUE)); assertTrue(f.test(null,Boolean.TRUE)); }
|
### Question:
CompositeBinaryPredicate implements BinaryPredicate<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof CompositeBinaryPredicate<?, ?>)) { return false; } CompositeBinaryPredicate<?, ?> that = (CompositeBinaryPredicate<?, ?>) obj; return this.helper.f.equals(that.helper.f) && this.helper.g.equals(that.helper.g) && this.helper.h.equals(that.helper.h); } <G, H> CompositeBinaryPredicate(final BinaryPredicate<? super G, ? super H> f,
final Function<? super L, ? extends G> g, final Function<? super R, ? extends H> h); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { BinaryPredicate<Boolean, Boolean> f = new CompositeBinaryPredicate<Boolean, Boolean>( LeftIdentity.PREDICATE, Constant.TRUE, Constant.FALSE); assertEquals(f,f); assertObjectsAreEqual(f,new CompositeBinaryPredicate<Boolean, Boolean>( LeftIdentity.PREDICATE, Constant.TRUE, Constant.FALSE)); assertObjectsAreNotEqual(f,new CompositeBinaryPredicate<Boolean, Boolean>( RightIdentity.PREDICATE, Constant.TRUE, Constant.FALSE)); assertObjectsAreNotEqual(f,new CompositeBinaryPredicate<Boolean, Boolean>( LeftIdentity.PREDICATE, Constant.FALSE, Constant.FALSE)); assertObjectsAreNotEqual(f,new CompositeBinaryPredicate<Boolean, Boolean>( LeftIdentity.PREDICATE, new Identity<Boolean>(), Constant.TRUE)); assertObjectsAreNotEqual(f,new CompositeBinaryPredicate<Boolean, Boolean>( LeftIdentity.PREDICATE, Constant.TRUE, new Identity<Boolean>())); assertTrue(!((CompositeBinaryPredicate<?,?>)f).equals(null)); }
|
### Question:
AbstractLoopNullaryProcedure implements NullaryProcedure { @Override public final boolean equals(Object object) { if (object == this) { return true; } if (!(object instanceof AbstractLoopNullaryProcedure)) { return false; } AbstractLoopNullaryProcedure that = (AbstractLoopNullaryProcedure) object; return (getCondition().equals(that.getCondition()) && (getAction().equals(that.getAction()))); } protected AbstractLoopNullaryProcedure(NullaryPredicate condition, NullaryProcedure action); @Override final boolean equals(Object object); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { MockLoopProcedure p = new MockLoopProcedure(Constant.FALSE, NoOp.INSTANCE); assertEquals(p,p); assertObjectsAreEqual(p,new MockLoopProcedure(Constant.FALSE, NoOp.INSTANCE)); assertObjectsAreNotEqual(p,new MockLoopProcedure(Constant.TRUE, NoOp.INSTANCE)); assertObjectsAreNotEqual(p,new MockLoopProcedure(Constant.FALSE, new NullarySequence())); }
|
### Question:
ConditionalBinaryProcedure implements BinaryProcedure<L, R> { public void run(L left, R right) { if (ifPred.test(left, right)) { thenProc.run(left, right); } else { elseProc.run(left, right); } } ConditionalBinaryProcedure(BinaryPredicate<? super L, ? super R> ifPred,
BinaryProcedure<? super L, ? super R> thenProc); ConditionalBinaryProcedure(BinaryPredicate<? super L, ? super R> ifPred,
BinaryProcedure<? super L, ? super R> thenProc, BinaryProcedure<? super L, ? super R> elseProc); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRun() throws Exception { RunCounter left = new RunCounter(); RunCounter right = new RunCounter(); ConditionalBinaryProcedure<Boolean, Object> p = new ConditionalBinaryProcedure<Boolean, Object>( LeftIdentity.PREDICATE, left, right); assertEquals(0,left.count); assertEquals(0,right.count); p.run(Boolean.TRUE, null); assertEquals(1,left.count); assertEquals(0,right.count); p.run(Boolean.FALSE, null); assertEquals(1,left.count); assertEquals(1,right.count); p.run(Boolean.TRUE, null); assertEquals(2,left.count); assertEquals(1,right.count); }
|
### Question:
ConditionalBinaryProcedure implements BinaryProcedure<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ConditionalBinaryProcedure<?, ?>)) { return false; } ConditionalBinaryProcedure<?, ?> that = (ConditionalBinaryProcedure<?, ?>) obj; return this.ifPred.equals(that.ifPred) && this.thenProc.equals(that.thenProc) && this.elseProc.equals(that.elseProc); } ConditionalBinaryProcedure(BinaryPredicate<? super L, ? super R> ifPred,
BinaryProcedure<? super L, ? super R> thenProc); ConditionalBinaryProcedure(BinaryPredicate<? super L, ? super R> ifPred,
BinaryProcedure<? super L, ? super R> thenProc, BinaryProcedure<? super L, ? super R> elseProc); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { ConditionalBinaryProcedure<?, ?> p = new ConditionalBinaryProcedure<Boolean, Object>( LeftIdentity.PREDICATE, NoOp.instance(), NoOp.instance()); assertEquals(p,p); assertObjectsAreEqual(p,new ConditionalBinaryProcedure<Boolean, Object>( LeftIdentity.PREDICATE, NoOp.instance(), NoOp.instance())); assertObjectsAreNotEqual(p,new ConditionalBinaryProcedure<Object, Object>( Constant.TRUE, NoOp.instance(), NoOp.instance())); assertObjectsAreNotEqual(p,new ConditionalBinaryProcedure<Boolean, Object>( LeftIdentity.PREDICATE, new RunCounter(), NoOp.instance())); assertObjectsAreNotEqual(p,new ConditionalBinaryProcedure<Boolean, Object>( LeftIdentity.PREDICATE, NoOp.instance(), new RunCounter())); assertObjectsAreNotEqual(p,new ConditionalBinaryProcedure<Boolean, Object>( Constant.TRUE, NoOp.instance())); assertTrue(!p.equals(null)); }
|
### Question:
ConditionalProcedure implements Procedure<A> { public void run(A obj) { if (ifPred.test(obj)) { thenProc.run(obj); } else { elseProc.run(obj); } } ConditionalProcedure(Predicate<? super A> ifPred, Procedure<? super A> thenProc); ConditionalProcedure(Predicate<? super A> ifPred,
Procedure<? super A> thenProc,
Procedure<? super A> elseProc); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRun() throws Exception { RunCounter left = new RunCounter(); RunCounter right = new RunCounter(); ConditionalProcedure<Object> p = new ConditionalProcedure<Object>( Identity.INSTANCE, left, right); assertEquals(0,left.count); assertEquals(0,right.count); p.run(Boolean.TRUE); assertEquals(1,left.count); assertEquals(0,right.count); p.run(Boolean.FALSE); assertEquals(1,left.count); assertEquals(1,right.count); p.run(Boolean.TRUE); assertEquals(2,left.count); assertEquals(1,right.count); }
|
### Question:
ConditionalProcedure implements Procedure<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ConditionalProcedure<?>)) { return false; } ConditionalProcedure<?> that = (ConditionalProcedure<?>) obj; return this.ifPred.equals(that.ifPred) && this.thenProc.equals(that.thenProc) && this.elseProc.equals(that.elseProc); } ConditionalProcedure(Predicate<? super A> ifPred, Procedure<? super A> thenProc); ConditionalProcedure(Predicate<? super A> ifPred,
Procedure<? super A> thenProc,
Procedure<? super A> elseProc); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { ConditionalProcedure<Object> p = new ConditionalProcedure<Object>( Identity.INSTANCE, NoOp.INSTANCE, NoOp.INSTANCE); assertEquals(p,p); assertObjectsAreEqual(p,new ConditionalProcedure<Object>( Identity.INSTANCE, NoOp.INSTANCE, NoOp.INSTANCE)); assertObjectsAreNotEqual(p,new ConditionalProcedure<Object>( Constant.TRUE, NoOp.INSTANCE, NoOp.INSTANCE)); assertObjectsAreNotEqual(p,new ConditionalProcedure<Object>( Identity.INSTANCE, new RunCounter(), NoOp.INSTANCE)); assertObjectsAreNotEqual(p,new ConditionalProcedure<Object>( Identity.INSTANCE, NoOp.INSTANCE, new RunCounter())); assertObjectsAreNotEqual(p, new ConditionalProcedure<Object>( Constant.TRUE, new RunCounter())); assertTrue(!p.equals(null)); }
|
### Question:
NullarySequence implements NullaryProcedure { public final void run() { for (Iterator<NullaryProcedure> iter = list.iterator(); iter.hasNext();) { iter.next().run(); } } NullarySequence(); NullarySequence(NullaryProcedure... procedures); NullarySequence(Iterable<NullaryProcedure> procedures); final NullarySequence then(NullaryProcedure p); final void run(); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRunZero() throws Exception { NullarySequence seq = new NullarySequence(); seq.run(); }
@Test public void testRunOne() throws Exception { RunCounter counter = new RunCounter(); NullarySequence seq = new NullarySequence(counter); assertEquals(0,counter.count); seq.run(); assertEquals(1,counter.count); }
@Test public void testRunTwo() throws Exception { RunCounter[] counter = { new RunCounter(), new RunCounter() }; NullarySequence seq = new NullarySequence(counter[0],counter[1]); assertEquals(0,counter[0].count); assertEquals(0,counter[1].count); seq.run(); assertEquals(1,counter[0].count); assertEquals(1,counter[1].count); }
|
### Question:
NullarySequence implements NullaryProcedure { public final NullarySequence then(NullaryProcedure p) { if (p != null) { list.add(p); } return this; } NullarySequence(); NullarySequence(NullaryProcedure... procedures); NullarySequence(Iterable<NullaryProcedure> procedures); final NullarySequence then(NullaryProcedure p); final void run(); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testThen() throws Exception { List<RunCounter> list = new ArrayList<RunCounter>(); NullarySequence seq = new NullarySequence(); seq.run(); for (int i=0;i<10;i++) { RunCounter counter = new RunCounter(); seq.then(counter); list.add(counter); seq.run(); for (int j=0;j<list.size();j++) { assertEquals(list.size()-j,(((RunCounter)(list.get(j))).count)); } } }
|
### Question:
NullarySequence implements NullaryProcedure { @Override public final boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof NullarySequence)) { return false; } NullarySequence that = (NullarySequence) obj; return this.list.equals(that.list); } NullarySequence(); NullarySequence(NullaryProcedure... procedures); NullarySequence(Iterable<NullaryProcedure> procedures); final NullarySequence then(NullaryProcedure p); final void run(); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { NullarySequence p = new NullarySequence(); assertEquals(p,p); NullarySequence q = new NullarySequence(); assertObjectsAreEqual(p,q); for (int i=0;i<3;i++) { p.then(new NoOp()); assertObjectsAreNotEqual(p,q); q.then(new NoOp()); assertObjectsAreEqual(p,q); p.then(new NullarySequence(new NoOp(),new NoOp())); assertObjectsAreNotEqual(p,q); q.then(new NullarySequence(new NoOp(),new NoOp())); assertObjectsAreEqual(p,q); } assertObjectsAreNotEqual(p,new NoOp()); assertTrue(!p.equals(null)); }
|
### Question:
ConditionalNullaryPredicate implements NullaryPredicate { public boolean test() { return ifPred.test() ? thenPred.test() : elsePred.test(); } ConditionalNullaryPredicate(NullaryPredicate ifPred, NullaryPredicate thenPred, NullaryPredicate elsePred); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testTest() throws Exception { { ConditionalNullaryPredicate p = new ConditionalNullaryPredicate( Constant.TRUE, Constant.TRUE, Constant.FALSE); assertTrue(p.test()); } { ConditionalNullaryPredicate p = new ConditionalNullaryPredicate( Constant.FALSE, Constant.TRUE, Constant.FALSE); assertTrue(!p.test()); } }
|
### Question:
ConditionalNullaryPredicate implements NullaryPredicate { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ConditionalNullaryPredicate)) { return false; } ConditionalNullaryPredicate that = (ConditionalNullaryPredicate) obj; return this.ifPred.equals(that.ifPred) && this.thenPred.equals(that.thenPred) && this.elsePred.equals(that.elsePred); } ConditionalNullaryPredicate(NullaryPredicate ifPred, NullaryPredicate thenPred, NullaryPredicate elsePred); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { ConditionalNullaryPredicate p = new ConditionalNullaryPredicate( Constant.TRUE, Constant.TRUE, Constant.FALSE); assertEquals(p,p); assertObjectsAreEqual(p,new ConditionalNullaryPredicate( Constant.TRUE, Constant.TRUE, Constant.FALSE)); assertObjectsAreNotEqual(p,new ConditionalNullaryPredicate( Constant.TRUE, Constant.FALSE, Constant.TRUE)); assertObjectsAreNotEqual(p,new ConditionalNullaryPredicate( Constant.TRUE, Constant.TRUE, Constant.TRUE)); assertObjectsAreNotEqual(p,new ConditionalNullaryPredicate( Constant.FALSE, Constant.TRUE, Constant.FALSE)); assertTrue(!p.equals(null)); }
|
### Question:
NullaryAnd extends BaseNullaryPredicateList { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof NullaryAnd)) { return false; } NullaryAnd that = (NullaryAnd) obj; return getNullaryPredicateListEquals(that); } NullaryAnd(); NullaryAnd(Iterable<NullaryPredicate> predicates); NullaryAnd(NullaryPredicate... predicates); NullaryAnd and(NullaryPredicate p); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { NullaryAnd p = new NullaryAnd(); assertEquals(p,p); NullaryAnd q = new NullaryAnd(); assertObjectsAreEqual(p,q); for (int i=0;i<3;i++) { p.and(Constant.TRUE); assertObjectsAreNotEqual(p,q); q.and(Constant.truePredicate()); assertObjectsAreEqual(p,q); p.and(new NullaryAnd(Constant.TRUE,Constant.FALSE)); assertObjectsAreNotEqual(p,q); q.and(new NullaryAnd(Constant.TRUE,Constant.FALSE)); assertObjectsAreEqual(p,q); } assertObjectsAreNotEqual(p,Constant.TRUE); Iterable<NullaryPredicate> iterable = Arrays.<NullaryPredicate>asList( Constant.TRUE, new NullaryAnd(Constant.TRUE, Constant.FALSE), Constant.TRUE, new NullaryAnd(Constant.TRUE, Constant.FALSE), Constant.TRUE, new NullaryAnd(Constant.TRUE, Constant.FALSE)); assertObjectsAreEqual(p,new NullaryAnd(iterable)); assertObjectsAreNotEqual(p,new NullaryAnd((Iterable<NullaryPredicate>)null)); assertObjectsAreNotEqual(p,new NullaryAnd((NullaryPredicate[])null)); assertObjectsAreNotEqual(p,new NullaryAnd((NullaryPredicate)null)); assertTrue(!p.equals(null)); }
|
### Question:
And extends BasePredicateList<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof And<?>)) { return false; } And<?> that = (And<?>) obj; return getPredicateListEquals(that); } And(); And(Iterable<Predicate<? super A>> predicates); And(Predicate<? super A>... predicates); And<A> and(Predicate<? super A> p); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@SuppressWarnings("rawtypes") @Test public void testEquals() throws Exception { And<Object> p = new And<Object>(); assertEquals(p,p); And<Object> q = new And<Object>(); assertObjectsAreEqual(p,q); for (int i=0;i<3;i++) { p.and(Constant.truePredicate()); assertObjectsAreNotEqual(p,q); q.and(Constant.truePredicate()); assertObjectsAreEqual(p,q); p.and(new And<Object>(Constant.truePredicate(),Constant.falsePredicate())); assertObjectsAreNotEqual(p,q); q.and(new And<Object>(Constant.truePredicate(),Constant.falsePredicate())); assertObjectsAreEqual(p,q); } assertObjectsAreNotEqual(p,Constant.truePredicate()); And<Object> r = new And<Object>(); r.and(Constant.truePredicate()); r.and(new And<Object>(Constant.truePredicate(),Constant.falsePredicate())); assertObjectsAreEqual(r, new And<Object>(r.getPredicateList())); assertObjectsAreNotEqual(p, new And((Iterable<Predicate<Object>>)null)); assertObjectsAreNotEqual(p, new And((Predicate<Object>[])null)); assertObjectsAreNotEqual(p, new And((Predicate<Object>)null)); assertTrue(!p.equals(null)); }
|
### Question:
ConditionalFunction implements Function<A, T> { public T evaluate(A obj) { if (ifPred.test(obj)) { return thenFunc.evaluate(obj); } else { return elseFunc.evaluate(obj); } } ConditionalFunction(Predicate<? super A> ifPred, Function<? super A, ? extends T> thenFunc,
Function<? super A, ? extends T> elseFunc); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEvaluate() throws Exception { ConditionalFunction<Object, Object> f = new ConditionalFunction<Object, Object>( Identity.INSTANCE, Constant.of("left"), Constant.of("right")); assertEquals("left",f.evaluate(Boolean.TRUE)); assertEquals("right",f.evaluate(Boolean.FALSE)); }
|
### Question:
ConditionalFunction implements Function<A, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ConditionalFunction<?, ?>)) { return false; } ConditionalFunction<?, ?> that = (ConditionalFunction<?, ?>) obj; return this.ifPred.equals(that.ifPred) && this.thenFunc.equals(that.thenFunc) && this.elseFunc.equals(that.elseFunc); } ConditionalFunction(Predicate<? super A> ifPred, Function<? super A, ? extends T> thenFunc,
Function<? super A, ? extends T> elseFunc); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { ConditionalFunction<Object, Object> f = new ConditionalFunction<Object, Object>( Identity.INSTANCE, Constant.of("left"), Constant.of("right")); assertEquals(f,f); assertObjectsAreEqual(f,new ConditionalFunction<Object, Object>( Identity.INSTANCE, Constant.of("left"), Constant.of("right"))); assertObjectsAreNotEqual(f,new ConditionalFunction<Object, Object>( Identity.INSTANCE, Constant.of(null), Constant.of("right"))); assertObjectsAreNotEqual(f,new ConditionalFunction<Object, Object>( Constant.TRUE, Constant.of("left"), Constant.of("right"))); assertObjectsAreNotEqual(f,new ConditionalFunction<Object, Object>( Identity.INSTANCE, Constant.of("left"), Constant.of(null))); assertTrue(!f.equals(null)); }
|
### Question:
Not implements Predicate<A> { public boolean test(A obj) { return !(predicate.test(obj)); } Not(Predicate<? super A> predicate); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Predicate<A> not(Predicate<? super A> pred); }### Answer:
@Test public void testTest() throws Exception { Predicate<Object> truePred = new Not<Object>(Constant.FALSE); assertTrue(truePred.test(null)); assertTrue(truePred.test("xyzzy")); assertTrue(truePred.test(Integer.valueOf(3))); }
|
### Question:
Not implements Predicate<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof Not<?>)) { return false; } Not<?> that = (Not<?>) obj; return this.predicate.equals(that.predicate); } Not(Predicate<? super A> predicate); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Predicate<A> not(Predicate<? super A> pred); }### Answer:
@Test public void testEquals() throws Exception { Not<Object> p = new Not<Object>(Constant.TRUE); assertEquals(p, p); assertObjectsAreEqual(p, new Not<Object>(Constant.TRUE)); assertObjectsAreEqual(p, Not.not(Constant.TRUE)); assertObjectsAreNotEqual(p, new Not<Object>(Constant.FALSE)); assertObjectsAreNotEqual(p, Constant.TRUE); assertTrue(!p.equals(null)); }
|
### Question:
Not implements Predicate<A> { public Not(Predicate<? super A> predicate) { this.predicate = Validate.notNull(predicate, "Predicate argument was null"); } Not(Predicate<? super A> predicate); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Predicate<A> not(Predicate<? super A> pred); }### Answer:
@Test public void testNotNull() throws Exception { assertNull(Not.not(null)); }
@Test public void testNotNotNull() throws Exception { assertNotNull(Not.not(Constant.truePredicate())); }
|
### Question:
CompositeProcedure implements Procedure<A> { public void run(A obj) { function.evaluate(obj); } CompositeProcedure(Procedure<? super A> procedure); private CompositeProcedure(CompositeFunction<? super A, Object> function); CompositeProcedure<T> of(Function<? super T, ? extends A> preceding); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRun() throws Exception { Composite.procedure(NoOp.instance(), Identity.instance()).run(null); }
|
### Question:
CompositeProcedure implements Procedure<A> { public <T> CompositeProcedure<T> of(Function<? super T, ? extends A> preceding) { return new CompositeProcedure<T>(function.of(preceding)); } CompositeProcedure(Procedure<? super A> procedure); private CompositeProcedure(CompositeFunction<? super A, Object> function); CompositeProcedure<T> of(Function<? super T, ? extends A> preceding); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test(expected=NullPointerException.class) public void testNullProcedureNotAllowed2() throws Exception { new CompositeProcedure<Object>(NoOp.instance()).of(null); }
@Test public void testOf() throws Exception { Composite.procedure(NoOp.instance()).of(Identity.instance()).run(null); }
|
### Question:
CompositeProcedure implements Procedure<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof CompositeProcedure<?>)) { return false; } CompositeProcedure<?> that = (CompositeProcedure<?>) obj; return this.function.equals(that.function); } CompositeProcedure(Procedure<? super A> procedure); private CompositeProcedure(CompositeFunction<? super A, Object> function); CompositeProcedure<T> of(Function<? super T, ? extends A> preceding); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { CompositeProcedure<Object> f = Composite.procedure(NoOp.instance()); assertEquals(f,f); CompositeProcedure<Object> g = Composite.procedure(NoOp.instance()); assertObjectsAreEqual(f,g); for (int i=0;i<3;i++) { f = f.of(Constant.of("x")); assertObjectsAreNotEqual(f,g); g = g.of(Constant.of("x")); assertObjectsAreEqual(f,g); f = f.of(Constant.of("y")).of(Constant.of("z")); assertObjectsAreNotEqual(f,g); g = g.of(Constant.of("y")).of(Constant.of("z")); assertObjectsAreEqual(f,g); } assertObjectsAreNotEqual(f,Constant.FALSE); assertTrue(!f.equals(null)); }
|
### Question:
CompositeBinaryFunction implements BinaryFunction<L, R, T> { public T evaluate(L left, R right) { return helper.evaluate(left, right); } <G, H> CompositeBinaryFunction(BinaryFunction<? super G, ? super H, ? extends T> f,
Function<? super L, ? extends G> g, Function<? super R, ? extends H> h); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryFunction<Object, Object, Object> f = new CompositeBinaryFunction<Object, Object, Object>( RightIdentity.FUNCTION, Constant.of("K"), Identity.instance()); assertEquals("right",f.evaluate("left","right")); assertNull("right",f.evaluate("left",null)); assertEquals("right",f.evaluate(null,"right")); }
|
### Question:
CompositeBinaryFunction implements BinaryFunction<L, R, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof CompositeBinaryFunction<?, ?, ?>)) { return false; } CompositeBinaryFunction<?, ?, ?> that = (CompositeBinaryFunction<?, ?, ?>) obj; return this.helper.f.equals(that.helper.f) && this.helper.g.equals(that.helper.g) && this.helper.h.equals(that.helper.h); } <G, H> CompositeBinaryFunction(BinaryFunction<? super G, ? super H, ? extends T> f,
Function<? super L, ? extends G> g, Function<? super R, ? extends H> h); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { BinaryFunction<Object, Object, Object> f = new CompositeBinaryFunction<Object, Object, Object>( LeftIdentity.FUNCTION, Constant.of("left"), Constant.of("right")); assertEquals(f,f); assertObjectsAreEqual(f,new CompositeBinaryFunction<Object, Object, Object>( LeftIdentity.FUNCTION, Constant.of("left"), Constant.of("right"))); assertObjectsAreNotEqual(f,new CompositeBinaryFunction<Object, Object, Object>( RightIdentity.FUNCTION, Constant.of("left"), Constant.of("right"))); assertObjectsAreNotEqual(f,new CompositeBinaryFunction<Object, Object, Object>( LeftIdentity.FUNCTION, Identity.instance(), Constant.of("right"))); assertObjectsAreNotEqual(f,new CompositeBinaryFunction<Object, Object, Object>( LeftIdentity.FUNCTION, Constant.of("left"), Identity.instance())); assertTrue(!((CompositeBinaryFunction<?,?,?>)f).equals(null)); }
|
### Question:
ConditionalPredicate implements Predicate<A> { public boolean test(A obj) { return ifPred.test(obj) ? thenPred.test(obj) : elsePred.test(obj); } ConditionalPredicate(Predicate<? super A> ifPred, Predicate<? super A> thenPred,
Predicate<? super A> elsePred); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testTest() throws Exception { ConditionalPredicate<Object> p = new ConditionalPredicate<Object>( Identity.INSTANCE, Constant.TRUE, Constant.FALSE); assertTrue(p.test(Boolean.TRUE)); assertTrue(!p.test(Boolean.FALSE)); }
|
### Question:
ConditionalPredicate implements Predicate<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ConditionalPredicate<?>)) { return false; } ConditionalPredicate<?> that = (ConditionalPredicate<?>) obj; return this.ifPred.equals(that.ifPred) && this.thenPred.equals(that.thenPred) && this.elsePred.equals(that.elsePred); } ConditionalPredicate(Predicate<? super A> ifPred, Predicate<? super A> thenPred,
Predicate<? super A> elsePred); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { ConditionalPredicate<Object> p = new ConditionalPredicate<Object>( Identity.INSTANCE, Constant.TRUE, Constant.TRUE); assertEquals(p,p); assertObjectsAreEqual(p,new ConditionalPredicate<Object>( Identity.INSTANCE, Constant.TRUE, Constant.TRUE)); assertObjectsAreNotEqual(p,new ConditionalPredicate<Object>( Identity.INSTANCE, Constant.FALSE, Constant.TRUE)); assertObjectsAreNotEqual(p,new ConditionalPredicate<Object>( Constant.TRUE, Constant.TRUE, Constant.TRUE)); assertObjectsAreNotEqual(p,new ConditionalPredicate<Object>( Identity.INSTANCE, Constant.TRUE, Constant.FALSE)); assertTrue(!p.equals(null)); }
|
### Question:
Or extends BasePredicateList<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof Or<?>)) { return false; } Or<?> that = (Or<?>) obj; return getPredicateListEquals(that); } Or(); Or(Iterable<Predicate<? super A>> predicates); Or(Predicate<? super A>... predicates); Or<A> or(Predicate<? super A> p); boolean test(A a); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { Or<Object> p = new Or<Object>(); assertEquals(p,p); Or<Object> q = new Or<Object>(); assertObjectsAreEqual(p,q); And<Object> r = new And<Object>(); assertObjectsAreNotEqual(p,r); for (int i=0;i<3;i++) { p.or(Constant.truePredicate()); assertObjectsAreNotEqual(p,q); q.or(Constant.truePredicate()); assertObjectsAreEqual(p,q); r.and(Constant.truePredicate()); assertObjectsAreNotEqual(p,r); p.or(new Or<Object>(Constant.truePredicate(),Constant.falsePredicate())); assertObjectsAreNotEqual(p,q); q.or(new Or<Object>(Constant.truePredicate(),Constant.falsePredicate())); assertObjectsAreEqual(p,q); r.and(new Or<Object>(Constant.truePredicate(),Constant.falsePredicate())); assertObjectsAreNotEqual(p,r); } assertObjectsAreNotEqual(p,Constant.truePredicate()); Or<Object> s = new Or<Object>(); s.or(Constant.truePredicate()); s.or(new Or<Object>(Constant.truePredicate(),Constant.falsePredicate())); assertObjectsAreEqual(s, new Or<Object>(s.getPredicateList())); }
|
### Question:
NullaryNot implements NullaryPredicate { public boolean test() { return !(predicate.test()); } NullaryNot(NullaryPredicate predicate); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryPredicate not(NullaryPredicate that); }### Answer:
@Test public void testTest() throws Exception { NullaryPredicate truePred = new NullaryNot(Constant.FALSE); assertTrue(truePred.test()); NullaryPredicate falsePred = new NullaryNot(Constant.TRUE); assertFalse(falsePred.test()); }
|
### Question:
FilteredGenerator extends BaseGenerator<E> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof FilteredGenerator<?>)) { return false; } FilteredGenerator<?> other = (FilteredGenerator<?>) obj; return other.getWrappedGenerator().equals(getWrappedGenerator()) && other.pred.equals(pred); } FilteredGenerator(Generator<? extends E> wrapped, Predicate<? super E> pred); void run(Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testEquals() { Generator<Integer> anotherGenerate = new FilteredGenerator<Integer>( IteratorToGeneratorAdapter.adapt(new IntegerRange(1, 10)), isEven); assertEquals(filteredGenerator, filteredGenerator); assertEquals(filteredGenerator, anotherGenerate); assertTrue(!filteredGenerator.equals((FilteredGenerator<Integer>)null)); Generator<Integer> aGenerateWithADifferentPredicate = new FilteredGenerator<Integer>( IteratorToGeneratorAdapter.adapt(new IntegerRange(1, 10)), new Predicate<Integer>() { public boolean test(Integer obj) { return obj % 2 == 0; } }); assertTrue(!filteredGenerator.equals(aGenerateWithADifferentPredicate)); Generator<Integer> aGenerateWithADifferentWrapped = new FilteredGenerator<Integer>( IteratorToGeneratorAdapter.adapt(new IntegerRange(1,11)), isEven); assertTrue(!filteredGenerator.equals(aGenerateWithADifferentWrapped)); }
|
### Question:
NullaryNot implements NullaryPredicate { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof NullaryNot)) { return false; } NullaryNot that = (NullaryNot) obj; return this.predicate.equals(that.predicate); } NullaryNot(NullaryPredicate predicate); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryPredicate not(NullaryPredicate that); }### Answer:
@Test public void testEquals() throws Exception { NullaryNot p = new NullaryNot(Constant.TRUE); assertEquals(p,p); assertObjectsAreEqual(p,new NullaryNot(Constant.TRUE)); assertObjectsAreEqual(p,NullaryNot.not(Constant.TRUE)); assertObjectsAreNotEqual(p,new NullaryNot(Constant.FALSE)); assertObjectsAreNotEqual(p,Constant.TRUE); assertTrue(!p.equals(null)); }
|
### Question:
NullaryNot implements NullaryPredicate { public static NullaryPredicate not(NullaryPredicate that) { return null == that ? null : new NullaryNot(that); } NullaryNot(NullaryPredicate predicate); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryPredicate not(NullaryPredicate that); }### Answer:
@Test public void testNotNull() throws Exception { assertNull(NullaryNot.not(null)); }
@Test public void testNotNotNull() throws Exception { assertNotNull(NullaryNot.not(Constant.TRUE)); }
|
### Question:
TransformedBinaryFunction implements BinaryFunction<L, R, T> { public final T evaluate(L left, R right) { return helper.evaluate(left, right); } <X> TransformedBinaryFunction(BinaryFunction<? super L, ? super R, ? extends X> preceding,
Function<? super X, ? extends T> following); final T evaluate(L left, R right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRun() { TransformedBinaryFunction<Integer, Integer, Integer> transform = new TransformedBinaryFunction<Integer, Integer, Integer>(new Sum(), new AddOne()); assertEquals(Integer.valueOf(4), transform.evaluate(1, 2)); }
|
### Question:
TransformedBinaryFunction implements BinaryFunction<L, R, T> { @Override public final boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TransformedBinaryFunction<?, ?, ?>)) { return false; } TransformedBinaryFunction<?, ?, ?> that = (TransformedBinaryFunction<?, ?, ?>) obj; return this.helper.preceding.equals(that.helper.preceding) && this.helper.following.equals(that.helper.following); } <X> TransformedBinaryFunction(BinaryFunction<? super L, ? super R, ? extends X> preceding,
Function<? super X, ? extends T> following); final T evaluate(L left, R right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { TransformedBinaryFunction<Integer, Integer, Integer> t = new TransformedBinaryFunction<Integer, Integer, Integer>(new Sum(), new AddOne()); BinaryFunction<Integer, Integer, Integer> f = new BinaryFunction<Integer, Integer, Integer>() { public Integer evaluate(Integer left, Integer right) { return left-right; } }; Function<Integer, Integer> p = new Function<Integer, Integer>() { public Integer evaluate(Integer obj) { return obj-1; } }; assertEquals(t,t); assertObjectsAreEqual(t,new TransformedBinaryFunction<Integer, Integer, Integer>(new Sum(), new AddOne())); assertObjectsAreNotEqual(t,new TransformedBinaryFunction<Integer, Integer, Integer>(f, new AddOne())); assertObjectsAreNotEqual(t,new TransformedBinaryFunction<Integer, Integer, Integer>(new Sum(), p)); assertTrue(!t.equals(null)); }
|
### Question:
BinaryNot implements BinaryPredicate<L, R> { public boolean test(L left, R right) { return !(predicate.test(left, right)); } BinaryNot(BinaryPredicate<? super L, ? super R> predicate); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryPredicate<L, R> not(BinaryPredicate<? super L, ? super R> that); }### Answer:
@Test public void testTest() throws Exception { BinaryPredicate<Integer, Integer> p = new BinaryNot<Integer, Integer>(new IsSumGreaterThanTen()); assertTrue(!p.test(9, 2)); assertTrue(p.test(9, 1)); }
|
### Question:
BinaryNot implements BinaryPredicate<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BinaryNot<?, ?>)) { return false; } BinaryNot<?, ?> that = (BinaryNot<?, ?>) obj; return this.predicate.equals(that.predicate); } BinaryNot(BinaryPredicate<? super L, ? super R> predicate); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryPredicate<L, R> not(BinaryPredicate<? super L, ? super R> that); }### Answer:
@Test public void testEquals() throws Exception { BinaryNot<Object, Object> p = new BinaryNot<Object, Object>(Constant.TRUE); assertEquals(p,p); assertObjectsAreEqual(p,new BinaryNot<Object, Object>(Constant.TRUE)); assertObjectsAreEqual(p,BinaryNot.not(Constant.TRUE)); assertObjectsAreNotEqual(p,new BinaryNot<Object, Object>(Constant.FALSE)); assertObjectsAreNotEqual(p,Constant.TRUE); assertTrue(!p.equals(null)); }
|
### Question:
BinaryNot implements BinaryPredicate<L, R> { public static <L, R> BinaryPredicate<L, R> not(BinaryPredicate<? super L, ? super R> that) { return null == that ? null : new BinaryNot<L, R>(that); } BinaryNot(BinaryPredicate<? super L, ? super R> predicate); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryPredicate<L, R> not(BinaryPredicate<? super L, ? super R> that); }### Answer:
@Test public void testNotNull() throws Exception { assertNull(BinaryNot.not(null)); }
@Test public void testNotNotNull() throws Exception { assertNotNull(BinaryNot.not(Constant.truePredicate())); }
|
### Question:
TransposedFunction implements BinaryFunction<L, R, T> { public final T evaluate(L left, R right) { return function.evaluate(right, left); } TransposedFunction(BinaryFunction<? super R, ? super L, ? extends T> function); final T evaluate(L left, R right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static TransposedFunction<R, L, T> transpose(BinaryFunction<? super L, ? super R, ? extends T> f); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryFunction<Object, Object, Object> f = new TransposedFunction<Object, Object, Object>(LeftIdentity.FUNCTION); assertEquals("xyzzy",f.evaluate(null,"xyzzy")); assertNull(f.evaluate("xyzzy",null)); }
|
### Question:
FilteredGenerator extends BaseGenerator<E> { @Override public int hashCode() { int result = "FilteredGenerator".hashCode(); result <<= 2; Generator<?> gen = getWrappedGenerator(); result ^= gen.hashCode(); result <<= 2; result ^= pred.hashCode(); return result; } FilteredGenerator(Generator<? extends E> wrapped, Predicate<? super E> pred); void run(Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testHashcode() { assertEquals(filteredGenerator.hashCode(), filteredGenerator.hashCode()); assertEquals(filteredGenerator.hashCode(), new FilteredGenerator<Integer>(wrappedGenerator, isEven).hashCode()); }
|
### Question:
TransposedFunction implements BinaryFunction<L, R, T> { @Override public final boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TransposedFunction<?, ?, ?>)) { return false; } TransposedFunction<?, ?, ?> that = (TransposedFunction<?, ?, ?>) obj; return this.function.equals(that.function); } TransposedFunction(BinaryFunction<? super R, ? super L, ? extends T> function); final T evaluate(L left, R right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static TransposedFunction<R, L, T> transpose(BinaryFunction<? super L, ? super R, ? extends T> f); }### Answer:
@Test public void testEquals() throws Exception { BinaryFunction<Object, Object, Object> f = new TransposedFunction<Object, Object, Object>(LeftIdentity.FUNCTION); assertEquals(f,f); assertObjectsAreEqual(f,new TransposedFunction<Object, Object, Object>(LeftIdentity.FUNCTION)); assertObjectsAreNotEqual(f,new TransposedFunction<Object, Object, Object>(RightIdentity.FUNCTION)); assertObjectsAreNotEqual(f,Constant.of("y")); assertTrue(!f.equals((TransposedFunction<?, ?, ?>)null)); }
|
### Question:
TransposedFunction implements BinaryFunction<L, R, T> { public static <L, R, T> TransposedFunction<R, L, T> transpose(BinaryFunction<? super L, ? super R, ? extends T> f) { return null == f ? null : new TransposedFunction<R, L, T>(f); } TransposedFunction(BinaryFunction<? super R, ? super L, ? extends T> function); final T evaluate(L left, R right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static TransposedFunction<R, L, T> transpose(BinaryFunction<? super L, ? super R, ? extends T> f); }### Answer:
@Test public void testTransposeNull() throws Exception { assertNull(TransposedFunction.transpose(null)); }
@Test public void testTranspose() throws Exception { assertNotNull(TransposedFunction.transpose(Constant.of("x"))); }
|
### Question:
Sequence implements Procedure<A> { public void run(A obj) { for (Iterator<Procedure<? super A>> iter = list.iterator(); iter.hasNext();) { iter.next().run(obj); } } Sequence(); Sequence(Procedure<? super A>... procedures); Sequence(Iterable<Procedure<? super A>> procedures); Sequence<A> then(Procedure<? super A> p); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRunZero() throws Exception { Sequence<String> seq = new Sequence<String>(); seq.run(null); seq.run("xyzzy"); }
@Test public void testRunOne() throws Exception { RunCounter counter = new RunCounter(); Sequence<String> seq = new Sequence<String>(counter); assertEquals(0,counter.count); seq.run(null); assertEquals(1,counter.count); seq.run("xyzzy"); assertEquals(2,counter.count); }
@Test public void testRunTwo() throws Exception { RunCounter[] counter = { new RunCounter(), new RunCounter() }; Sequence<String> seq = new Sequence<String>(counter[0],counter[1]); assertEquals(0,counter[0].count); assertEquals(0,counter[1].count); seq.run(null); assertEquals(1,counter[0].count); assertEquals(1,counter[1].count); seq.run("xyzzy"); assertEquals(2,counter[0].count); assertEquals(2,counter[1].count); }
|
### Question:
Sequence implements Procedure<A> { public Sequence<A> then(Procedure<? super A> p) { if (p != null) { list.add(p); } return this; } Sequence(); Sequence(Procedure<? super A>... procedures); Sequence(Iterable<Procedure<? super A>> procedures); Sequence<A> then(Procedure<? super A> p); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testThen() throws Exception { List<RunCounter> list = new ArrayList<RunCounter>(); Sequence<String> seq = new Sequence<String>(); seq.run(null); for (int i=0;i<10;i++) { RunCounter counter = new RunCounter(); seq.then(counter); list.add(counter); seq.run("xyzzy"); for (int j=0;j<list.size();j++) { assertEquals(list.size()-j,((list.get(j)).count)); } } }
|
### Question:
Sequence implements Procedure<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof Sequence<?>)) { return false; } Sequence<?> that = (Sequence<?>) obj; return this.list.equals(that.list); } Sequence(); Sequence(Procedure<? super A>... procedures); Sequence(Iterable<Procedure<? super A>> procedures); Sequence<A> then(Procedure<? super A> p); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { Sequence<?> p = new Sequence<Object>(); assertEquals(p,p); Sequence<?> q = new Sequence<Object>(); assertObjectsAreEqual(p,q); for (int i=0;i<3;i++) { p.then(new NoOp()); assertObjectsAreNotEqual(p,q); q.then(new NoOp()); assertObjectsAreEqual(p,q); p.then(new Sequence<Object>(new NoOp(),new NoOp())); assertObjectsAreNotEqual(p,q); q.then(new Sequence<Object>(new NoOp(),new NoOp())); assertObjectsAreEqual(p,q); } assertObjectsAreNotEqual(p,new NoOp()); assertFalse(p.equals(null)); }
|
### Question:
CompositeFunction implements Function<A, T> { public final T evaluate(A obj) { return function.evaluate(obj); } CompositeFunction(Function<? super A, ? extends T> function); private <X> CompositeFunction(Function<? super X, ? extends T> following,
Function<? super A, ? extends X> preceding); final T evaluate(A obj); final CompositeFunction<P, T> of(Function<? super P, ? extends A> preceding); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEvaluate() throws Exception { assertEquals(Integer.valueOf(4),(new CompositeFunction<Object, Integer>(Constant.of(4))).evaluate(null)); assertEquals(Integer.valueOf(4),(Composite.function(Constant.of(4)).of(Constant.of(3)).evaluate("xyzzy"))); assertEquals(Integer.valueOf(3),(new CompositeFunction<Object, Integer>(Constant.of(3)).of(Constant.of(4)).evaluate("xyzzy"))); }
|
### Question:
FilteredGenerator extends BaseGenerator<E> { public void run(Procedure<? super E> proc) { getWrappedGenerator().run(new ConditionalProcedure<E>(pred, proc)); } FilteredGenerator(Generator<? extends E> wrapped, Predicate<? super E> pred); void run(Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testGenerate() { final List<Integer> evenNumbers = new ArrayList<Integer>(); filteredGenerator.run(new Procedure<Integer>() { public void run(Integer obj) { evenNumbers.add(obj); } }); assertEquals(4, evenNumbers.size()); List<Integer> expected = Arrays.asList(2, 4, 6, 8); assertEquals(expected, evenNumbers); }
|
### Question:
CompositeFunction implements Function<A, T> { public final <P> CompositeFunction<P, T> of(Function<? super P, ? extends A> preceding) { Validate.notNull(preceding, "preceding function was null"); return new CompositeFunction<P, T>(function, preceding); } CompositeFunction(Function<? super A, ? extends T> function); private <X> CompositeFunction(Function<? super X, ? extends T> following,
Function<? super A, ? extends X> preceding); final T evaluate(A obj); final CompositeFunction<P, T> of(Function<? super P, ? extends A> preceding); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testOf() throws Exception { Function<Object, Integer> uf = new Function<Object, Integer>() { public Integer evaluate(Object obj) { if (obj instanceof Integer) { return (((Integer) obj).intValue()) + 1; } else { return 1; } } }; CompositeFunction<Object, Integer> f = null; for (int i = 0; i < 10; i++) { f = f == null ? new CompositeFunction<Object, Integer>(uf) : f.of(uf); assertEquals(Integer.valueOf(i+1),f.evaluate(null)); } }
|
### Question:
CompositeFunction implements Function<A, T> { @Override public final boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof CompositeFunction<?, ?>)) { return false; } CompositeFunction<?, ?> that = (CompositeFunction<?, ?>) obj; return this.function.equals(that.function); } CompositeFunction(Function<? super A, ? extends T> function); private <X> CompositeFunction(Function<? super X, ? extends T> following,
Function<? super A, ? extends X> preceding); final T evaluate(A obj); final CompositeFunction<P, T> of(Function<? super P, ? extends A> preceding); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { CompositeFunction<Object, String> f = new CompositeFunction<Object, String>(Constant.of("x")); assertEquals(f,f); CompositeFunction<Object, String> g = new CompositeFunction<Object, String>(Constant.of("x")); assertObjectsAreEqual(f,g); for (int i=0;i<3;i++) { f = f.of(Constant.of("y")).of(Constant.of("z")); System.out.println(f); System.out.println(f.hashCode()); System.out.println(g); System.out.println(g.hashCode()); assertObjectsAreNotEqual(f,g); g = g.of(Constant.of("y")).of(Constant.of("z")); assertObjectsAreEqual(f,g); } assertObjectsAreNotEqual(f, Constant.of("y")); assertObjectsAreNotEqual(Constant.of("y"), f); assertObjectsAreNotEqual(f, Identity.instance()); assertTrue(!f.equals(null)); }
|
### Question:
TransformedNullaryFunction implements NullaryFunction<T> { public final T evaluate() { return helper.evaluate(); } <X> TransformedNullaryFunction(NullaryFunction<? extends X> preceding,
Function<? super X, ? extends T> following); final T evaluate(); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRun() { TransformedNullaryFunction<Integer> p = new TransformedNullaryFunction<Integer>(one, addOne); assertEquals(Integer.valueOf(2), p.evaluate()); }
|
### Question:
TransformedNullaryFunction implements NullaryFunction<T> { @Override public final boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TransformedNullaryFunction<?>)) { return false; } TransformedNullaryFunction<?> that = (TransformedNullaryFunction<?>) obj; return this.helper.preceding.equals(that.helper.preceding) && this.helper.following.equals(that.helper.following); } <X> TransformedNullaryFunction(NullaryFunction<? extends X> preceding,
Function<? super X, ? extends T> following); final T evaluate(); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { TransformedNullaryFunction<Integer> t = new TransformedNullaryFunction<Integer>(one, addOne); NullaryFunction<Integer> f = new NullaryFunction<Integer>() { public Integer evaluate() { return Integer.valueOf(2); } }; Function<Integer, Integer> p = new Function<Integer, Integer>() { public Integer evaluate(Integer obj) { return obj + 2; } }; assertEquals(t, t); assertObjectsAreEqual(t, new TransformedNullaryFunction<Integer>(one, addOne)); assertObjectsAreNotEqual(t, new TransformedNullaryFunction<Integer>(f, addOne)); assertObjectsAreNotEqual(t, new TransformedNullaryFunction<Integer>(one, p)); assertTrue(!t.equals(null)); }
|
### Question:
NullaryOr extends BaseNullaryPredicateList { public boolean test() { for (NullaryPredicate p : getNullaryPredicateList()) { if (p.test()) { return true; } } return false; } NullaryOr(); NullaryOr(Iterable<NullaryPredicate> predicates); NullaryOr(NullaryPredicate... predicates); NullaryOr or(NullaryPredicate p); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testConstructors() { NullaryOr or = new NullaryOr(Constant.FALSE); assertEquals(Boolean.FALSE, or.test()); NullaryOr or2 = new NullaryOr((Iterable<NullaryPredicate>)Arrays.asList((NullaryPredicate)Constant.truePredicate())); assertEquals(Boolean.TRUE, or2.test()); NullaryOr or3 = new NullaryOr((NullaryPredicate)null); assertEquals(Boolean.FALSE, or3.test()); NullaryOr or4 = new NullaryOr((Iterable<NullaryPredicate>)null); assertEquals(Boolean.FALSE, or4.test()); }
|
### Question:
NullaryOr extends BaseNullaryPredicateList { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof NullaryOr)) { return false; } NullaryOr that = (NullaryOr) obj; return getNullaryPredicateListEquals(that); } NullaryOr(); NullaryOr(Iterable<NullaryPredicate> predicates); NullaryOr(NullaryPredicate... predicates); NullaryOr or(NullaryPredicate p); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { NullaryOr p = new NullaryOr(); assertEquals(p,p); NullaryOr q = new NullaryOr(); assertObjectsAreEqual(p,q); NullaryAnd r = new NullaryAnd(); assertObjectsAreNotEqual(p,r); for (int i=0;i<3;i++) { p.or(Constant.TRUE); assertObjectsAreNotEqual(p,q); q.or(Constant.TRUE); assertObjectsAreEqual(p,q); r.and(Constant.TRUE); assertObjectsAreNotEqual(p,r); p.or(new NullaryOr(Constant.TRUE,Constant.FALSE)); assertObjectsAreNotEqual(p,q); q.or(new NullaryOr(Constant.TRUE,Constant.FALSE)); assertObjectsAreEqual(p,q); r.and(new NullaryOr(Constant.TRUE,Constant.FALSE)); assertObjectsAreNotEqual(p,r); } assertObjectsAreNotEqual(p,Constant.TRUE); assertObjectsAreNotEqual(p,new NullaryOr((Iterable<NullaryPredicate>)null)); assertObjectsAreNotEqual(p,new NullaryOr((NullaryPredicate[])null)); assertObjectsAreNotEqual(p,new NullaryOr((NullaryPredicate)null)); assertTrue(!p.equals(null)); }
|
### Question:
BinarySequence implements BinaryProcedure<L, R> { public final void run(L left, R right) { for (Iterator<BinaryProcedure<? super L, ? super R>> iter = list.iterator(); iter.hasNext();) { iter.next().run(left, right); } } BinarySequence(); BinarySequence(BinaryProcedure<? super L, ? super R>... procedures); BinarySequence(Iterable<BinaryProcedure<? super L, ? super R>> procedures); final BinarySequence<L, R> then(BinaryProcedure<? super L, ? super R> p); final void run(L left, R right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRunZero() throws Exception { BinarySequence<String, String> seq = new BinarySequence<String, String>(); seq.run(null,null); seq.run("xyzzy","xyzzy"); }
@Test public void testRunOne() throws Exception { RunCounter counter = new RunCounter(); BinarySequence<String, String> seq = new BinarySequence<String, String>(counter); assertEquals(0,counter.count); seq.run(null,null); assertEquals(1,counter.count); seq.run("xyzzy","xyzzy"); assertEquals(2,counter.count); }
@Test public void testRunTwo() throws Exception { RunCounter[] counter = { new RunCounter(), new RunCounter() }; BinarySequence<String, String> seq = new BinarySequence<String, String>(counter[0],counter[1]); assertEquals(0,counter[0].count); assertEquals(0,counter[1].count); seq.run(null,null); assertEquals(1,counter[0].count); assertEquals(1,counter[1].count); seq.run("xyzzy","xyzzy"); assertEquals(2,counter[0].count); assertEquals(2,counter[1].count); }
|
### Question:
BinarySequence implements BinaryProcedure<L, R> { public final BinarySequence<L, R> then(BinaryProcedure<? super L, ? super R> p) { list.add(p); return this; } BinarySequence(); BinarySequence(BinaryProcedure<? super L, ? super R>... procedures); BinarySequence(Iterable<BinaryProcedure<? super L, ? super R>> procedures); final BinarySequence<L, R> then(BinaryProcedure<? super L, ? super R> p); final void run(L left, R right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testThen() throws Exception { List<RunCounter> list = new ArrayList<RunCounter>(); BinarySequence<String, String> seq = new BinarySequence<String, String>(); seq.run(null,null); for (int i=0;i<10;i++) { RunCounter counter = new RunCounter(); seq.then(counter); list.add(counter); seq.run("xyzzy","xyzzy"); for (int j=0;j<list.size();j++) { assertEquals(list.size()-j,(((RunCounter)(list.get(j))).count)); } } }
|
### Question:
Endpoint { public T getValue() { return value; } Endpoint(T value, BoundType boundType); T getValue(); BoundType getBoundType(); @Override String toString(); @Override boolean equals(Object obj); @Override int hashCode(); String toLeftString(); String toRightString(); }### Answer:
@Test public void testValue() { assertEquals(Integer.valueOf(1), openEndpoint.getValue()); assertEquals(Integer.valueOf(2), closedEndpoint.getValue()); }
|
### Question:
ConditionalBinaryFunction implements BinaryFunction<L, R, T> { public T evaluate(L left, R right) { if (ifPred.test(left, right)) { return thenFunc.evaluate(left, right); } else { return elseFunc.evaluate(left, right); } } ConditionalBinaryFunction(BinaryPredicate<? super L, ? super R> ifPred,
BinaryFunction<? super L, ? super R, ? extends T> thenFunc,
BinaryFunction<? super L, ? super R, ? extends T> elseFunc); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEvaluate() throws Exception { ConditionalBinaryFunction<Boolean, Object, String> f = new ConditionalBinaryFunction<Boolean, Object, String>( LeftIdentity.PREDICATE, Constant.of("left"), Constant.of("right")); assertEquals("left",f.evaluate(Boolean.TRUE,null)); assertEquals("right",f.evaluate(Boolean.FALSE,null)); }
|
### Question:
ConditionalBinaryFunction implements BinaryFunction<L, R, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ConditionalBinaryFunction<?, ?, ?>)) { return false; } ConditionalBinaryFunction<?, ?, ?> that = (ConditionalBinaryFunction<?, ?, ?>) obj; return this.ifPred.equals(that.ifPred) && this.thenFunc.equals(that.thenFunc) && this.elseFunc.equals(that.elseFunc); } ConditionalBinaryFunction(BinaryPredicate<? super L, ? super R> ifPred,
BinaryFunction<? super L, ? super R, ? extends T> thenFunc,
BinaryFunction<? super L, ? super R, ? extends T> elseFunc); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { ConditionalBinaryFunction<Boolean, Object, String> f = new ConditionalBinaryFunction<Boolean, Object, String>( LeftIdentity.PREDICATE, Constant.of("left"), Constant.of("right")); assertEquals(f,f); assertObjectsAreEqual(f,new ConditionalBinaryFunction<Boolean, Object, String>( LeftIdentity.PREDICATE, Constant.of("left"), Constant.of("right"))); assertObjectsAreNotEqual(f,new ConditionalBinaryFunction<Boolean, Object, Object>( LeftIdentity.PREDICATE, Constant.of(null), Constant.of("right"))); assertObjectsAreNotEqual(f,new ConditionalBinaryFunction<Boolean, Object, String>( Constant.TRUE, Constant.of("left"), Constant.of("right"))); assertObjectsAreNotEqual(f,new ConditionalBinaryFunction<Boolean, Object, Object>( LeftIdentity.PREDICATE, Constant.of("left"), Constant.of(null))); assertTrue(!f.equals(null)); }
|
### Question:
WhileDoNullaryProcedure extends AbstractLoopNullaryProcedure { public void run() { while (getCondition().test()) { getAction().run(); } } WhileDoNullaryProcedure(NullaryPredicate condition, NullaryProcedure action); void run(); @Override String toString(); }### Answer:
@Test public void testLoopWithAction() throws Exception { List<Object> list=getList(); NullaryProcedure action=new ListRemoveFirstProcedure(list); NullaryPredicate condition=new NullaryNot(new BoundNullaryPredicate(new IsEmpty<List<Object>>(), list)); NullaryProcedure procedure=new WhileDoNullaryProcedure(condition, action); assertTrue("The condition should be true before running the loop", condition.test()); assertFalse("The list should not be empty then", list.isEmpty()); procedure.run(); assertFalse("The condition should be false after running the loop", condition.test()); assertTrue("The list should be empty then", list.isEmpty()); list=getList(); action=new ListRemoveFirstProcedure(list); condition=new NullaryPredicate() { private int count=2; public boolean test() { return count-- > 0; } }; procedure=new WhileDoNullaryProcedure(condition, action); procedure.run(); assertFalse("The list should not contain \"a\" anymore", list.contains("a")); assertFalse("The list should not contain \"b\" anymore", list.contains("b")); assertTrue("The list should still contain \"c\"", list.contains("c")); assertTrue("The list should still contain \"d\"", list.contains("d")); }
@Test public void testLoopForNothing() { List<Object> list=getList(); NullaryProcedure action=new ListRemoveFirstProcedure(list); NullaryProcedure procedure=new WhileDoNullaryProcedure(Constant.FALSE, action); assertTrue("The list should contain 4 elements before runnning the loop", list.size()==4); procedure.run(); assertTrue("The list should contain 4 elements after runnning the loop", list.size()==4); }
|
### Question:
TransformedBinaryProcedure implements BinaryProcedure<L, R> { public final void run(L left, R right) { helper.run(left, right); } <X> TransformedBinaryProcedure(BinaryFunction<? super L, ? super R, ? extends X> function,
Procedure<? super X> procedure); final void run(L left, R right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRun() { Total t = new Total(); TransformedBinaryProcedure<Integer, Integer> transform = new TransformedBinaryProcedure<Integer, Integer>(new Sum(), t); transform.run(1, 2); assertEquals(Integer.valueOf(3), t.getTotal()); }
|
### Question:
TransformedBinaryProcedure implements BinaryProcedure<L, R> { @Override public final boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TransformedBinaryProcedure<?, ?>)) { return false; } TransformedBinaryProcedure<?, ?> that = (TransformedBinaryProcedure<?, ?>) obj; return this.helper.function.equals(that.helper.function) && this.helper.procedure.equals(that.helper.procedure); } <X> TransformedBinaryProcedure(BinaryFunction<? super L, ? super R, ? extends X> function,
Procedure<? super X> procedure); final void run(L left, R right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { TransformedBinaryProcedure<Integer, Integer> t = new TransformedBinaryProcedure<Integer, Integer>(new Sum(), new Total()); BinaryFunction<Integer, Integer, Integer> f = new BinaryFunction<Integer, Integer, Integer>() { public Integer evaluate(Integer left, Integer right) { return left-right; } }; Procedure<Integer> p = new Procedure<Integer>() { public void run(Integer obj) { } }; assertEquals(t,t); assertObjectsAreEqual(t,new TransformedBinaryProcedure<Integer, Integer>(new Sum(), new Total())); assertObjectsAreNotEqual(t,new TransformedBinaryProcedure<Integer, Integer>(f, new Total())); assertObjectsAreNotEqual(t,new TransformedBinaryProcedure<Integer, Integer>(new Sum(), p)); assertTrue(!t.equals(null)); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.