method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
TransformedNullaryProcedure implements NullaryProcedure { public final void run() { helper.run(); } <X> TransformedNullaryProcedure(NullaryFunction<? extends X> function, Procedure<? super X> procedure); final void run(); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRun() { TransformedNullaryProcedure p = new TransformedNullaryProcedure(one, aggregator); p.run(); assertEquals(1, aggregator.getTotal()); }
|
### Question:
TransformedNullaryProcedure implements NullaryProcedure { @Override public final boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TransformedNullaryProcedure)) { return false; } TransformedNullaryProcedure that = (TransformedNullaryProcedure) obj; return this.helper.function.equals(that.helper.function) && this.helper.procedure.equals(that.helper.procedure); } <X> TransformedNullaryProcedure(NullaryFunction<? extends X> function, Procedure<? super X> procedure); final void run(); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { TransformedNullaryProcedure t = new TransformedNullaryProcedure(one, aggregator); NullaryFunction<Integer> f = new NullaryFunction<Integer>() { public Integer evaluate() { return Integer.valueOf(2); } }; Procedure<Integer> p = new Procedure<Integer>() { public void run(Integer obj) { } }; assertEquals(t, t); assertObjectsAreEqual(t, new TransformedNullaryProcedure(one, aggregator)); assertObjectsAreNotEqual(t, new TransformedNullaryProcedure(f, aggregator)); assertObjectsAreNotEqual(t, new TransformedNullaryProcedure(one, p)); assertTrue(!t.equals(null)); }
|
### Question:
TransposedProcedure implements BinaryProcedure<L, R> { public void run(L left, R right) { procedure.run(right, left); } TransposedProcedure(BinaryProcedure<? super R, ? super L> procedure); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static TransposedProcedure<R, L> transpose(BinaryProcedure<? super L, ? super R> p); }### Answer:
@Test public void testEvaluate() throws Exception { LeftNotNullCounter counter = new LeftNotNullCounter(); BinaryProcedure<Object, Object> p = new TransposedProcedure<Object, Object>(counter); assertEquals(0,counter.count); p.run(null,"not null"); assertEquals(1,counter.count); p.run("not null",null); assertEquals(1,counter.count); }
|
### Question:
Endpoint { public BoundType getBoundType() { return boundType; } 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 testBoundType() { assertEquals(BoundType.OPEN, openEndpoint.getBoundType()); assertEquals(BoundType.CLOSED, closedEndpoint.getBoundType()); }
|
### Question:
TransposedProcedure implements BinaryProcedure<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TransposedProcedure<?, ?>)) { return false; } TransposedProcedure<?, ?> that = (TransposedProcedure<?, ?>) obj; return this.procedure.equals(that.procedure); } TransposedProcedure(BinaryProcedure<? super R, ? super L> procedure); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static TransposedProcedure<R, L> transpose(BinaryProcedure<? super L, ? super R> p); }### Answer:
@Test public void testEquals() throws Exception { BinaryProcedure<Object, Object> p = new TransposedProcedure<Object, Object>(NoOp.INSTANCE); assertEquals(p,p); assertObjectsAreEqual(p,new TransposedProcedure<Object, Object>(NoOp.INSTANCE)); assertObjectsAreEqual(p,TransposedProcedure.transpose(NoOp.INSTANCE)); assertObjectsAreNotEqual(p,new TransposedProcedure<Object, Object>(new TransposedProcedure<Object, Object>(NoOp.INSTANCE))); assertObjectsAreNotEqual(p,NoOp.INSTANCE); assertTrue(!p.equals((TransposedProcedure<?, ?>)null)); }
|
### Question:
TransposedProcedure implements BinaryProcedure<L, R> { public static <L, R> TransposedProcedure<R, L> transpose(BinaryProcedure<? super L, ? super R> p) { return null == p ? null : new TransposedProcedure<R, L>(p); } TransposedProcedure(BinaryProcedure<? super R, ? super L> procedure); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static TransposedProcedure<R, L> transpose(BinaryProcedure<? super L, ? super R> p); }### Answer:
@Test public void testTransposeNull() throws Exception { assertNull(TransposedProcedure.transpose(null)); }
@Test public void testTranspose() throws Exception { assertNotNull(TransposedProcedure.transpose(NoOp.INSTANCE)); }
|
### Question:
ConditionalBinaryPredicate implements BinaryPredicate<L, R> { public boolean test(L left, R right) { return ifPred.test(left, right) ? thenPred.test(left, right) : elsePred.test(left, right); } ConditionalBinaryPredicate(BinaryPredicate<? super L, ? super R> ifPred,
BinaryPredicate<? super L, ? super R> thenPred, BinaryPredicate<? super L, ? super R> elsePred); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testTest() throws Exception { { ConditionalBinaryPredicate<Object, Object> p = new ConditionalBinaryPredicate<Object, Object>( Constant.TRUE, Constant.TRUE, Constant.FALSE); assertTrue(p.test(null,null)); } { ConditionalBinaryPredicate<Object, Object> p = new ConditionalBinaryPredicate<Object, Object>( Constant.FALSE, Constant.TRUE, Constant.FALSE); assertFalse(p.test(null,null)); } }
|
### Question:
ConditionalBinaryPredicate implements BinaryPredicate<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ConditionalBinaryPredicate<?, ?>)) { return false; } ConditionalBinaryPredicate<?, ?> that = (ConditionalBinaryPredicate<?, ?>) obj; return this.ifPred.equals(that.ifPred) && this.thenPred.equals(that.thenPred) && this.elsePred.equals(that.elsePred); } ConditionalBinaryPredicate(BinaryPredicate<? super L, ? super R> ifPred,
BinaryPredicate<? super L, ? super R> thenPred, BinaryPredicate<? super L, ? super R> elsePred); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { ConditionalBinaryPredicate<Object, Object> p = new ConditionalBinaryPredicate<Object, Object>( Constant.TRUE, Constant.TRUE, Constant.FALSE); assertEquals(p,p); assertObjectsAreEqual(p,new ConditionalBinaryPredicate<Object, Object>( Constant.TRUE, Constant.TRUE, Constant.FALSE)); assertObjectsAreNotEqual(p,new ConditionalBinaryPredicate<Object, Object>( Constant.TRUE, Constant.FALSE, Constant.TRUE)); assertObjectsAreNotEqual(p,new ConditionalBinaryPredicate<Object, Object>( Constant.TRUE, Constant.TRUE, Constant.TRUE)); assertObjectsAreNotEqual(p,new ConditionalBinaryPredicate<Object, Object>( Constant.FALSE, Constant.TRUE, Constant.FALSE)); assertTrue(!p.equals(null)); }
|
### Question:
ConditionalNullaryFunction implements NullaryFunction<T> { public T evaluate() { if (ifPred.test()) { return thenFunc.evaluate(); } else { return elseFunc.evaluate(); } } ConditionalNullaryFunction(NullaryPredicate ifPred, NullaryFunction<? extends T> thenFunc,
NullaryFunction<? extends T> elseFunc); T evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEvaluate() throws Exception { { ConditionalNullaryFunction<Object> f = new ConditionalNullaryFunction<Object>( Constant.TRUE, Constant.of("left"), Constant.of("right")); assertEquals("left",f.evaluate()); } { ConditionalNullaryFunction<Object> f = new ConditionalNullaryFunction<Object>( Constant.FALSE, Constant.of("left"), Constant.of("right")); assertEquals("right",f.evaluate()); } }
|
### Question:
ConditionalNullaryFunction implements NullaryFunction<T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ConditionalNullaryFunction<?>)) { return false; } ConditionalNullaryFunction<?> that = (ConditionalNullaryFunction<?>) obj; return this.ifPred.equals(that.ifPred) && this.thenFunc.equals(that.thenFunc) && this.elseFunc.equals(that.elseFunc); } ConditionalNullaryFunction(NullaryPredicate ifPred, NullaryFunction<? extends T> thenFunc,
NullaryFunction<? extends T> elseFunc); T evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { ConditionalNullaryFunction<Object> f = new ConditionalNullaryFunction<Object>( Constant.TRUE, Constant.of("left"), Constant.of("right")); assertEquals(f,f); assertObjectsAreEqual(f,new ConditionalNullaryFunction<Object>( Constant.TRUE, Constant.of("left"), Constant.of("right"))); assertObjectsAreNotEqual(f,new ConditionalNullaryFunction<Object>( Constant.TRUE, Constant.of(null), Constant.of("right"))); assertObjectsAreNotEqual(f,new ConditionalNullaryFunction<Object>( Constant.TRUE, Constant.of("left"), Constant.of(null))); assertObjectsAreNotEqual(f,new ConditionalNullaryFunction<Object>( Constant.FALSE, Constant.of("left"), Constant.of("right"))); assertTrue(!f.equals(null)); }
|
### Question:
ConditionalNullaryProcedure implements NullaryProcedure { public void run() { if (ifPred.test()) { thenProc.run(); } else { elseProc.run(); } } ConditionalNullaryProcedure(NullaryPredicate ifPred, NullaryProcedure thenProc); ConditionalNullaryProcedure(NullaryPredicate ifPred, NullaryProcedure thenProc, NullaryProcedure elseProc); void run(); @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(); ConditionalNullaryProcedure p = new ConditionalNullaryProcedure( Constant.TRUE, left, right); assertEquals(0,left.count); assertEquals(0,right.count); p.run(); assertEquals(1,left.count); assertEquals(0,right.count); p.run(); assertEquals(2,left.count); assertEquals(0,right.count); p.run(); assertEquals(3,left.count); assertEquals(0,right.count); } { RunCounter left = new RunCounter(); RunCounter right = new RunCounter(); ConditionalNullaryProcedure p = new ConditionalNullaryProcedure( Constant.FALSE, left, right); assertEquals(0,left.count); assertEquals(0,right.count); p.run(); assertEquals(0,left.count); assertEquals(1,right.count); p.run(); assertEquals(0,left.count); assertEquals(2,right.count); p.run(); assertEquals(0,left.count); assertEquals(3,right.count); } }
|
### Question:
ConditionalNullaryProcedure implements NullaryProcedure { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ConditionalNullaryProcedure)) { return false; } ConditionalNullaryProcedure that = (ConditionalNullaryProcedure) obj; return this.ifPred.equals(that.ifPred) && this.thenProc.equals(that.thenProc) && this.elseProc.equals(that.elseProc); } ConditionalNullaryProcedure(NullaryPredicate ifPred, NullaryProcedure thenProc); ConditionalNullaryProcedure(NullaryPredicate ifPred, NullaryProcedure thenProc, NullaryProcedure elseProc); void run(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { ConditionalNullaryProcedure p = new ConditionalNullaryProcedure( Constant.FALSE, NoOp.INSTANCE, NoOp.INSTANCE); assertEquals(p,p); assertObjectsAreEqual(p,new ConditionalNullaryProcedure( Constant.FALSE, NoOp.INSTANCE, NoOp.INSTANCE)); assertObjectsAreNotEqual(p,new ConditionalNullaryProcedure( Constant.TRUE, NoOp.INSTANCE, NoOp.INSTANCE)); assertObjectsAreNotEqual(p,new ConditionalNullaryProcedure( Constant.TRUE, NoOp.INSTANCE, NoOp.INSTANCE)); assertObjectsAreNotEqual(p,new ConditionalNullaryProcedure( Constant.FALSE, new RunCounter(), NoOp.INSTANCE)); assertObjectsAreNotEqual(p,new ConditionalNullaryProcedure( Constant.FALSE, NoOp.INSTANCE, new RunCounter())); assertObjectsAreNotEqual(p,new ConditionalNullaryProcedure( Constant.TRUE, NoOp.INSTANCE)); assertTrue(!p.equals(null)); }
|
### Question:
Endpoint { @Override public String toString() { String boundType = this.boundType == BoundType.OPEN ? "OPEN" : "CLOSED"; return "Endpoint<" + this.value + ", " + boundType + ">"; } 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 testToString() { assertEquals("Endpoint<1, OPEN>", openEndpoint.toString()); assertEquals("Endpoint<2, CLOSED>", closedEndpoint.toString()); assertEquals("(1", openEndpoint.toLeftString()); assertEquals("[2", closedEndpoint.toLeftString()); assertEquals("1)", openEndpoint.toRightString()); assertEquals("2]", closedEndpoint.toRightString()); }
|
### Question:
WhileGenerate extends LoopGenerator<E> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof WhileGenerate<?>)) { return false; } WhileGenerate<?> other = (WhileGenerate<?>) obj; return other.getWrappedGenerator().equals(getWrappedGenerator()) && other.test.equals(test); } WhileGenerate(Predicate<? super E> test, Generator<? extends E> wrapped); void run(final Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testEquals() { Generator<Integer> anotherGenerate = new WhileGenerate<Integer>( isLessThanFive, IteratorToGeneratorAdapter.adapt(new IntegerRange(1, 10))); assertEquals(whileGenerate, whileGenerate); assertEquals(whileGenerate, anotherGenerate); assertTrue(!whileGenerate.equals((WhileGenerate<Integer>)null)); Generator<Integer> aGenerateWithADifferentPredicate = new WhileGenerate<Integer>( new Predicate<Integer>() { public boolean test(Integer obj) { return obj < FIVE; } }, IteratorToGeneratorAdapter.adapt(new IntegerRange(1, 10))); assertTrue(!whileGenerate.equals(aGenerateWithADifferentPredicate)); Generator<Integer> aGenerateWithADifferentWrapped = new WhileGenerate<Integer>( isLessThanFive, IteratorToGeneratorAdapter.adapt(new IntegerRange(1,11))); assertTrue(!whileGenerate.equals(aGenerateWithADifferentWrapped)); }
|
### Question:
DoWhileNullaryProcedure extends AbstractLoopNullaryProcedure { public final void run() { do { getAction().run(); } while (getCondition().test()); } DoWhileNullaryProcedure(NullaryProcedure action, NullaryPredicate condition); final 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 DoWhileNullaryProcedure(action, condition); 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 DoWhileNullaryProcedure(action, condition); procedure.run(); assertFalse("The list should not contain \"a\" anymore", list.contains("a")); assertFalse("The list should not contain \"b\" anymore", list.contains("b")); assertFalse("The list should not contain \"c\" anymore", 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 DoWhileNullaryProcedure(action, Constant.FALSE); assertTrue("The list should contain 4 elements before runnning the loop", list.size()==4); procedure.run(); assertTrue("The list should contain 3 elements after runnning the loop", list.size()==3); }
|
### Question:
CompositePredicate implements Predicate<A> { public <P> CompositePredicate<P> of(Function<? super P, ? extends A> preceding) { return new CompositePredicate<P>(function.of(preceding)); } CompositePredicate(Predicate<? super A> predicate); private CompositePredicate(CompositeFunction<? super A, Boolean> function); CompositePredicate<P> of(Function<? super P, ? extends A> preceding); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testOf() throws Exception { CompositePredicate<Object> f = new CompositePredicate<Object>(Constant.TRUE); assertTrue(f.test(null)); for (int i=0;i<10;i++) { f = f.of(Constant.FALSE); assertTrue(f.test(null)); } }
|
### Question:
CompositePredicate implements Predicate<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof CompositePredicate<?>)) { return false; } CompositePredicate<?> that = (CompositePredicate<?>) obj; return this.function.equals(that.function); } CompositePredicate(Predicate<? super A> predicate); private CompositePredicate(CompositeFunction<? super A, Boolean> function); CompositePredicate<P> of(Function<? super P, ? extends A> preceding); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { CompositePredicate<Object> f = new CompositePredicate<Object>(Constant.TRUE); assertEquals(f,f); CompositePredicate<Object> g = new CompositePredicate<Object>(Constant.TRUE); 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:
TransposedPredicate implements BinaryPredicate<L, R> { public final boolean test(L left, R right) { return predicate.test(right, left); } TransposedPredicate(BinaryPredicate<? super R, ? super L> predicate); final boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static TransposedPredicate<R, L> transpose(BinaryPredicate<? super L, ? super R> p); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryPredicate<Boolean, Boolean> p = new TransposedPredicate<Boolean, Boolean>(BinaryFunctionBinaryPredicate .adapt(LeftIdentity.<Boolean, Boolean> function())); assertTrue(p.test(Boolean.FALSE,Boolean.TRUE)); assertFalse(p.test(Boolean.TRUE,Boolean.FALSE)); }
|
### Question:
TransposedPredicate implements BinaryPredicate<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TransposedPredicate<?, ?>)) { return false; } TransposedPredicate<?, ?> that = (TransposedPredicate<?, ?>) obj; return this.predicate.equals(that.predicate); } TransposedPredicate(BinaryPredicate<? super R, ? super L> predicate); final boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static TransposedPredicate<R, L> transpose(BinaryPredicate<? super L, ? super R> p); }### Answer:
@Test public void testEquals() throws Exception { BinaryPredicate<Object, Object> p = new TransposedPredicate<Object, Object>(Constant.TRUE); assertEquals(p,p); assertObjectsAreEqual(p,new TransposedPredicate<Object, Object>(Constant.TRUE)); assertObjectsAreEqual(p,TransposedPredicate.transpose(Constant.TRUE)); assertObjectsAreNotEqual(p,new TransposedPredicate<Object, Object>(Constant.FALSE)); assertObjectsAreNotEqual(p,Constant.TRUE); assertTrue(!p.equals((TransposedPredicate<?, ?>)null)); }
|
### Question:
TransposedPredicate implements BinaryPredicate<L, R> { public static <L, R> TransposedPredicate<R, L> transpose(BinaryPredicate<? super L, ? super R> p) { return null == p ? null : new TransposedPredicate<R, L>(p); } TransposedPredicate(BinaryPredicate<? super R, ? super L> predicate); final boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static TransposedPredicate<R, L> transpose(BinaryPredicate<? super L, ? super R> p); }### Answer:
@Test public void testTransposeNull() throws Exception { assertNull(TransposedPredicate.transpose(null)); }
@Test public void testTranspose() throws Exception { assertNotNull(TransposedPredicate.transpose(Constant.TRUE)); }
|
### Question:
BinaryCompositeBinaryFunction implements BinaryFunction<L, R, T> { public final T evaluate(L left, R right) { return helper.evaluate(left, right); } <G, H> BinaryCompositeBinaryFunction(BinaryFunction<? super G, ? super H, ? extends T> f,
BinaryFunction<? super L, ? super R, ? extends G> g, BinaryFunction<? super L, ? super R, ? extends H> h); final T evaluate(L left, R right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEvaluateRaw() throws Exception { BinaryFunction<Object, Object, Object> f = new BinaryCompositeBinaryFunction<Object, Object, Object>( RightIdentity.FUNCTION, Constant.of("K"), RightIdentity.FUNCTION); assertEquals("right",f.evaluate("left","right")); assertNull("right",f.evaluate("left",null)); assertEquals("right",f.evaluate(null,"right")); }
@Test public void testEvaluate() throws Exception { BinaryFunction<String, String, String> f = new BinaryCompositeBinaryFunction<String, String, String>( RightIdentity.<String, String>function(), Constant.of("K"), RightIdentity.<String, String>function()); assertEquals("right",f.evaluate("left","right")); assertNull("right",f.evaluate("left",null)); assertEquals("right",f.evaluate(null,"right")); }
@Test public void testEvaluateObject() throws Exception { BinaryFunction<Object, Object, Object> f = new BinaryCompositeBinaryFunction<Object, Object, Object>( RightIdentity.FUNCTION, Constant.of("K"), RightIdentity.FUNCTION); assertEquals("right",f.evaluate("left","right")); assertNull("right",f.evaluate("left",null)); assertEquals("right",f.evaluate(null,"right")); }
|
### Question:
Endpoint { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof Endpoint)) { return false; } Endpoint<?> that = (Endpoint<?>) obj; return this.boundType == that.boundType && this.value.equals(that.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 testEquals() throws Exception { Endpoint<Integer> endpoint = new Endpoint<Integer>(1, BoundType.OPEN); assertEquals("equals must be reflexive", endpoint, endpoint); assertEquals("hashCode must be reflexive", endpoint.hashCode(), endpoint.hashCode()); assertTrue(!endpoint.equals(null)); Object endpoint2 = new Endpoint<Integer>(1, BoundType.OPEN); if (endpoint.equals(endpoint2)) { assertEquals("equals implies hash equals", endpoint.hashCode(), endpoint2.hashCode()); assertEquals("equals must be symmetric", endpoint2, endpoint); } else { assertTrue("equals must be symmetric", !endpoint2.equals(endpoint)); } Object differentEndpoint = new Endpoint<Integer>(1, BoundType.CLOSED); assertTrue(!differentEndpoint.equals(endpoint)); assertTrue(differentEndpoint.hashCode() != endpoint.hashCode()); }
|
### Question:
IsNotEqual implements BinaryPredicate<L, R> { public boolean test(L left, R right) { return (null == left ? null != right : !left.equals(right)); } IsNotEqual(); boolean test(L left, R right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNotEqual<L, R> instance(); static Predicate<L> to(R object); static final IsNotEqual<Object, Object> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { IsNotEqual<Object, Object> p = new IsNotEqual<Object, Object>(); assertTrue("For symmetry, two nulls should be equal", !p.test(null, null)); assertTrue(!p.test("foo", "foo")); assertTrue(p.test(null, "foo")); assertTrue(p.test("foo", null)); assertTrue(!p.test(Integer.valueOf(3), Integer.valueOf(3))); assertTrue(p.test(null, Integer.valueOf(3))); assertTrue(p.test(Integer.valueOf(3), null)); assertTrue(p.test(Integer.valueOf(3), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(4), Integer.valueOf(3))); assertTrue(p.test("3", Integer.valueOf(3))); assertTrue(p.test(Integer.valueOf(3), "3")); }
|
### Question:
IsNotEqual implements BinaryPredicate<L, R> { @Override public boolean equals(Object that) { return that instanceof IsNotEqual<?, ?>; } IsNotEqual(); boolean test(L left, R right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNotEqual<L, R> instance(); static Predicate<L> to(R object); static final IsNotEqual<Object, Object> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { BinaryPredicate<Object, Object> p = new IsNotEqual<Object, Object>(); assertEquals(p, p); assertObjectsAreEqual(p, new IsNotEqual<Object, Object>()); assertObjectsAreEqual(p, IsNotEqual.instance()); assertObjectsAreNotEqual(p, Constant.truePredicate()); }
|
### Question:
IsNotEqual implements BinaryPredicate<L, R> { public static <L, R> IsNotEqual<L, R> instance() { return new IsNotEqual<L, R>(); } IsNotEqual(); boolean test(L left, R right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNotEqual<L, R> instance(); static Predicate<L> to(R object); static final IsNotEqual<Object, Object> INSTANCE; }### Answer:
@Test public void testConstant() throws Exception { assertEquals(IsNotEqual.instance(), IsNotEqual.instance()); }
|
### Question:
NoOp implements NullaryProcedure, Procedure<Object>, BinaryProcedure<Object, Object> { public void run() { } NoOp(); void run(); void run(Object obj); void run(Object left, Object right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static NoOp instance(); @SuppressWarnings("unchecked") static Procedure<A> unaryInstance(); @SuppressWarnings("unchecked") static BinaryProcedure<L, R> binaryInstance(); static final NoOp INSTANCE; }### Answer:
@Test public void testRun() throws Exception { NoOp p = new NoOp(); p.run(); p.run(null); p.run(null,null); p.run("foo"); p.run("foo",null); p.run(null,"bar"); p.run("foo","bar"); }
|
### Question:
NoOp implements NullaryProcedure, Procedure<Object>, BinaryProcedure<Object, Object> { @Override public boolean equals(Object that) { return (that instanceof NoOp); } NoOp(); void run(); void run(Object obj); void run(Object left, Object right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static NoOp instance(); @SuppressWarnings("unchecked") static Procedure<A> unaryInstance(); @SuppressWarnings("unchecked") static BinaryProcedure<L, R> binaryInstance(); static final NoOp INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { NoOp p = new NoOp(); assertEquals(p,p); assertObjectsAreEqual(p,new NoOp()); assertObjectsAreEqual(p,NoOp.instance()); assertObjectsAreNotEqual(p,new NullaryProcedure() { public void run() { } }); assertObjectsAreNotEqual(p,new Procedure<Object>() { public void run(Object a) { } }); assertObjectsAreNotEqual(p,new BinaryProcedure<Object, Object>() { public void run(Object a, Object b) { } }); }
|
### Question:
Limit implements NullaryPredicate, Predicate<Object>, BinaryPredicate<Object, Object> { public boolean test() { if (state.get() < max) { state.incrementAndGet(); return true; } return false; } Limit(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(); static Limit of(int count); }### Answer:
@Test public void testZero() throws Exception { NullaryPredicate p = new Limit(0); assertTrue(! p.test()); assertTrue(! p.test()); assertTrue(! p.test()); }
@Test public void testTestNullary() throws Exception { NullaryPredicate p = new Limit(3); assertTrue(p.test()); assertTrue(p.test()); assertTrue(p.test()); assertTrue(! p.test()); }
@Test public void testTestUnary() throws Exception { Predicate<Object> p = new Limit(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 Limit(3); assertTrue(p.test(null,null)); assertTrue(p.test(null,null)); assertTrue(p.test(null,null)); assertTrue(! p.test(null,null)); }
|
### Question:
Limit implements NullaryPredicate, Predicate<Object>, BinaryPredicate<Object, Object> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof Limit)) { return false; } Limit other = (Limit) obj; return other.max == max; } Limit(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(); static Limit of(int count); }### Answer:
@Test public void testEquals() { Limit limit = new Limit(1); assertObjectsAreEqual(new Limit(1), limit); assertObjectsAreNotEqual(new Limit(2), limit); assertTrue(!limit.equals(null)); }
|
### Question:
Limit implements NullaryPredicate, Predicate<Object>, BinaryPredicate<Object, Object> { public static Limit of(int count) { return new Limit(count); } Limit(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(); static Limit of(int count); }### Answer:
@Test public void testLimits() { Limit limit = new Limit(1); assertEquals(Limit.of(1), limit); assertObjectsAreEqual(Limit.of(1), limit); assertObjectsAreNotEqual(Limit.of(3), limit); }
|
### Question:
IsSame implements BinaryPredicate<L, R> { public boolean test(L left, R right) { return left == right; } IsSame(); boolean test(L left, R right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsSame<L, R> instance(); static Predicate<L> as(R object); static final IsSame<Object, Object> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { IsSame<Object, Object> p = new IsSame<Object, Object>(); assertTrue("For symmetry, two nulls should be same", p.test(null, null)); assertTrue(p.test("foo", "foo")); assertFalse(p.test(null, "foo")); assertFalse(p.test("foo", null)); assertFalse(p.test(new Integer(3), Integer.valueOf(3))); assertFalse(p.test(null, Integer.valueOf(3))); assertFalse(p.test(Integer.valueOf(3), null)); assertFalse(p.test(Integer.valueOf(3), Integer.valueOf(4))); assertFalse(p.test(Integer.valueOf(4), Integer.valueOf(3))); assertFalse(p.test("3", Integer.valueOf(3))); assertFalse(p.test(Integer.valueOf(3), "3")); }
|
### Question:
IsSame implements BinaryPredicate<L, R> { @Override public boolean equals(Object that) { return that instanceof IsSame<?, ?>; } IsSame(); boolean test(L left, R right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsSame<L, R> instance(); static Predicate<L> as(R object); static final IsSame<Object, Object> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { BinaryPredicate<Object, Object> f = new IsSame<Object, Object>(); assertEquals(f, f); assertObjectsAreEqual(f, new IsSame<Object, Object>()); assertObjectsAreEqual(f, IsSame.instance()); assertObjectsAreNotEqual(f, Constant.truePredicate()); }
|
### Question:
IsSame implements BinaryPredicate<L, R> { public static <L, R> IsSame<L, R> instance() { return new IsSame<L, R>(); } IsSame(); boolean test(L left, R right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsSame<L, R> instance(); static Predicate<L> as(R object); static final IsSame<Object, Object> INSTANCE; }### Answer:
@Test public void testConstant() throws Exception { assertEquals(IsSame.instance(), IsSame.instance()); assertNotSame(IsSame.instance(), IsSame.instance()); assertSame(IsSame.INSTANCE, IsSame.INSTANCE); }
|
### Question:
IsNotSame implements BinaryPredicate<L, R> { public boolean test(L left, R right) { return left != right; } IsNotSame(); boolean test(L left, R right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNotSame<L, R> instance(); static Predicate<L> as(R object); static final IsNotSame<Object, Object> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { IsNotSame<Object, Object> p = new IsNotSame<Object, Object>(); assertFalse("For symmetry, two nulls should be same", p.test(null, null)); assertFalse(p.test("foo", "foo")); assertTrue(p.test(null, "foo")); assertTrue(p.test("foo", null)); assertTrue(p.test(new Integer(3), Integer.valueOf(3))); assertTrue(p.test(null, Integer.valueOf(3))); assertTrue(p.test(Integer.valueOf(3), null)); assertTrue(p.test(Integer.valueOf(3), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(4), Integer.valueOf(3))); assertTrue(p.test("3", Integer.valueOf(3))); assertTrue(p.test(Integer.valueOf(3), "3")); }
|
### Question:
IsNotSame implements BinaryPredicate<L, R> { @Override public boolean equals(Object that) { return that instanceof IsNotSame<?, ?>; } IsNotSame(); boolean test(L left, R right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNotSame<L, R> instance(); static Predicate<L> as(R object); static final IsNotSame<Object, Object> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { BinaryPredicate<Object, Object> f = new IsNotSame<Object, Object>(); assertEquals(f, f); assertObjectsAreEqual(f, new IsNotSame<Object, Object>()); assertObjectsAreEqual(f, IsNotSame.instance()); assertObjectsAreNotEqual(f, Constant.truePredicate()); }
|
### Question:
IsNotSame implements BinaryPredicate<L, R> { public static <L, R> IsNotSame<L, R> instance() { return new IsNotSame<L, R>(); } IsNotSame(); boolean test(L left, R right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsNotSame<L, R> instance(); static Predicate<L> as(R object); static final IsNotSame<Object, Object> INSTANCE; }### Answer:
@Test public void testConstant() throws Exception { assertEquals(IsNotSame.instance(), IsNotSame.instance()); assertNotSame(IsNotSame.instance(), IsNotSame.instance()); assertSame(IsNotSame.INSTANCE, IsNotSame.INSTANCE); }
|
### Question:
IsNotEquivalent implements BinaryPredicate<T, T> { public boolean test(T left, T right) { return comparator.compare(left, right) != 0; } @SuppressWarnings("unchecked") IsNotEquivalent(); IsNotEquivalent(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static IsNotEquivalent<T> instance(); static Predicate<T> instance(T right); static final IsNotEquivalent<Comparable<?>> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { IsNotEquivalent<Integer> p = new IsNotEquivalent<Integer>(); assertTrue(p.test(Integer.valueOf(2), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(3), Integer.valueOf(4))); assertTrue(!p.test(Integer.valueOf(4), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(5), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(6), Integer.valueOf(4))); }
|
### Question:
IsNotEquivalent implements BinaryPredicate<T, T> { @SuppressWarnings("unchecked") public static <T extends Comparable<?>> IsNotEquivalent<T> instance() { return new IsNotEquivalent<T>((Comparator<? super T>) ComparableComparator.INSTANCE); } @SuppressWarnings("unchecked") IsNotEquivalent(); IsNotEquivalent(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static IsNotEquivalent<T> instance(); static Predicate<T> instance(T right); static final IsNotEquivalent<Comparable<?>> INSTANCE; }### Answer:
@Test public void testInstance() { assertTrue(!IsNotEquivalent.instance(Integer.valueOf(7)).test(Integer.valueOf(7))); assertTrue(IsNotEquivalent.instance(Integer.valueOf(7)).test(Integer.valueOf(8))); }
|
### Question:
IsNotEquivalent implements BinaryPredicate<T, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IsNotEquivalent<?>)) { return false; } IsNotEquivalent<?> that = (IsNotEquivalent<?>) obj; return this.comparator.equals(that.comparator); } @SuppressWarnings("unchecked") IsNotEquivalent(); IsNotEquivalent(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static IsNotEquivalent<T> instance(); static Predicate<T> instance(T right); static final IsNotEquivalent<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { IsNotEquivalent<Comparable<?>> p = new IsNotEquivalent<Comparable<?>>(); assertEquals(p, p); assertObjectsAreEqual(p, new IsNotEquivalent<Integer>(ComparableComparator.<Integer> instance())); assertObjectsAreEqual(p, IsNotEquivalent.instance()); assertObjectsAreNotEqual(p, Constant.FALSE); assertFalse(p.equals(null)); }
|
### Question:
Min implements BinaryFunction<T, T, T> { public T evaluate(T left, T right) { return (comparator.compare(left, right) <= 0) ? left : right; } @SuppressWarnings("unchecked") Min(); Min(Comparator<T> comparator); T evaluate(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Min<T> instance(); static Function<T, T> instance(T right); static final Min<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEvaluate() { Min<Integer> f = Min.instance(); assertEquals(ONE, f.evaluate(ONE, ONE)); assertEquals(ZERO, f.evaluate(ZERO, ONE)); assertEquals(ZERO, f.evaluate(ONE, ZERO)); assertEquals(ONE, f.evaluate(ONE, MAX)); assertEquals(MIN, f.evaluate(MIN, MAX)); assertEquals(MIN, f.evaluate(MIN, MINUS_TWO)); }
|
### Question:
Min implements BinaryFunction<T, T, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof Min<?>)) { return false; } Min<?> that = (Min<?>) obj; return this.comparator.equals(that.comparator); } @SuppressWarnings("unchecked") Min(); Min(Comparator<T> comparator); T evaluate(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Min<T> instance(); static Function<T, T> instance(T right); static final Min<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEquals() { Min<Comparable<?>> f = Min.instance(); assertObjectsAreEqual(f, f); assertObjectsAreEqual(f, Min.instance()); assertObjectsAreEqual(f, new Min<Integer>(ComparableComparator.<Integer> instance())); assertObjectsAreNotEqual(f, new Min<Comparable<?>>(Collections.<Comparable<?>> reverseOrder())); assertFalse(f.equals(null)); }
|
### Question:
IsEquivalent implements BinaryPredicate<T, T> { @SuppressWarnings("unchecked") public static <T extends Comparable<?>> IsEquivalent<T> instance() { return new IsEquivalent<T>((Comparator<? super T>) ComparableComparator.INSTANCE); } @SuppressWarnings("unchecked") IsEquivalent(); IsEquivalent(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static IsEquivalent<T> instance(); static Predicate<T> instance(T right); static final IsEquivalent<Comparable<?>> INSTANCE; }### Answer:
@Test public void testInstance() { assertTrue(IsEquivalent.instance("Xyzzy").test("Xyzzy")); assertTrue(!IsEquivalent.instance("Xyzzy").test("z")); }
|
### Question:
IsEquivalent implements BinaryPredicate<T, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IsEquivalent<?>)) { return false; } IsEquivalent<?> that = (IsEquivalent<?>) obj; return this.comparator.equals(that.comparator); } @SuppressWarnings("unchecked") IsEquivalent(); IsEquivalent(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static IsEquivalent<T> instance(); static Predicate<T> instance(T right); static final IsEquivalent<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { IsEquivalent<Comparable<Integer>> p = IsEquivalent.instance(); assertEquals(p, p); assertObjectsAreEqual(p, new IsEquivalent<Comparable<?>>()); assertObjectsAreEqual(p, new IsEquivalent<Integer>(ComparableComparator.<Integer> instance())); assertObjectsAreNotEqual(p, Constant.FALSE); assertFalse(p.equals(null)); }
|
### Question:
IsLessThan implements BinaryPredicate<T, T> { public boolean test(T left, T right) { return comparator.compare(left, right) < 0; } @SuppressWarnings("unchecked") IsLessThan(); IsLessThan(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsLessThan<T> instance(); static Predicate<T> instance(T right); static final IsLessThan<Comparable<?>> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { IsLessThan<Integer> p = new IsLessThan<Integer>(); assertTrue(p.test(Integer.valueOf(2), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(3), Integer.valueOf(4))); assertFalse(p.test(Integer.valueOf(4), Integer.valueOf(4))); assertFalse(p.test(Integer.valueOf(5), Integer.valueOf(4))); assertFalse(p.test(Integer.valueOf(6), Integer.valueOf(4))); }
|
### Question:
IsLessThan implements BinaryPredicate<T, T> { public static <T extends Comparable<?>> IsLessThan<T> instance() { return new IsLessThan<T>(); } @SuppressWarnings("unchecked") IsLessThan(); IsLessThan(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsLessThan<T> instance(); static Predicate<T> instance(T right); static final IsLessThan<Comparable<?>> INSTANCE; }### Answer:
@Test public void testInstance() { assertFalse(IsLessThan.instance(Integer.valueOf(7)).test(Integer.valueOf(8))); assertTrue(IsLessThan.instance(Integer.valueOf(7)).test(Integer.valueOf(6))); }
|
### Question:
IsLessThan implements BinaryPredicate<T, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IsLessThan<?>)) { return false; } IsLessThan<?> that = (IsLessThan<?>) obj; return this.comparator.equals(that.comparator); } @SuppressWarnings("unchecked") IsLessThan(); IsLessThan(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsLessThan<T> instance(); static Predicate<T> instance(T right); static final IsLessThan<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { IsLessThan<Comparable<?>> p = new IsLessThan<Comparable<?>>(); assertEquals(p, p); assertObjectsAreEqual(p, new IsLessThan<Comparable<?>>()); assertObjectsAreEqual(p, new IsLessThan<Integer>(ComparableComparator.<Integer> instance())); assertObjectsAreEqual(p, IsLessThan.instance()); assertObjectsAreNotEqual(p, Constant.FALSE); assertFalse(p.equals(null)); }
|
### Question:
ComparatorFunction implements BinaryFunction<T, T, Integer> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ComparatorFunction<?>)) { return false; } ComparatorFunction<?> that = (ComparatorFunction<?>) obj; return this.comparator.equals(that.comparator); } ComparatorFunction(Comparator<? super T> comparator); Integer evaluate(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static ComparatorFunction<T> instance(); static final ComparatorFunction<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEquals() { ComparatorFunction<Comparable<?>> f = ComparatorFunction.instance(); assertObjectsAreEqual(f, f); assertObjectsAreEqual(f, new ComparatorFunction<Integer>(ComparableComparator.<Integer> instance())); assertObjectsAreNotEqual(f, new ComparatorFunction<Boolean>(Collections.reverseOrder())); assertTrue(!f.equals(null)); }
|
### Question:
Max implements BinaryFunction<T, T, T> { public T evaluate(T left, T right) { return (comparator.compare(left, right) >= 0) ? left : right; } @SuppressWarnings("unchecked") Max(); Max(Comparator<T> comparator); T evaluate(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Max<T> instance(); static Function<T, T> instance(T right); static final Max<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEvaluate() { Max<Integer> f = Max.instance(); assertEquals(ONE,f.evaluate(ONE,ONE)); assertEquals(ONE,f.evaluate(ZERO,ONE)); assertEquals(ONE,f.evaluate(ONE,ZERO)); assertEquals(MAX,f.evaluate(ONE,MAX)); assertEquals(MAX,f.evaluate(MIN,MAX)); assertEquals(MINUS_TWO,f.evaluate(MIN,MINUS_TWO)); }
|
### Question:
Max implements BinaryFunction<T, T, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof Max<?>)) { return false; } Max<?> that = (Max<?>) obj; return this.comparator.equals(that.comparator); } @SuppressWarnings("unchecked") Max(); Max(Comparator<T> comparator); T evaluate(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Max<T> instance(); static Function<T, T> instance(T right); static final Max<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEquals() { Max<Comparable<?>> f = Max.instance(); assertObjectsAreEqual(f,f); assertObjectsAreEqual(f,Max.instance()); assertObjectsAreEqual(f,new Max<Integer>(ComparableComparator.<Integer>instance())); assertObjectsAreNotEqual(f,new Max<Comparable<?>>(Collections.<Comparable<?>>reverseOrder())); assertFalse(f.equals(null)); }
|
### Question:
IsGreaterThanOrEqual implements BinaryPredicate<T, T> { public boolean test(T left, T right) { return comparator.compare(left, right) >= 0; } @SuppressWarnings("unchecked") IsGreaterThanOrEqual(); IsGreaterThanOrEqual(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsGreaterThanOrEqual<T> instance(); static Predicate<T> instance(T right); static final IsGreaterThanOrEqual<Comparable<?>> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { IsGreaterThanOrEqual<Integer> p = new IsGreaterThanOrEqual<Integer>(); assertFalse(p.test(Integer.valueOf(2), Integer.valueOf(4))); assertFalse(p.test(Integer.valueOf(3), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(4), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(5), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(6), Integer.valueOf(4))); }
|
### Question:
IsGreaterThanOrEqual implements BinaryPredicate<T, T> { public static <T extends Comparable<?>> IsGreaterThanOrEqual<T> instance() { return new IsGreaterThanOrEqual<T>(); } @SuppressWarnings("unchecked") IsGreaterThanOrEqual(); IsGreaterThanOrEqual(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsGreaterThanOrEqual<T> instance(); static Predicate<T> instance(T right); static final IsGreaterThanOrEqual<Comparable<?>> INSTANCE; }### Answer:
@Test public void testInstance() { assertTrue(IsGreaterThanOrEqual.instance(Integer.valueOf(7)).test(Integer.valueOf(8))); assertTrue(!IsGreaterThanOrEqual.instance(Integer.valueOf(7)).test(Integer.valueOf(6))); }
|
### Question:
IsGreaterThanOrEqual implements BinaryPredicate<T, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IsGreaterThanOrEqual<?>)) { return false; } IsGreaterThanOrEqual<?> that = (IsGreaterThanOrEqual<?>) obj; return this.comparator.equals(that.comparator); } @SuppressWarnings("unchecked") IsGreaterThanOrEqual(); IsGreaterThanOrEqual(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsGreaterThanOrEqual<T> instance(); static Predicate<T> instance(T right); static final IsGreaterThanOrEqual<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { IsGreaterThanOrEqual<Comparable<?>> p = new IsGreaterThanOrEqual<Comparable<?>>(); assertEquals(p, p); assertObjectsAreEqual(p, new IsGreaterThanOrEqual<Comparable<?>>()); assertObjectsAreEqual(p, new IsGreaterThanOrEqual<Integer>(ComparableComparator.<Integer> instance())); assertObjectsAreEqual(p, IsGreaterThanOrEqual.instance()); assertObjectsAreNotEqual(p, Constant.FALSE); assertFalse(p.equals(null)); }
|
### Question:
IsLessThanOrEqual implements BinaryPredicate<T, T> { public boolean test(T left, T right) { return comparator.compare(left, right) <= 0; } @SuppressWarnings("unchecked") IsLessThanOrEqual(); IsLessThanOrEqual(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsLessThanOrEqual<T> instance(); static Predicate<T> instance(T right); static final IsLessThanOrEqual<Comparable<?>> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { IsLessThanOrEqual<Integer> p = new IsLessThanOrEqual<Integer>(); assertTrue(p.test(Integer.valueOf(2),Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(3),Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(4),Integer.valueOf(4))); assertFalse(p.test(Integer.valueOf(5),Integer.valueOf(4))); assertFalse(p.test(Integer.valueOf(6),Integer.valueOf(4))); }
|
### Question:
IsLessThanOrEqual implements BinaryPredicate<T, T> { public static <T extends Comparable<?>> IsLessThanOrEqual<T> instance() { return new IsLessThanOrEqual<T>(); } @SuppressWarnings("unchecked") IsLessThanOrEqual(); IsLessThanOrEqual(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsLessThanOrEqual<T> instance(); static Predicate<T> instance(T right); static final IsLessThanOrEqual<Comparable<?>> INSTANCE; }### Answer:
@Test public void testInstance() { assertFalse(IsLessThanOrEqual.instance(Integer.valueOf(7)).test(Integer.valueOf(8))); assertTrue(IsLessThanOrEqual.instance(Integer.valueOf(7)).test(Integer.valueOf(6))); }
|
### Question:
IsLessThanOrEqual implements BinaryPredicate<T, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IsLessThanOrEqual<?>)) { return false; } IsLessThanOrEqual<?> that = (IsLessThanOrEqual<?>) obj; return this.comparator.equals(that.comparator); } @SuppressWarnings("unchecked") IsLessThanOrEqual(); IsLessThanOrEqual(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsLessThanOrEqual<T> instance(); static Predicate<T> instance(T right); static final IsLessThanOrEqual<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { IsLessThanOrEqual<Comparable<?>> p = new IsLessThanOrEqual<Comparable<?>>(); assertEquals(p,p); assertObjectsAreEqual(p,new IsLessThanOrEqual<Comparable<?>>()); assertObjectsAreEqual(p,new IsLessThanOrEqual<Integer>(ComparableComparator.<Integer>instance())); assertObjectsAreEqual(p,IsLessThanOrEqual.instance()); assertObjectsAreNotEqual(p,Constant.FALSE); assertFalse(p.equals(null)); }
|
### Question:
IsWithinRange implements Predicate<A> { public final boolean test(A o) { return o.compareTo(min) >= 0 && o.compareTo(max) <= 0; } IsWithinRange(A min, A max); final boolean test(A o); @Override final boolean equals(Object o); @Override int hashCode(); @Override String toString(); static IsWithinRange<A> instance(A min, A max); }### Answer:
@Test public void testTest() throws Exception { IsWithinRange<Integer> p = new IsWithinRange<Integer>(Integer.valueOf(5), Integer.valueOf(10)); assertTrue(p.test(Integer.valueOf(5))); assertTrue(p.test(Integer.valueOf(6))); assertTrue(p.test(Integer.valueOf(7))); assertTrue(p.test(Integer.valueOf(8))); assertTrue(p.test(Integer.valueOf(9))); assertTrue(p.test(Integer.valueOf(10))); assertTrue(!p.test(Integer.valueOf(4))); assertTrue(!p.test(Integer.valueOf(11))); }
|
### Question:
IsWithinRange implements Predicate<A> { @Override public final boolean equals(Object o) { if (this == o) { return true; } if (!(o instanceof IsWithinRange<?>)) { return false; } final IsWithinRange<?> isWithinRange = (IsWithinRange<?>) o; return max.equals(isWithinRange.max) && min.equals(isWithinRange.min); } IsWithinRange(A min, A max); final boolean test(A o); @Override final boolean equals(Object o); @Override int hashCode(); @Override String toString(); static IsWithinRange<A> instance(A min, A max); }### Answer:
@Test public void testEquals() throws Exception { IsWithinRange<Integer> p1 = new IsWithinRange<Integer>(Integer.valueOf(5), Integer.valueOf(10)); IsWithinRange<Integer> p2 = new IsWithinRange<Integer>(Integer.valueOf(5), Integer.valueOf(10)); assertEquals(p1, p2); p2 = new IsWithinRange<Integer>(Integer.valueOf(5), Integer.valueOf(11)); assertTrue(!p1.equals(p2)); p2 = new IsWithinRange<Integer>(Integer.valueOf(6), Integer.valueOf(10)); assertTrue(!p1.equals(p2)); }
|
### Question:
IsGreaterThan implements BinaryPredicate<T, T> { public boolean test(T left, T right) { return comparator.compare(left, right) > 0; } @SuppressWarnings("unchecked") IsGreaterThan(); IsGreaterThan(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsGreaterThan<T> instance(); static Predicate<T> instance(T right); static final IsGreaterThan<Comparable<?>> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { IsGreaterThan<Integer> p = new IsGreaterThan<Integer>(); assertFalse(p.test(Integer.valueOf(2), Integer.valueOf(4))); assertFalse(p.test(Integer.valueOf(3), Integer.valueOf(4))); assertFalse(p.test(Integer.valueOf(4), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(5), Integer.valueOf(4))); assertTrue(p.test(Integer.valueOf(6), Integer.valueOf(4))); }
|
### Question:
IsGreaterThan implements BinaryPredicate<T, T> { public static <T extends Comparable<?>> IsGreaterThan<T> instance() { return new IsGreaterThan<T>(); } @SuppressWarnings("unchecked") IsGreaterThan(); IsGreaterThan(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsGreaterThan<T> instance(); static Predicate<T> instance(T right); static final IsGreaterThan<Comparable<?>> INSTANCE; }### Answer:
@Test public void testInstance() { assertTrue(IsGreaterThan.instance(Integer.valueOf(7)).test(Integer.valueOf(8))); assertTrue(!IsGreaterThan.instance(Integer.valueOf(7)).test(Integer.valueOf(6))); }
|
### Question:
IsGreaterThan implements BinaryPredicate<T, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IsGreaterThan<?>)) { return false; } IsGreaterThan<?> that = (IsGreaterThan<?>) obj; return this.comparator.equals(that.comparator); } @SuppressWarnings("unchecked") IsGreaterThan(); IsGreaterThan(Comparator<? super T> comparator); boolean test(T left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsGreaterThan<T> instance(); static Predicate<T> instance(T right); static final IsGreaterThan<Comparable<?>> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { IsGreaterThan<Comparable<?>> p = new IsGreaterThan<Comparable<?>>(); assertEquals(p, p); assertObjectsAreEqual(p, new IsGreaterThan<Comparable<?>>()); assertObjectsAreEqual(p, new IsGreaterThan<Integer>(ComparableComparator.<Integer> instance())); assertObjectsAreEqual(p, IsGreaterThan.instance()); assertObjectsAreNotEqual(p, Constant.FALSE); assertFalse(p.equals(null)); }
|
### Question:
FilteredIterator implements Iterator<T> { public boolean hasNext() { return nextSet || setNext(); } FilteredIterator(Iterator<? extends T> iterator, Predicate<? super T> predicate); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static Iterator<T> filter(Iterator<? extends T> iter, Predicate<? super T> pred); }### Answer:
@Test public void testEmptyList() { Iterator<Integer> testing = new FilteredIterator<Integer>(new ArrayList<Integer>().iterator(), isEven); assertTrue(!testing.hasNext()); }
@Test public void testNonePass() { Iterator<Integer> testing = new FilteredIterator<Integer>(new ArrayList<Integer>().iterator(), Constant.falsePredicate()); assertTrue(!testing.hasNext()); }
|
### Question:
FilteredIterator implements Iterator<T> { public T next() { if (hasNext()) { return returnNext(); } throw new NoSuchElementException(); } FilteredIterator(Iterator<? extends T> iterator, Predicate<? super T> predicate); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static Iterator<T> filter(Iterator<? extends T> iter, Predicate<? super T> pred); }### Answer:
@Test(expected = NoSuchElementException.class) public void testNextOnEmptyList() { Iterator<Integer> testing = new FilteredIterator<Integer>(new ArrayList<Integer>().iterator(), isEven); testing.next(); }
|
### Question:
FilteredIterator implements Iterator<T> { public void remove() { if (canRemove) { canRemove = false; iterator.remove(); } else { throw new IllegalStateException(); } } FilteredIterator(Iterator<? extends T> iterator, Predicate<? super T> predicate); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static Iterator<T> filter(Iterator<? extends T> iter, Predicate<? super T> pred); }### Answer:
@Test(expected = IllegalStateException.class) public void testRemoveBeforeNext() { Iterator<Integer> testing = new FilteredIterator<Integer>(list.iterator(), isEven); testing.remove(); }
|
### Question:
FilteredIterator implements Iterator<T> { @SuppressWarnings("unchecked") public static <T> Iterator<T> filter(Iterator<? extends T> iter, Predicate<? super T> pred) { return null == pred ? (Iterator<T>) iter : (null == iter ? null : new FilteredIterator<T>(iter, pred)); } FilteredIterator(Iterator<? extends T> iterator, Predicate<? super T> predicate); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static Iterator<T> filter(Iterator<? extends T> iter, Predicate<? super T> pred); }### Answer:
@Test public void testFilterWithNullIteratorReturnsNull() { assertNull(FilteredIterator.filter(null, Constant.truePredicate())); }
@Test public void testFilterWithNullPredicateReturnsIdentity() { Iterator<Integer> iter = list.iterator(); assertSame(iter, FilteredIterator.filter(iter, null)); }
|
### Question:
FilteredIterator implements Iterator<T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof FilteredIterator<?>)) { return false; } FilteredIterator<?> that = (FilteredIterator<?>) obj; return predicate.equals(that.predicate) && iterator.equals(that.iterator); } FilteredIterator(Iterator<? extends T> iterator, Predicate<? super T> predicate); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); @SuppressWarnings("unchecked") static Iterator<T> filter(Iterator<? extends T> iter, Predicate<? super T> pred); }### Answer:
@Test public void testEquals() { Iterator<Integer> iter = list.iterator(); FilteredIterator<Integer> t = new FilteredIterator<Integer>(iter, isEven); Predicate<Integer> isOdd = new Predicate<Integer>() { public boolean test(Integer obj) { return obj.intValue() % 2 != 0; } }; Predicate<Float> isOddFloat = new Predicate<Float>() { public boolean test(Float obj) { return obj.intValue() % 2 != 0; } }; assertEquals(t, new FilteredIterator<Integer>(iter, isEven)); assertTrue(!t.equals(new FilteredIterator<Integer>(list.iterator(), isOdd))); assertTrue(!t.equals(new FilteredIterator<Float>(Arrays.asList(0.0f, 0.1f).iterator(), isOddFloat))); assertTrue(!t.equals(null)); }
|
### Question:
IsEmpty implements Predicate<A> { @Override public boolean equals(Object that) { return that instanceof IsEmpty<?>; } IsEmpty(); boolean test(A obj); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsEmpty<A> instance(); static final IsEmpty<Object> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { Predicate<String> p = new IsEmpty<String>(); assertEquals(p, p); assertObjectsAreEqual(p, new IsEmpty<Long>()); assertObjectsAreEqual(p, IsEmpty.instance()); assertObjectsAreNotEqual(p, new Constant<Boolean>(Boolean.TRUE)); }
|
### Question:
FilteredIterable implements Iterable<T> { public static <T> FilteredIterable<T> of(Iterable<T> iterable) { if (iterable == null) { return null; } if (iterable instanceof FilteredIterable<?>) { return (FilteredIterable<T>) iterable; } return new FilteredIterable<T>(iterable); } protected FilteredIterable(Iterable<? extends T> iterable); Iterator<T> iterator(); @Override String toString(); FilteredIterable<T> retain(Predicate<? super T> filter); FilteredIterable<U> retain(final Class<U> type); FilteredIterable<T> retain(final Class<?>... ofType); static FilteredIterable<T> of(Iterable<T> iterable); @SuppressWarnings("unchecked") static FilteredIterable<T> empty(); }### Answer:
@Test public void testFilterWithNullIteratorReturnsNull() { assertNull(FilteredIterable.of(null)); }
@Test public void testFilterWithFilteredIterableReturnsItself() { FilteredIterable<Integer> filter = FilteredIterable.of(list); assertEquals(filter,FilteredIterable.of(filter)); }
|
### Question:
Size implements Function<A, Integer> { public Integer evaluate(Object obj) { Validate.notNull(obj, "Argument must not be null"); if (obj instanceof Collection<?>) { return evaluate((Collection<?>) obj); } if (obj instanceof String) { return evaluate((String) obj); } if (obj.getClass().isArray()) { return evaluateArray(obj); } throw new IllegalArgumentException("Expected Collection, String or Array, found " + obj); } Size(); Integer evaluate(Object obj); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static Size<Object> instance(); }### Answer:
@Test public void testEvaluate() throws Exception { assertEquals(Integer.valueOf(0), Size.instance().evaluate(Collections.EMPTY_LIST)); assertEquals(Integer.valueOf(0), Size.instance().evaluate(Collections.EMPTY_SET)); { List<Integer> list = new ArrayList<Integer>(); assertEquals(Integer.valueOf(0), Size.instance().evaluate(list)); for (int i = 0; i < 2; i++) { assertEquals(Integer.valueOf(i), Size.instance().evaluate(list)); list.add(Integer.valueOf(i)); assertEquals(Integer.valueOf(i + 1), Size.instance().evaluate(list)); } } { Set<Integer> set = new HashSet<Integer>(); assertEquals(Integer.valueOf(0), Size.instance().evaluate(set)); for (int i = 0; i < 2; i++) { assertEquals(Integer.valueOf(i), Size.instance().evaluate(set)); set.add(Integer.valueOf(i)); assertEquals(Integer.valueOf(i + 1), Size.instance().evaluate(set)); } } }
|
### Question:
Size implements Function<A, Integer> { private Integer evaluateArray(Object array) { return Integer.valueOf(Array.getLength(array)); } Size(); Integer evaluate(Object obj); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static Size<Object> instance(); }### Answer:
@Test public void testEvaluateArray() throws Exception { assertEquals(Integer.valueOf(10), Size.instance().evaluate(new int[10])); assertEquals(Integer.valueOf(7), Size.instance().evaluate(new String[7])); }
|
### Question:
Size implements Function<A, Integer> { @Override public boolean equals(Object that) { return that instanceof Size<?>; } Size(); Integer evaluate(Object obj); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static Size<Object> instance(); }### Answer:
@Test public void testEquals() throws Exception { Function<Object, Integer> f = new Size<Object>(); assertEquals(f, f); assertObjectsAreEqual(f, new Size<Object>()); assertObjectsAreEqual(f, Size.instance()); assertSame(Size.instance(), Size.instance()); assertObjectsAreNotEqual(f, new Constant<Object>(null)); assertTrue(!f.equals((Size<?>) null)); }
|
### Question:
IsElementOf implements BinaryPredicate<L, R> { public static IsElementOf<Object, Object> instance() { return INSTANCE; } IsElementOf(); boolean test(L obj, R col); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsElementOf<Object, Object> instance(); static Predicate<A> instance(Object obj); }### Answer:
@Test public void testWrapNull() { try { IsElementOf.instance(null); fail("expected NullPointerException"); } catch (NullPointerException e) { } }
@Test public void testWrapNonCollection() { try { IsElementOf.instance(Integer.valueOf(3)); fail("expected IllegalArgumentException"); } catch (IllegalArgumentException e) { } }
|
### Question:
IsElementOf implements BinaryPredicate<L, R> { @Override public boolean equals(Object obj) { return (obj instanceof IsElementOf<?, ?>); } IsElementOf(); boolean test(L obj, R col); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IsElementOf<Object, Object> instance(); static Predicate<A> instance(Object obj); }### Answer:
@Test public void testEquals() throws Exception { IsElementOf<Integer, Collection<Integer>> p1 = new IsElementOf<Integer, Collection<Integer>>(); assertObjectsAreEqual(p1, p1); assertObjectsAreEqual(p1, new IsElementOf<Integer, Collection<Integer>>()); assertObjectsAreEqual(p1, IsElementOf.instance()); assertSame(IsElementOf.instance(), IsElementOf.instance()); assertObjectsAreNotEqual(p1, Constant.falsePredicate()); }
|
### Question:
TransformedIterator implements Iterator<T> { public boolean hasNext() { return iterator.hasNext(); } TransformedIterator(Iterator<? extends E> iterator, Function<? super E, ? extends T> function); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Iterator<T> transform(Iterator<? extends E> iter, Function<? super E, ? extends T> func); static Iterator<?> maybeTransform(Iterator<? extends E> iter, Function<? super E, ?> func); }### Answer:
@Test public void testEmptyList() { Iterator<?> testing = new TransformedIterator<Integer, Integer>(Collections.<Integer> emptyList().iterator(), negate); assertTrue(!testing.hasNext()); }
|
### Question:
TransformedIterator implements Iterator<T> { public T next() { return function.evaluate(iterator.next()); } TransformedIterator(Iterator<? extends E> iterator, Function<? super E, ? extends T> function); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Iterator<T> transform(Iterator<? extends E> iter, Function<? super E, ? extends T> func); static Iterator<?> maybeTransform(Iterator<? extends E> iter, Function<? super E, ?> func); }### Answer:
@Test(expected = NoSuchElementException.class) public void testNextOnEmptyList() { Iterator<Integer> testing = new TransformedIterator<Integer, Integer>(Collections.<Integer> emptyList().iterator(), negate); testing.next(); }
|
### Question:
TransformedIterator implements Iterator<T> { public void remove() { iterator.remove(); } TransformedIterator(Iterator<? extends E> iterator, Function<? super E, ? extends T> function); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Iterator<T> transform(Iterator<? extends E> iter, Function<? super E, ? extends T> func); static Iterator<?> maybeTransform(Iterator<? extends E> iter, Function<? super E, ?> func); }### Answer:
@Test(expected = IllegalStateException.class) public void testRemoveBeforeNext() { Iterator<Integer> testing = new TransformedIterator<Integer, Integer>(list.iterator(), negate); testing.remove(); }
|
### Question:
TransformedIterator implements Iterator<T> { public static <E, T> Iterator<T> transform(Iterator<? extends E> iter, Function<? super E, ? extends T> func) { if (null == iter) { return null; } return new TransformedIterator<E, T>(iter, func); } TransformedIterator(Iterator<? extends E> iterator, Function<? super E, ? extends T> function); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Iterator<T> transform(Iterator<? extends E> iter, Function<? super E, ? extends T> func); static Iterator<?> maybeTransform(Iterator<? extends E> iter, Function<? super E, ?> func); }### Answer:
@Test public void testTransformWithNullIteratorReturnsNull() { assertNull(TransformedIterator.transform(null, negate)); }
@Test public void testTransform() { Iterator<Integer> iter = list.iterator(); assertNotSame(iter, TransformedIterator.maybeTransform(iter, negate)); }
|
### Question:
TransformedIterator implements Iterator<T> { public static <E> Iterator<?> maybeTransform(Iterator<? extends E> iter, Function<? super E, ?> func) { return null == func ? (null == iter ? null : iter) : new TransformedIterator<E, Object>(iter, func); } TransformedIterator(Iterator<? extends E> iterator, Function<? super E, ? extends T> function); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Iterator<T> transform(Iterator<? extends E> iter, Function<? super E, ? extends T> func); static Iterator<?> maybeTransform(Iterator<? extends E> iter, Function<? super E, ?> func); }### Answer:
@Test public void testTransformWithNullFunctionReturnsIdentity() { Iterator<Integer> iter = list.iterator(); assertSame(iter, TransformedIterator.maybeTransform(iter, null)); }
@Test public void testTransformWithNullIteratorAndNullFunctionReturnsNull() { assertSame(null, TransformedIterator.maybeTransform(null, null)); }
|
### Question:
TransformedIterator implements Iterator<T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof TransformedIterator<?, ?>)) { return false; } TransformedIterator<?, ?> that = (TransformedIterator<?, ?>) obj; return function.equals(that.function) && iterator.equals(that.iterator); } TransformedIterator(Iterator<? extends E> iterator, Function<? super E, ? extends T> function); boolean hasNext(); T next(); void remove(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Iterator<T> transform(Iterator<? extends E> iter, Function<? super E, ? extends T> func); static Iterator<?> maybeTransform(Iterator<? extends E> iter, Function<? super E, ?> func); }### Answer:
@Test public void testEquals() { Iterator<Integer> iter = list.iterator(); TransformedIterator<Integer, Integer> t = new TransformedIterator<Integer, Integer>(iter, negate); Function<Number, Double> negateDouble = new Function<Number, Double>() { public Double evaluate(Number obj) { return Double.valueOf(obj.intValue() * -1); } }; assertEquals(t, new TransformedIterator<Integer, Integer>(iter, negate)); assertTrue(!t.equals(new TransformedIterator<Integer, Double>(list.iterator(), negateDouble))); assertTrue(!t.equals(new TransformedIterator<Float, Integer>(Arrays.asList(0.0f, 0.1f).iterator(), negate))); assertTrue(!t.equals(null)); }
|
### Question:
RecursiveEvaluation implements NullaryFunction<Object> { public final Object evaluate() { Object result = null; while (true) { result = function.evaluate(); if (functionType.isInstance(result)) { function = (NullaryFunction<?>) result; continue; } else { break; } } return result; } RecursiveEvaluation(NullaryFunction<?> function); RecursiveEvaluation(NullaryFunction<?> function, Class<?> functionType); final Object evaluate(); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testRecurse() { assertEquals(Integer.valueOf(5), new RecursiveEvaluation(new RecFunc(0, false)).evaluate()); @SuppressWarnings({ "unchecked", "rawtypes" }) NullaryFunction<Object> func = (NullaryFunction) new RecursiveEvaluation(new RecFunc(0, true)).evaluate(); assertEquals(Integer.valueOf(5), func.evaluate()); }
|
### Question:
DoUntil extends PredicatedLoop { public DoUntil(NullaryProcedure body, NullaryPredicate test) { super(body, test); } DoUntil(NullaryProcedure body, NullaryPredicate test); final void run(); @Override String toString(); }### Answer:
@Test public void testDoUntil() { for(int i=0;i<3;++i){ Counter counter = new Counter(); new DoUntil(counter, new Offset(i)).run(); assertEquals(i+1,counter.count); } }
|
### Question:
FindWithinGenerator implements BinaryFunction<Generator<? extends E>, Predicate<? super E>, E> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof FindWithinGenerator<?>)) { return false; } FindWithinGenerator<?> other = (FindWithinGenerator<?>) obj; return other.useIfNone == useIfNone && !useIfNone || (other.ifNone == this.ifNone || other.ifNone != null && other.ifNone.equals(this.ifNone)); } FindWithinGenerator(); FindWithinGenerator(E ifNone); E evaluate(Generator<? extends E> left, Predicate<? super E> right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FindWithinGenerator<Object> instance(); static final FindWithinGenerator<Object> INSTANCE; }### Answer:
@Test public void testEquals() { FindWithinGenerator<Object> f = new FindWithinGenerator<Object>(); assertEquals(f, f); assertObjectsAreEqual(f, new FindWithinGenerator<Object>()); assertObjectsAreEqual(new FindWithinGenerator<Object>(Double.valueOf(0)), new FindWithinGenerator<Object>( Double.valueOf(0))); assertObjectsAreNotEqual(f, new FindWithinGenerator<Object>(Integer.valueOf(0))); }
|
### Question:
FindWithinGenerator implements BinaryFunction<Generator<? extends E>, Predicate<? super E>, E> { public E evaluate(Generator<? extends E> left, Predicate<? super E> right) { FindProcedure<E> findProcedure = new FindProcedure<E>(right); left.run(findProcedure); if (!findProcedure.wasFound) { if (useIfNone) { return ifNone; } throw new NoSuchElementException("No element matching " + right + " was found."); } return findProcedure.found; } FindWithinGenerator(); FindWithinGenerator(E ifNone); E evaluate(Generator<? extends E> left, Predicate<? super E> right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FindWithinGenerator<Object> instance(); static final FindWithinGenerator<Object> INSTANCE; }### Answer:
@Test(expected = NoSuchElementException.class) public void testDetect() { assertEquals(Integer.valueOf(3), new FindWithinGenerator<Integer>().evaluate( IteratorToGeneratorAdapter.adapt(numbers.iterator()), equalsThree)); new FindWithinGenerator<Integer>().evaluate(IteratorToGeneratorAdapter.adapt(numbers.iterator()), equalsTwentyThree); }
@Test public void testDetectIfNone() { assertEquals( Integer.valueOf(3), new FindWithinGenerator<Integer>(Integer.valueOf(3)).evaluate( IteratorToGeneratorAdapter.adapt(numbers.iterator()), equalsThree)); assertEquals("Xyzzy", new FindWithinGenerator<String>("Xyzzy").evaluate( IteratorToGeneratorAdapter.adapt(strings.iterator()), equalsXyZ)); }
|
### Question:
FindWithinGenerator implements BinaryFunction<Generator<? extends E>, Predicate<? super E>, E> { public static FindWithinGenerator<Object> instance() { return INSTANCE; } FindWithinGenerator(); FindWithinGenerator(E ifNone); E evaluate(Generator<? extends E> left, Predicate<? super E> right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FindWithinGenerator<Object> instance(); static final FindWithinGenerator<Object> INSTANCE; }### Answer:
@Test public void testInstance() { assertNotNull("FindWithinGenerator instance must not be null", FindWithinGenerator.instance()); }
|
### Question:
FoldLeft implements Function<Generator<T>, T>, BinaryFunction<Generator<T>, T, T> { public FoldLeft(BinaryFunction<? super T, ? super T, ? extends T> func) { this.function = func; } FoldLeft(BinaryFunction<? super T, ? super T, ? extends T> func); final T evaluate(Generator<T> obj); final T evaluate(Generator<T> left, T right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testFoldLeft() { FoldLeft<Integer> foldLeft = new FoldLeft<Integer>(new BinaryFunction<Integer, Integer, Integer>() { public Integer evaluate(Integer a, Integer b) { return Integer.valueOf(a + b); } }); assertEquals(Integer.valueOf(sum), foldLeft.evaluate(IteratorToGeneratorAdapter.adapt(list.iterator()))); assertEquals(Integer.valueOf(sum), foldLeft.evaluate(IteratorToGeneratorAdapter.adapt(list.iterator()), Integer.valueOf(0))); assertEquals(Integer.valueOf(0), foldLeft.evaluate(IteratorToGeneratorAdapter.adapt(new ArrayList<Integer>(0).iterator()), Integer.valueOf(0)), Integer.valueOf(0)); }
|
### Question:
UntilDo extends PredicatedLoop { public UntilDo(NullaryPredicate test, NullaryProcedure body) { super(body, test); } UntilDo(NullaryPredicate test, NullaryProcedure body); final void run(); @Override String toString(); }### Answer:
@Test public void testUntilDo() { for (int i=0;i<3;i++){ Counter counter = new Counter(); new UntilDo(new Offset(i), counter).run(); assertEquals(i,counter.count); } }
|
### Question:
InPlaceTransform implements BinaryProcedure<ListIterator<T>, Function<? super T, ? extends T>> { public void run(ListIterator<T> left, Function<? super T, ? extends T> right) { while (left.hasNext()) { left.set(right.evaluate(left.next())); } } void run(ListIterator<T> left, Function<? super T, ? extends T> right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static InPlaceTransform<Object> instance(); }### Answer:
@Test public void testTransform() { new InPlaceTransform<Integer>().run(list.listIterator(), new Function<Integer, Integer>() { public Integer evaluate(Integer obj) { return Integer.valueOf(obj * 2); } }); assertEquals(doubled, list); }
|
### Question:
IndexOfInGenerator implements BinaryFunction<LoopGenerator<? extends T>, Predicate<? super T>, Number> { public Number evaluate(LoopGenerator<? extends T> left, Predicate<? super T> right) { IndexProcedure<T> findProcedure = new IndexProcedure<T>(left, right); left.run(findProcedure); return Long.valueOf(findProcedure.index); } Number evaluate(LoopGenerator<? extends T> left, Predicate<? super T> right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IndexOfInGenerator<Object> instance(); }### Answer:
@Test public void testIndexOfInGenerator() { assertEquals(3L, new IndexOfInGenerator<Integer>().evaluate(IteratorToGeneratorAdapter.adapt(list.iterator()),equalsThree)); }
|
### Question:
WhileDo extends PredicatedLoop { public WhileDo(NullaryPredicate test, NullaryProcedure body) { super(body, test); } WhileDo(NullaryPredicate test, NullaryProcedure body); final void run(); @Override String toString(); }### Answer:
@Test public void testWhileDo() { for (int i=0;i<3;i++){ Counter counter = new Counter(); new WhileDo(new Limit(i),counter).run(); assertEquals(i,counter.count); } }
|
### Question:
GeneratorContains implements BinaryPredicate<Generator<? extends T>, Predicate<? super T>> { public boolean test(Generator<? extends T> left, Predicate<? super T> right) { ContainsProcedure<T> findProcedure = new ContainsProcedure<T>(right); left.run(findProcedure); return findProcedure.found; } boolean test(Generator<? extends T> left, Predicate<? super T> right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static GeneratorContains<Object> instance(); }### Answer:
@Test public void testContains() { assertTrue(new GeneratorContains<Integer>() .test(IteratorToGeneratorAdapter.adapt(list.iterator()), equalsThree)); assertFalse(new GeneratorContains<Integer>().test(IteratorToGeneratorAdapter.adapt(list.iterator()), equalsTwentyThree)); }
|
### Question:
RetainMatching implements BinaryProcedure<Iterator<? extends T>, Predicate<? super T>> { public void run(Iterator<? extends T> left, Predicate<? super T> right) { removeMatching.run(left, Not.not(right)); } void run(Iterator<? extends T> left, Predicate<? super T> right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RetainMatching<Object> instance(); }### Answer:
@Test public void testRemove() { new RetainMatching<Integer>().run(list.iterator(), isOdd); assertEquals(odds, list); }
|
### Question:
RemoveMatching implements BinaryProcedure<Iterator<? extends T>, Predicate<? super T>> { public void run(Iterator<? extends T> left, Predicate<? super T> right) { while (left.hasNext()) { if (right.test(left.next())) { left.remove(); } } } void run(Iterator<? extends T> left, Predicate<? super T> right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RemoveMatching<Object> instance(); }### Answer:
@Test public void testRemove() { new RemoveMatching<Integer>().run(list.iterator(), isOdd); assertEquals(evens, list); }
|
### Question:
DoWhile extends PredicatedLoop { public DoWhile(NullaryProcedure body, NullaryPredicate test) { super(body, test); } DoWhile(NullaryProcedure body, NullaryPredicate test); final void run(); @Override String toString(); }### Answer:
@Test public void testDoWhile() { for(int i=0;i<3;i++){ Counter counter = new Counter(); new DoWhile(counter, new Limit(i)).run(); assertEquals(i+1,counter.count); } }
|
### Question:
FoldRight implements Function<Generator<T>, T>, BinaryFunction<Generator<T>, T, T> { public FoldRight(BinaryFunction<? super T, ? super T, ? extends T> function) { this.function = function; } FoldRight(BinaryFunction<? super T, ? super T, ? extends T> function); final T evaluate(Generator<T> obj); final T evaluate(Generator<T> left, T right); @Override final boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testFoldRight() { FoldRight<Object> foldRight = new FoldRight<Object>(new BinaryFunction<Object, Object, Object>() { public Object evaluate(Object left, Object right) { StringBuilder buf = left instanceof StringBuilder ? (StringBuilder) left : new StringBuilder().append(left); return buf.append(right); } }); assertEquals("0123456789", foldRight.evaluate(IteratorToGeneratorAdapter.adapt(list.iterator())).toString()); assertEquals("0123456789x", foldRight.evaluate(IteratorToGeneratorAdapter.adapt(list.iterator()), "x").toString()); assertEquals("x", foldRight.evaluate(IteratorToGeneratorAdapter.adapt(new ArrayList<Object>().iterator()), "x").toString()); }
|
### Question:
Identity implements Function<T, T>, Predicate<T> { public T evaluate(T obj) { return obj; } Identity(); T evaluate(T obj); boolean test(Object obj); boolean test(Boolean bool); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static Identity<T> instance(); static final Identity<Object> INSTANCE; }### Answer:
@Test public void testEvaluate() throws Exception { Function<Object, Object> f = new Identity<Object>(); assertNull(f.evaluate(null)); assertEquals("xyzzy",f.evaluate("xyzzy")); assertEquals(Integer.valueOf(3),f.evaluate(Integer.valueOf(3))); Object obj = Long.valueOf(12345L); assertSame(obj,f.evaluate(obj)); }
|
### Question:
Identity implements Function<T, T>, Predicate<T> { public boolean test(Object obj) { return test((Boolean) obj); } Identity(); T evaluate(T obj); boolean test(Object obj); boolean test(Boolean bool); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static Identity<T> instance(); static final Identity<Object> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { Predicate<Object> p = new Identity<Object>(); assertTrue(p.test(Boolean.TRUE)); assertTrue(!p.test(Boolean.FALSE)); try { p.test("true"); fail("Expected ClassCastException"); } catch(ClassCastException e) { } try { p.test(null); fail("Expected NullPointerException"); } catch(NullPointerException e) { } }
|
### Question:
Identity implements Function<T, T>, Predicate<T> { @Override public boolean equals(Object that) { return (that instanceof Identity<?>); } Identity(); T evaluate(T obj); boolean test(Object obj); boolean test(Boolean bool); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static Identity<T> instance(); static final Identity<Object> INSTANCE; }### Answer:
@Test public void testEquals() throws Exception { Function<Object, Object> f = new Identity<Object>(); assertEquals(f,f); assertObjectsAreEqual(f,new Identity<Object>()); assertObjectsAreEqual(f,Identity.instance()); assertObjectsAreNotEqual(f,Constant.of("abcde")); }
|
### Question:
Identity implements Function<T, T>, Predicate<T> { public static <T> Identity<T> instance() { return new Identity<T>(); } Identity(); T evaluate(T obj); boolean test(Object obj); boolean test(Boolean bool); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static Identity<T> instance(); static final Identity<Object> INSTANCE; }### Answer:
@Test public void testConstant() throws Exception { assertEquals(Identity.instance(),Identity.instance()); }
|
### Question:
RightIdentity { public static <L, R> BinaryFunction<L, R, R> function() { return IgnoreLeftFunction.adapt(new Identity<R>()); } RightIdentity(); static BinaryFunction<L, R, R> function(); static BinaryPredicate<L, Boolean> predicate(); static final BinaryFunction<Object, Object, Object> FUNCTION; static final BinaryPredicate<Object, Boolean> PREDICATE; }### Answer:
@Test public void testEquals() throws Exception { BinaryFunction<Object, Object, Object> f = RightIdentity.FUNCTION; assertEquals(f,f); assertObjectsAreEqual(f,RightIdentity.function()); assertObjectsAreNotEqual(f,new Identity<Object>()); assertObjectsAreNotEqual(f,LeftIdentity.function()); assertObjectsAreNotEqual(f,Constant.TRUE); assertObjectsAreNotEqual(f,Constant.of("abcde")); }
@Test public void testConstant() throws Exception { assertEquals(RightIdentity.function(),RightIdentity.function()); }
|
### Question:
WhileGenerate extends LoopGenerator<E> { @Override public int hashCode() { int result = "WhileGenerate".hashCode(); result <<= 2; Generator<?> gen = getWrappedGenerator(); result ^= gen.hashCode(); result <<= 2; result ^= test.hashCode(); return result; } WhileGenerate(Predicate<? super E> test, Generator<? extends E> wrapped); void run(final Procedure<? super E> proc); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testHashcode() { assertEquals(whileGenerate.hashCode(), whileGenerate.hashCode()); assertEquals(whileGenerate.hashCode(), new WhileGenerate<Integer>(isLessThanFive, wrappedGenerator).hashCode()); }
|
### Question:
IsEqual implements BinaryPredicate<L, R> { public boolean test(L left, R right) { return left == right || left != null && left.equals(right); } IsEqual(); boolean test(L left, R right); @Override boolean equals(Object that); @Override int hashCode(); @Override String toString(); static IsEqual<L, R> instance(); static Predicate<L> to(R object); static final IsEqual<Object, Object> INSTANCE; }### Answer:
@Test public void testTest() throws Exception { IsEqual<Object, Object> p = new IsEqual<Object, Object>(); assertTrue("For symmetry, two nulls should be equal", p.test(null, null)); assertTrue(p.test("foo", "foo")); assertFalse(p.test(null, "foo")); assertFalse(p.test("foo", null)); assertTrue(p.test(Integer.valueOf(3), Integer.valueOf(3))); assertFalse(p.test(null, Integer.valueOf(3))); assertFalse(p.test(Integer.valueOf(3), null)); assertFalse(p.test(Integer.valueOf(3), Integer.valueOf(4))); assertFalse(p.test(Integer.valueOf(4), Integer.valueOf(3))); assertFalse(p.test("3", Integer.valueOf(3))); assertFalse(p.test(Integer.valueOf(3), "3")); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.