method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
IsEqual implements BinaryPredicate<L, R> { @Override public boolean equals(Object that) { return that instanceof IsEqual<?, ?>; } 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 testEquals() throws Exception { BinaryPredicate<Object, Object> f = new IsEqual<Object, Object>(); assertEquals(f, f); assertObjectsAreEqual(f, new IsEqual<Object, Object>()); assertObjectsAreEqual(f, IsEqual.instance()); assertObjectsAreNotEqual(f, Constant.truePredicate()); }
|
### Question:
IsEqual implements BinaryPredicate<L, R> { public static <L, R> IsEqual<L, R> instance() { return new IsEqual<L, R>(); } 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 testConstant() throws Exception { assertEquals(IsEqual.instance(), IsEqual.instance()); assertNotSame(IsEqual.instance(), IsEqual.instance()); assertSame(IsEqual.INSTANCE, IsEqual.INSTANCE); }
|
### Question:
BinaryFunctionBinaryPredicate implements BinaryPredicate<L, R> { public boolean test(final L left, final R right) { return function.evaluate(left, right).booleanValue(); } BinaryFunctionBinaryPredicate(final BinaryFunction<? super L, ? super R, Boolean> function); boolean test(final L left, final R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryFunctionBinaryPredicate<L, R> adapt(
final BinaryFunction<? super L, ? super R, Boolean> function); }### Answer:
@Test public void testTestWhenTrue() throws Exception { BinaryPredicate<Object, Object> p = new BinaryFunctionBinaryPredicate<Object, Object>(Constant.TRUE); assertTrue(p.test(null,null)); }
@Test public void testTestWhenFalse() throws Exception { BinaryPredicate<Object, Object> p = new BinaryFunctionBinaryPredicate<Object, Object>(Constant.FALSE); assertFalse(p.test(null,null)); }
|
### Question:
BinaryFunctionBinaryPredicate implements BinaryPredicate<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BinaryFunctionBinaryPredicate<?, ?>)) { return false; } BinaryFunctionBinaryPredicate<?, ?> that = (BinaryFunctionBinaryPredicate<?, ?>) obj; return this.function.equals(that.function); } BinaryFunctionBinaryPredicate(final BinaryFunction<? super L, ? super R, Boolean> function); boolean test(final L left, final R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryFunctionBinaryPredicate<L, R> adapt(
final BinaryFunction<? super L, ? super R, Boolean> function); }### Answer:
@Test public void testEquals() throws Exception { BinaryPredicate<Object, Object> p = new BinaryFunctionBinaryPredicate<Object, Object>(Constant.TRUE); assertEquals(p,p); assertObjectsAreEqual(p,new BinaryFunctionBinaryPredicate<Object, Object>(Constant.TRUE)); assertObjectsAreNotEqual(p,Constant.truePredicate()); assertObjectsAreNotEqual(p,new BinaryFunctionBinaryPredicate<Object, Object>(Constant.FALSE)); assertTrue(!p.equals(null)); }
|
### Question:
BinaryFunctionBinaryPredicate implements BinaryPredicate<L, R> { public static <L, R, T> BinaryFunctionBinaryPredicate<L, R> adapt( final BinaryFunction<? super L, ? super R, Boolean> function) { return null == function ? null : new BinaryFunctionBinaryPredicate<L, R>(function); } BinaryFunctionBinaryPredicate(final BinaryFunction<? super L, ? super R, Boolean> function); boolean test(final L left, final R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryFunctionBinaryPredicate<L, R> adapt(
final BinaryFunction<? super L, ? super R, Boolean> function); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(BinaryFunctionBinaryPredicate.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(BinaryFunctionBinaryPredicate.adapt(Constant.TRUE)); }
|
### Question:
LeftBoundPredicate implements Predicate<A> { public boolean test(A obj) { return predicate.test(param, obj); } @SuppressWarnings("unchecked") <L> LeftBoundPredicate(BinaryPredicate<? super L, ? super A> predicate, L arg); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static LeftBoundPredicate<R> bind(BinaryPredicate<? super L, ? super R> predicate, L arg); }### Answer:
@Test public void testTest() throws Exception { Predicate<Boolean> p = new LeftBoundPredicate<Boolean>( new BinaryFunctionBinaryPredicate<Object, Boolean>(RightIdentity.<Object, Boolean> function()), "foo"); assertTrue(p.test(Boolean.TRUE)); assertFalse(p.test(Boolean.FALSE)); }
|
### Question:
LeftBoundPredicate implements Predicate<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof LeftBoundPredicate<?>)) { return false; } LeftBoundPredicate<?> that = (LeftBoundPredicate<?>) obj; return predicate.equals(that.predicate) && (null == param ? null == that.param : param.equals(that.param)); } @SuppressWarnings("unchecked") <L> LeftBoundPredicate(BinaryPredicate<? super L, ? super A> predicate, L arg); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static LeftBoundPredicate<R> bind(BinaryPredicate<? super L, ? super R> predicate, L arg); }### Answer:
@Test public void testEquals() throws Exception { Predicate<Boolean> p = new LeftBoundPredicate<Boolean>(Constant.TRUE,"xyzzy"); assertEquals(p,p); assertObjectsAreEqual(p,new LeftBoundPredicate<Boolean>(Constant.TRUE,"xyzzy")); assertObjectsAreNotEqual(p,Constant.TRUE); assertObjectsAreNotEqual(p,new LeftBoundPredicate<Boolean>(Constant.FALSE,"xyzzy")); assertObjectsAreNotEqual(p,new LeftBoundPredicate<Boolean>(Constant.TRUE,"foo")); assertObjectsAreNotEqual(p,new LeftBoundPredicate<Boolean>(Constant.TRUE,null)); assertObjectsAreEqual(new LeftBoundPredicate<Boolean>(Constant.TRUE,null),new LeftBoundPredicate<Boolean>(Constant.TRUE,null)); assertTrue(!p.equals(null)); }
|
### Question:
LeftBoundPredicate implements Predicate<A> { public static <L, R> LeftBoundPredicate<R> bind(BinaryPredicate<? super L, ? super R> predicate, L arg) { return null == predicate ? null : new LeftBoundPredicate<R>(predicate, arg); } @SuppressWarnings("unchecked") <L> LeftBoundPredicate(BinaryPredicate<? super L, ? super A> predicate, L arg); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static LeftBoundPredicate<R> bind(BinaryPredicate<? super L, ? super R> predicate, L arg); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(LeftBoundPredicate.bind(null,"xyzzy")); }
@Test public void testAdapt() throws Exception { assertNotNull(LeftBoundPredicate.bind(Constant.FALSE,"xyzzy")); assertNotNull(LeftBoundPredicate.bind(Constant.FALSE,null)); }
|
### Question:
IgnoreLeftProcedure implements BinaryProcedure<L, R> { public void run(L left, R right) { procedure.run(right); } IgnoreLeftProcedure(Procedure<? super R> procedure); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreLeftProcedure<L, R> adapt(Procedure<? super R> procedure); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryProcedure<Object, Object> p = new IgnoreLeftProcedure<Object, Object>( new FunctionProcedure<Object>(Identity.INSTANCE)); p.run(null,Boolean.TRUE); }
|
### Question:
IgnoreLeftProcedure implements BinaryProcedure<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IgnoreLeftProcedure<?, ?>)) { return false; } IgnoreLeftProcedure<?, ?> that = (IgnoreLeftProcedure<?, ?>) obj; return this.procedure.equals(that.procedure); } IgnoreLeftProcedure(Procedure<? super R> procedure); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreLeftProcedure<L, R> adapt(Procedure<? super R> procedure); }### Answer:
@Test public void testEquals() throws Exception { BinaryProcedure<Object, Object> p = new IgnoreLeftProcedure<Object, Object>(NoOp.INSTANCE); assertEquals(p,p); assertObjectsAreEqual(p,new IgnoreLeftProcedure<Object, Object>(NoOp.INSTANCE)); assertObjectsAreNotEqual(p,NoOp.INSTANCE); assertObjectsAreNotEqual(p,new IgnoreLeftProcedure<Object, Object>(new Sequence<Object>())); assertTrue(!p.equals(null)); }
|
### Question:
IgnoreLeftProcedure implements BinaryProcedure<L, R> { public static <L, R> IgnoreLeftProcedure<L, R> adapt(Procedure<? super R> procedure) { return null == procedure ? null : new IgnoreLeftProcedure<L, R>(procedure); } IgnoreLeftProcedure(Procedure<? super R> procedure); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreLeftProcedure<L, R> adapt(Procedure<? super R> procedure); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(IgnoreLeftProcedure.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(IgnoreLeftProcedure.adapt(NoOp.INSTANCE)); }
|
### Question:
BinaryProcedureProcedure implements Procedure<A> { public void run(A obj) { procedure.run(obj, obj); } BinaryProcedureProcedure(BinaryProcedure<? super A, ? super A> procedure); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Procedure<A> adapt(BinaryProcedure<? super A, ? super A> procedure); }### Answer:
@Test public void testRun() throws Exception { Procedure<Object> p = new BinaryProcedureProcedure<Object>(NoOp.INSTANCE); p.run(null); }
|
### Question:
BinaryProcedureProcedure implements Procedure<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BinaryProcedureProcedure<?>)) { return false; } BinaryProcedureProcedure<?> that = (BinaryProcedureProcedure<?>) obj; return this.procedure.equals(that.procedure); } BinaryProcedureProcedure(BinaryProcedure<? super A, ? super A> procedure); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Procedure<A> adapt(BinaryProcedure<? super A, ? super A> procedure); }### Answer:
@Test public void testEquals() throws Exception { Procedure<Object> p = new BinaryProcedureProcedure<Object>(NoOp.INSTANCE); assertEquals(p, p); assertObjectsAreEqual(p, new BinaryProcedureProcedure<Object>(NoOp.INSTANCE)); assertObjectsAreNotEqual(p, NoOp.INSTANCE); assertObjectsAreNotEqual(p, new BinaryProcedureProcedure<Object>(IgnoreLeftProcedure.adapt(NoOp.INSTANCE))); assertTrue(!p.equals(null)); }
|
### Question:
BinaryProcedureProcedure implements Procedure<A> { public static <A> Procedure<A> adapt(BinaryProcedure<? super A, ? super A> procedure) { return null == procedure ? null : new BinaryProcedureProcedure<A>(procedure); } BinaryProcedureProcedure(BinaryProcedure<? super A, ? super A> procedure); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Procedure<A> adapt(BinaryProcedure<? super A, ? super A> procedure); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(BinaryProcedureProcedure.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(BinaryProcedureProcedure.adapt(NoOp.INSTANCE)); }
|
### Question:
RightBoundProcedure implements Procedure<A> { public void run(A obj) { procedure.run(obj, param); } @SuppressWarnings("unchecked") <R> RightBoundProcedure(BinaryProcedure<? super A, ? super R> procedure, R arg); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RightBoundProcedure<L> bind(BinaryProcedure<? super L, ? super R> procedure, R arg); }### Answer:
@Test public void testRun() throws Exception { Procedure<Object> p = new RightBoundProcedure<Object>( new BinaryFunctionBinaryProcedure<Object, Object>(LeftIdentity.FUNCTION), "foo"); p.run(Boolean.TRUE); p.run(Boolean.FALSE); }
|
### Question:
RightBoundProcedure implements Procedure<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof RightBoundProcedure<?>)) { return false; } RightBoundProcedure<?> that = (RightBoundProcedure<?>) obj; return this.procedure.equals(that.procedure) && (null == param ? null == that.param : param.equals(that.param)); } @SuppressWarnings("unchecked") <R> RightBoundProcedure(BinaryProcedure<? super A, ? super R> procedure, R arg); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RightBoundProcedure<L> bind(BinaryProcedure<? super L, ? super R> procedure, R arg); }### Answer:
@Test public void testEquals() throws Exception { Procedure<Object> f = new RightBoundProcedure<Object>(NoOp.INSTANCE,"xyzzy"); assertEquals(f,f); assertObjectsAreEqual(f,new RightBoundProcedure<Object>(NoOp.INSTANCE,"xyzzy")); assertObjectsAreNotEqual(f,NoOp.INSTANCE); assertObjectsAreNotEqual(f,new RightBoundProcedure<Object>(new BinaryFunctionBinaryProcedure<Object, Object>(LeftIdentity.FUNCTION),"xyzzy")); assertObjectsAreNotEqual(f,new RightBoundProcedure<Object>(NoOp.INSTANCE,"foo")); assertObjectsAreNotEqual(f,new RightBoundProcedure<Object>(NoOp.INSTANCE,null)); assertObjectsAreEqual(new RightBoundProcedure<Object>(NoOp.INSTANCE,null),new RightBoundProcedure<Object>(NoOp.INSTANCE,null)); assertObjectsAreNotEqual(new RightBoundProcedure<Object>(new BinarySequence<Object, Object>(),null),new RightBoundProcedure<Object>(NoOp.INSTANCE,null)); assertTrue(!f.equals(null)); }
|
### Question:
RightBoundProcedure implements Procedure<A> { public static <L, R> RightBoundProcedure<L> bind(BinaryProcedure<? super L, ? super R> procedure, R arg) { return null == procedure ? null : new RightBoundProcedure<L>(procedure, arg); } @SuppressWarnings("unchecked") <R> RightBoundProcedure(BinaryProcedure<? super A, ? super R> procedure, R arg); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RightBoundProcedure<L> bind(BinaryProcedure<? super L, ? super R> procedure, R arg); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(RightBoundProcedure.bind(null,"xyzzy")); }
@Test public void testAdapt() throws Exception { assertNotNull(RightBoundProcedure.bind(NoOp.INSTANCE,"xyzzy")); assertNotNull(RightBoundProcedure.bind(NoOp.INSTANCE,null)); }
|
### Question:
PredicateFunction implements Function<A, Boolean> { public Boolean evaluate(A obj) { return Boolean.valueOf(predicate.test(obj)); } PredicateFunction(Predicate<? super A> predicate); Boolean evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static PredicateFunction<A> adapt(Predicate<? super A> predicate); }### Answer:
@Test public void testTestWhenTrue() throws Exception { Function<Object, Boolean> f = new PredicateFunction<Object>(Constant.TRUE); assertEquals(Boolean.TRUE,f.evaluate(null)); }
@Test public void testTestWhenFalse() throws Exception { Function<Object, Boolean> f = new PredicateFunction<Object>(Constant.FALSE); assertEquals(Boolean.FALSE,f.evaluate(null)); }
|
### Question:
PredicateFunction implements Function<A, Boolean> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof PredicateFunction<?>)) { return false; } PredicateFunction<?> that = (PredicateFunction<?>) obj; return this.predicate.equals(that.predicate); } PredicateFunction(Predicate<? super A> predicate); Boolean evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static PredicateFunction<A> adapt(Predicate<? super A> predicate); }### Answer:
@Test public void testEquals() throws Exception { Function<Object, Boolean> f = new PredicateFunction<Object>(Constant.TRUE); assertEquals(f,f); assertObjectsAreEqual(f,new PredicateFunction<Object>(Constant.TRUE)); assertObjectsAreNotEqual(f,Constant.of("x")); assertObjectsAreNotEqual(f,new PredicateFunction<Object>(Constant.FALSE)); assertTrue(!f.equals(null)); }
|
### Question:
PredicateFunction implements Function<A, Boolean> { public static <A> PredicateFunction<A> adapt(Predicate<? super A> predicate) { return null == predicate ? null : new PredicateFunction<A>(predicate); } PredicateFunction(Predicate<? super A> predicate); Boolean evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static PredicateFunction<A> adapt(Predicate<? super A> predicate); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(PredicateFunction.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(PredicateFunction.adapt(Constant.TRUE)); }
|
### Question:
FullyBoundNullaryPredicate implements NullaryPredicate { public boolean test() { return predicate.test(left, right); } @SuppressWarnings("unchecked") <L, R> FullyBoundNullaryPredicate(BinaryPredicate<? super L, ? super R> predicate, L left, R right); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FullyBoundNullaryPredicate bind(
BinaryPredicate<? super L, ? super R> predicate, L left, R right); }### Answer:
@Test public void testTest() throws Exception { NullaryPredicate p = new FullyBoundNullaryPredicate( new BinaryFunctionBinaryPredicate<Object, Boolean>(RightIdentity.<Object, Boolean> function()), "foo", Boolean.TRUE); assertTrue(p.test()); }
|
### Question:
FullyBoundNullaryPredicate implements NullaryPredicate { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof FullyBoundNullaryPredicate)) { return false; } FullyBoundNullaryPredicate that = (FullyBoundNullaryPredicate) obj; return predicate.equals(that.predicate) && (null == left ? null == that.left : left.equals(that.left)) && (null == right ? null == that.right : right.equals(that.right)); } @SuppressWarnings("unchecked") <L, R> FullyBoundNullaryPredicate(BinaryPredicate<? super L, ? super R> predicate, L left, R right); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FullyBoundNullaryPredicate bind(
BinaryPredicate<? super L, ? super R> predicate, L left, R right); }### Answer:
@Test public void testEquals() throws Exception { NullaryPredicate p = new FullyBoundNullaryPredicate(Constant.TRUE, "xyzzy", null); assertEquals(p, p); assertObjectsAreEqual(p, new FullyBoundNullaryPredicate(Constant.TRUE, "xyzzy", null)); assertObjectsAreNotEqual(p, Constant.TRUE); assertObjectsAreNotEqual(p, new FullyBoundNullaryPredicate(Constant.FALSE, "xyzzy", null)); assertObjectsAreNotEqual(p, new FullyBoundNullaryPredicate(Constant.TRUE, "foo", null)); assertObjectsAreNotEqual(p, new FullyBoundNullaryPredicate(Constant.TRUE, null, "xyzzy")); assertObjectsAreNotEqual(new FullyBoundNullaryPredicate(Constant.TRUE, null, "xyzzy"), new FullyBoundNullaryPredicate(Constant.TRUE, null, null)); assertObjectsAreEqual(new FullyBoundNullaryPredicate(Constant.TRUE, "foo", "xyzzy"), new FullyBoundNullaryPredicate(Constant.TRUE, "foo", "xyzzy")); assertTrue(!p.equals(null)); }
|
### Question:
FullyBoundNullaryPredicate implements NullaryPredicate { public static <L, R> FullyBoundNullaryPredicate bind( BinaryPredicate<? super L, ? super R> predicate, L left, R right) { return null == predicate ? null : new FullyBoundNullaryPredicate(predicate, left, right); } @SuppressWarnings("unchecked") <L, R> FullyBoundNullaryPredicate(BinaryPredicate<? super L, ? super R> predicate, L left, R right); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FullyBoundNullaryPredicate bind(
BinaryPredicate<? super L, ? super R> predicate, L left, R right); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(FullyBoundNullaryPredicate.bind(null, "xyzzy", null)); }
@Test public void testAdapt() throws Exception { assertNotNull(FullyBoundNullaryPredicate.bind(Constant.FALSE, "xyzzy", "foobar")); assertNotNull(FullyBoundNullaryPredicate.bind(Constant.FALSE, null, null)); }
|
### Question:
BinaryPredicatePredicate implements Predicate<A> { public boolean test(A obj) { return predicate.test(obj, obj); } BinaryPredicatePredicate(BinaryPredicate<? super A, ? super A> predicate); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Predicate<A> adapt(BinaryPredicate<? super A, ? super A> predicate); }### Answer:
@Test public void testTestWhenTrue() throws Exception { Predicate<Object> p = new BinaryPredicatePredicate<Object>(IsSame.INSTANCE); assertTrue(p.test(null)); }
@Test public void testTestWhenFalse() throws Exception { Predicate<Object> p = new BinaryPredicatePredicate<Object>(IsNotSame.INSTANCE); assertFalse(p.test(null)); }
|
### Question:
BinaryPredicatePredicate implements Predicate<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BinaryPredicatePredicate<?>)) { return false; } BinaryPredicatePredicate<?> that = (BinaryPredicatePredicate<?>) obj; return this.predicate.equals(that.predicate); } BinaryPredicatePredicate(BinaryPredicate<? super A, ? super A> predicate); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Predicate<A> adapt(BinaryPredicate<? super A, ? super A> predicate); }### Answer:
@Test public void testEquals() throws Exception { Predicate<Object> p = new BinaryPredicatePredicate<Object>(IsSame.INSTANCE); assertEquals(p, p); assertObjectsAreEqual(p, new BinaryPredicatePredicate<Object>(IsSame.INSTANCE)); assertObjectsAreNotEqual(p, Constant.truePredicate()); assertObjectsAreNotEqual(p, new BinaryPredicatePredicate<Object>(IsNotSame.INSTANCE)); }
|
### Question:
BinaryPredicatePredicate implements Predicate<A> { public static <A> Predicate<A> adapt(BinaryPredicate<? super A, ? super A> predicate) { return null == predicate ? null : new BinaryPredicatePredicate<A>(predicate); } BinaryPredicatePredicate(BinaryPredicate<? super A, ? super A> predicate); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static Predicate<A> adapt(BinaryPredicate<? super A, ? super A> predicate); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(BinaryPredicatePredicate.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(BinaryPredicatePredicate.adapt(Constant.TRUE)); }
|
### Question:
RightBoundFunction implements Function<A, T> { public T evaluate(A obj) { return function.evaluate(obj, param); } @SuppressWarnings("unchecked") <R> RightBoundFunction(BinaryFunction<? super A, ? super R, ? extends T> function, R arg); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RightBoundFunction<L, T> bind(BinaryFunction<? super L, ? super R, ? extends T> function,
R arg); }### Answer:
@Test public void testEvaluate() throws Exception { Function<String, String> f = RightBoundFunction.bind(LeftIdentity.<String, String>function(),"foo"); assertEquals("xyzzy",f.evaluate("xyzzy")); }
|
### Question:
RightBoundFunction implements Function<A, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof RightBoundFunction<?, ?>)) { return false; } RightBoundFunction<?, ?> that = (RightBoundFunction<?, ?>) obj; return function.equals(that.function) && (null == param ? null == that.param : param.equals(that.param)); } @SuppressWarnings("unchecked") <R> RightBoundFunction(BinaryFunction<? super A, ? super R, ? extends T> function, R arg); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RightBoundFunction<L, T> bind(BinaryFunction<? super L, ? super R, ? extends T> function,
R arg); }### Answer:
@Test public void testEquals() throws Exception { Function<Object, Object> f = RightBoundFunction.bind(LeftIdentity.FUNCTION,"xyzzy"); assertEquals(f,f); assertObjectsAreEqual(f,new RightBoundFunction<Object, Object>(LeftIdentity.FUNCTION,"xyzzy")); assertObjectsAreNotEqual(f,Constant.of("xyzzy")); assertObjectsAreNotEqual(f,new RightBoundFunction<Object, Object>(RightIdentity.FUNCTION,"xyzzy")); assertObjectsAreNotEqual(f,new RightBoundFunction<Object, Object>(LeftIdentity.FUNCTION,"bar")); assertObjectsAreNotEqual(f,new RightBoundFunction<Object, Object>(LeftIdentity.FUNCTION,null)); assertObjectsAreEqual(new RightBoundFunction<Object, Object>(LeftIdentity.FUNCTION,null),new RightBoundFunction<Object, Object>(LeftIdentity.FUNCTION,null)); assertTrue(!f.equals(null)); }
|
### Question:
RightBoundFunction implements Function<A, T> { public static <L, R, T> RightBoundFunction<L, T> bind(BinaryFunction<? super L, ? super R, ? extends T> function, R arg) { return null == function ? null : new RightBoundFunction<L, T>(function, arg); } @SuppressWarnings("unchecked") <R> RightBoundFunction(BinaryFunction<? super A, ? super R, ? extends T> function, R arg); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RightBoundFunction<L, T> bind(BinaryFunction<? super L, ? super R, ? extends T> function,
R arg); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(RightBoundFunction.bind(null,"xyzzy")); }
@Test public void testAdapt() throws Exception { assertNotNull(RightBoundFunction.bind(LeftIdentity.FUNCTION,"xyzzy")); assertNotNull(RightBoundFunction.bind(LeftIdentity.FUNCTION,null)); }
|
### Question:
IgnoreRightProcedure implements BinaryProcedure<L, R> { public void run(L left, R right) { procedure.run(left); } IgnoreRightProcedure(Procedure<? super L> procedure); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreRightProcedure<L, R> adapt(Procedure<? super L> procedure); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryProcedure<Object, Object> p = new IgnoreRightProcedure<Object, Object>( new FunctionProcedure<Object>(Identity.INSTANCE)); p.run(Boolean.TRUE,null); }
|
### Question:
IgnoreRightProcedure implements BinaryProcedure<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IgnoreRightProcedure<?, ?>)) { return false; } IgnoreRightProcedure<?, ?> that = (IgnoreRightProcedure<?, ?>) obj; return this.procedure.equals(that.procedure); } IgnoreRightProcedure(Procedure<? super L> procedure); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreRightProcedure<L, R> adapt(Procedure<? super L> procedure); }### Answer:
@Test public void testEquals() throws Exception { BinaryProcedure<Object, Object> p = new IgnoreRightProcedure<Object, Object>(NoOp.INSTANCE); assertEquals(p,p); assertObjectsAreEqual(p,new IgnoreRightProcedure<Object, Object>(NoOp.INSTANCE)); assertObjectsAreNotEqual(p,NoOp.INSTANCE); assertObjectsAreNotEqual(p,new IgnoreRightProcedure<Object, Object>(new Procedure<Object>() { public void run(Object obj) { } })); assertTrue(!p.equals(null)); }
|
### Question:
IgnoreRightProcedure implements BinaryProcedure<L, R> { public static <L, R> IgnoreRightProcedure<L, R> adapt(Procedure<? super L> procedure) { return null == procedure ? null : new IgnoreRightProcedure<L, R>(procedure); } IgnoreRightProcedure(Procedure<? super L> procedure); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreRightProcedure<L, R> adapt(Procedure<? super L> procedure); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(IgnoreRightProcedure.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(IgnoreRightProcedure.adapt(NoOp.INSTANCE)); }
|
### Question:
BinaryProcedureBinaryFunction implements BinaryFunction<L, R, T> { public T evaluate(L left, R right) { procedure.run(left, right); return null; } BinaryProcedureBinaryFunction(BinaryProcedure<? super L, ? super R> procedure); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryProcedureBinaryFunction<L, R, T> adapt(
BinaryProcedure<? super L, ? super R> procedure); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryFunction<Object, Object, Object> f = new BinaryProcedureBinaryFunction<Object, Object, Object>(NoOp.instance()); assertNull(f.evaluate(null,null)); }
|
### Question:
BinaryProcedureBinaryFunction implements BinaryFunction<L, R, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BinaryProcedureBinaryFunction<?, ?, ?>)) { return false; } BinaryProcedureBinaryFunction<?, ?, ?> that = (BinaryProcedureBinaryFunction<?, ?, ?>) obj; return this.procedure.equals(that.procedure); } BinaryProcedureBinaryFunction(BinaryProcedure<? super L, ? super R> procedure); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryProcedureBinaryFunction<L, R, T> adapt(
BinaryProcedure<? super L, ? super R> procedure); }### Answer:
@Test public void testEquals() throws Exception { BinaryFunction<Object, Object, Object> f = new BinaryProcedureBinaryFunction<Object, Object, Object>(new NoOp()); assertEquals(f,f); assertObjectsAreEqual(f,new BinaryProcedureBinaryFunction<Object, Object, Object>(new NoOp())); assertObjectsAreNotEqual(f,Constant.of("x")); assertObjectsAreNotEqual(f, new BinaryProcedureBinaryFunction<Object, Object, Object>( new BinaryProcedure<Object, Object>() { public void run(Object a, Object b) { } })); assertObjectsAreNotEqual(f,Constant.of(null)); }
|
### Question:
BinaryProcedureBinaryFunction implements BinaryFunction<L, R, T> { public static <L, R, T> BinaryProcedureBinaryFunction<L, R, T> adapt( BinaryProcedure<? super L, ? super R> procedure) { return null == procedure ? null : new BinaryProcedureBinaryFunction<L, R, T>(procedure); } BinaryProcedureBinaryFunction(BinaryProcedure<? super L, ? super R> procedure); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryProcedureBinaryFunction<L, R, T> adapt(
BinaryProcedure<? super L, ? super R> procedure); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(BinaryProcedureBinaryFunction.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(BinaryProcedureBinaryFunction.adapt(NoOp.instance())); }
|
### Question:
BoundNullaryProcedure implements NullaryProcedure { public void run() { procedure.run(param); } @SuppressWarnings("unchecked") <A> BoundNullaryProcedure(Procedure<? super A> procedure, A arg); void run(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BoundNullaryProcedure bind(Procedure<? super A> procedure, A arg); }### Answer:
@Test public void testRun() throws Exception { NullaryProcedure p = new BoundNullaryProcedure(new FunctionProcedure<Object>(Identity.INSTANCE),Boolean.TRUE); p.run(); }
|
### Question:
BoundNullaryProcedure implements NullaryProcedure { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BoundNullaryProcedure)) { return false; } BoundNullaryProcedure that = (BoundNullaryProcedure) obj; return procedure.equals(that.procedure) && (null == param ? null == that.param : param.equals(that.param)); } @SuppressWarnings("unchecked") <A> BoundNullaryProcedure(Procedure<? super A> procedure, A arg); void run(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BoundNullaryProcedure bind(Procedure<? super A> procedure, A arg); }### Answer:
@Test public void testEquals() throws Exception { NullaryProcedure f = new BoundNullaryProcedure(NoOp.INSTANCE,"xyzzy"); assertEquals(f,f); assertObjectsAreEqual(f,new BoundNullaryProcedure(NoOp.INSTANCE,"xyzzy")); assertObjectsAreNotEqual(f,NoOp.INSTANCE); assertObjectsAreNotEqual(f,new BoundNullaryProcedure(NoOp.INSTANCE,"foo")); assertObjectsAreNotEqual(f,new BoundNullaryProcedure(new FunctionProcedure<Object>(Identity.INSTANCE),"xyzzy")); assertObjectsAreNotEqual(f,new BoundNullaryProcedure(NoOp.INSTANCE,null)); assertObjectsAreEqual(new BoundNullaryProcedure(NoOp.INSTANCE,null),new BoundNullaryProcedure(NoOp.INSTANCE,null)); assertTrue(!f.equals(null)); }
|
### Question:
BoundNullaryProcedure implements NullaryProcedure { public static <A> BoundNullaryProcedure bind(Procedure<? super A> procedure, A arg) { return null == procedure ? null : new BoundNullaryProcedure(procedure, arg); } @SuppressWarnings("unchecked") <A> BoundNullaryProcedure(Procedure<? super A> procedure, A arg); void run(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BoundNullaryProcedure bind(Procedure<? super A> procedure, A arg); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(BoundNullaryProcedure.bind(null,"xyzzy")); }
@Test public void testAdapt() throws Exception { assertNotNull(BoundNullaryProcedure.bind(new NoOp(),"xyzzy")); assertNotNull(BoundNullaryProcedure.bind(new NoOp(),null)); }
|
### Question:
BinaryFunctionBinaryProcedure implements BinaryProcedure<L, R> { public void run(L left, R right) { function.evaluate(left, right); } BinaryFunctionBinaryProcedure(BinaryFunction<? super L, ? super R, ?> function); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryFunctionBinaryProcedure<L, R> adapt(BinaryFunction<? super L, ? super R, ?> function); }### Answer:
@Test public void testRun() throws Exception { class EvaluateCounter implements BinaryFunction<Object, Object, Integer> { int count = 0; public Integer evaluate(Object a, Object b) { return Integer.valueOf(count++); } } EvaluateCounter counter = new EvaluateCounter(); BinaryProcedure<Object, Object> p = new BinaryFunctionBinaryProcedure<Object, Object>(counter); assertEquals(0,counter.count); p.run(null,null); assertEquals(1,counter.count); p.run("x","y"); assertEquals(2,counter.count); }
|
### Question:
BinaryFunctionBinaryProcedure implements BinaryProcedure<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BinaryFunctionBinaryProcedure<?, ?>)) { return false; } BinaryFunctionBinaryProcedure<?, ?> that = (BinaryFunctionBinaryProcedure<?, ?>) obj; return this.function.equals(that.function); } BinaryFunctionBinaryProcedure(BinaryFunction<? super L, ? super R, ?> function); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryFunctionBinaryProcedure<L, R> adapt(BinaryFunction<? super L, ? super R, ?> function); }### Answer:
@Test public void testEquals() throws Exception { BinaryProcedure<Object, Object> p = new BinaryFunctionBinaryProcedure<Object, Object>(Constant.of("K")); assertEquals(p,p); assertObjectsAreEqual(p,new BinaryFunctionBinaryProcedure<Object, Object>(Constant.of("K"))); assertObjectsAreNotEqual(p,new NoOp()); assertObjectsAreNotEqual(p,new BinaryFunctionBinaryProcedure<Object, Object>(Constant.of("J"))); assertTrue(!p.equals(null)); }
|
### Question:
BinaryFunctionBinaryProcedure implements BinaryProcedure<L, R> { public static <L, R> BinaryFunctionBinaryProcedure<L, R> adapt(BinaryFunction<? super L, ? super R, ?> function) { return null == function ? null : new BinaryFunctionBinaryProcedure<L, R>(function); } BinaryFunctionBinaryProcedure(BinaryFunction<? super L, ? super R, ?> function); void run(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryFunctionBinaryProcedure<L, R> adapt(BinaryFunction<? super L, ? super R, ?> function); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(BinaryFunctionBinaryProcedure.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(BinaryFunctionBinaryProcedure.adapt(Constant.of("K"))); }
|
### Question:
NullaryFunctionNullaryPredicate implements NullaryPredicate { public boolean test() { return function.evaluate().booleanValue(); } NullaryFunctionNullaryPredicate(NullaryFunction<Boolean> function); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryFunctionNullaryPredicate adapt(NullaryFunction<Boolean> function); }### Answer:
@Test public void testTestWhenTrue() throws Exception { NullaryPredicate p = new NullaryFunctionNullaryPredicate(Constant.TRUE); assertTrue(p.test()); }
@Test public void testTestWhenFalse() throws Exception { NullaryPredicate p = new NullaryFunctionNullaryPredicate(Constant.FALSE); assertTrue(!p.test()); }
|
### Question:
NullaryFunctionNullaryPredicate implements NullaryPredicate { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof NullaryFunctionNullaryPredicate)) { return false; } NullaryFunctionNullaryPredicate that = (NullaryFunctionNullaryPredicate) obj; return this.function.equals(that.function); } NullaryFunctionNullaryPredicate(NullaryFunction<Boolean> function); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryFunctionNullaryPredicate adapt(NullaryFunction<Boolean> function); }### Answer:
@Test public void testEquals() throws Exception { NullaryPredicate p = new NullaryFunctionNullaryPredicate(Constant.TRUE); assertEquals(p,p); assertObjectsAreEqual(p,new NullaryFunctionNullaryPredicate(Constant.TRUE)); assertObjectsAreNotEqual(p,Constant.TRUE); assertObjectsAreNotEqual(p,new NullaryFunctionNullaryPredicate(Constant.FALSE)); assertTrue(!p.equals(null)); }
|
### Question:
NullaryFunctionNullaryPredicate implements NullaryPredicate { public static NullaryFunctionNullaryPredicate adapt(NullaryFunction<Boolean> function) { return null == function ? null : new NullaryFunctionNullaryPredicate(function); } NullaryFunctionNullaryPredicate(NullaryFunction<Boolean> function); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryFunctionNullaryPredicate adapt(NullaryFunction<Boolean> function); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(NullaryFunctionNullaryPredicate.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(NullaryFunctionNullaryPredicate.adapt(Constant.TRUE)); }
|
### Question:
NullaryPredicatePredicate implements Predicate<A> { public boolean test(Object obj) { return predicate.test(); } NullaryPredicatePredicate(NullaryPredicate predicate); boolean test(Object obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryPredicatePredicate<A> adapt(NullaryPredicate predicate); }### Answer:
@Test public void testEvaluate() throws Exception { Predicate<Object> p = new NullaryPredicatePredicate<Object>(Constant.TRUE); assertTrue(p.test(null)); }
|
### Question:
NullaryPredicatePredicate implements Predicate<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof NullaryPredicatePredicate<?>)) { return false; } NullaryPredicatePredicate<?> that = (NullaryPredicatePredicate<?>) obj; return this.predicate.equals(that.predicate); } NullaryPredicatePredicate(NullaryPredicate predicate); boolean test(Object obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryPredicatePredicate<A> adapt(NullaryPredicate predicate); }### Answer:
@Test public void testEquals() throws Exception { Predicate<Object> p = new NullaryPredicatePredicate<Object>(Constant.TRUE); assertEquals(p,p); assertObjectsAreEqual(p,new NullaryPredicatePredicate<Object>(Constant.TRUE)); assertObjectsAreNotEqual(p,Constant.TRUE); assertObjectsAreNotEqual(p,new NullaryPredicatePredicate<Object>(Constant.FALSE)); assertObjectsAreNotEqual(p,Constant.FALSE); assertTrue(!p.equals(null)); }
|
### Question:
NullaryPredicatePredicate implements Predicate<A> { public static <A> NullaryPredicatePredicate<A> adapt(NullaryPredicate predicate) { return null == predicate ? null : new NullaryPredicatePredicate<A>(predicate); } NullaryPredicatePredicate(NullaryPredicate predicate); boolean test(Object obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryPredicatePredicate<A> adapt(NullaryPredicate predicate); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(NullaryPredicatePredicate.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(NullaryPredicatePredicate.adapt(Constant.TRUE)); }
|
### Question:
IgnoreLeftFunction implements BinaryFunction<L, R, T> { public T evaluate(L left, R right) { return function.evaluate(right); } IgnoreLeftFunction(Function<? super R, ? extends T> function); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreLeftFunction<L, R, T> adapt(Function<? super R, ? extends T> function); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryFunction<String, String, String> f = new IgnoreLeftFunction<String, String, String>(new Identity<String>()); assertNull(f.evaluate(null,null)); assertNull(f.evaluate("xyzzy",null)); assertEquals("xyzzy",f.evaluate(null,"xyzzy")); assertEquals("xyzzy",f.evaluate("abc","xyzzy")); }
|
### Question:
IgnoreLeftFunction implements BinaryFunction<L, R, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IgnoreLeftFunction<?, ?, ?>)) { return false; } IgnoreLeftFunction<?, ?, ?> that = (IgnoreLeftFunction<?, ?, ?>) obj; return this.function.equals(that.function); } IgnoreLeftFunction(Function<? super R, ? extends T> function); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreLeftFunction<L, R, T> adapt(Function<? super R, ? extends T> function); }### Answer:
@Test public void testEquals() throws Exception { BinaryFunction<Object, Object, String> f = new IgnoreLeftFunction<Object, Object, String>(Constant.of("xyzzy")); assertEquals(f,f); assertObjectsAreEqual(f,new IgnoreLeftFunction<Object, Object, String>(Constant.of("xyzzy"))); assertObjectsAreNotEqual(f,Constant.of("x")); assertObjectsAreNotEqual(f,new IgnoreLeftFunction<Object, Object, String>(Constant.<String>of(null))); assertObjectsAreNotEqual(f,Constant.of(null)); assertTrue(!f.equals(null)); }
|
### Question:
IgnoreLeftFunction implements BinaryFunction<L, R, T> { public static <L, R, T> IgnoreLeftFunction<L, R, T> adapt(Function<? super R, ? extends T> function) { return null == function ? null : new IgnoreLeftFunction<L, R, T>(function); } IgnoreLeftFunction(Function<? super R, ? extends T> function); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreLeftFunction<L, R, T> adapt(Function<? super R, ? extends T> function); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(IgnoreLeftFunction.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(IgnoreLeftFunction.adapt(Constant.of("xyzzy"))); }
|
### Question:
BoundNullaryPredicate implements NullaryPredicate { public boolean test() { return predicate.test(param); } @SuppressWarnings("unchecked") <A> BoundNullaryPredicate(Predicate<? super A> predicate, A arg); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BoundNullaryPredicate bind(Predicate<? super A> predicate, A arg); }### Answer:
@Test public void testTest() throws Exception { { NullaryPredicate p = new BoundNullaryPredicate(new FunctionPredicate<Boolean>(Identity.<Boolean>instance()),Boolean.TRUE); assertTrue(p.test()); } { NullaryPredicate p = new BoundNullaryPredicate(new FunctionPredicate<Boolean>(Identity.<Boolean>instance()),Boolean.FALSE); assertFalse(p.test()); } }
|
### Question:
BoundNullaryPredicate implements NullaryPredicate { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BoundNullaryPredicate)) { return false; } BoundNullaryPredicate that = (BoundNullaryPredicate) obj; return predicate.equals(that.predicate) && (null == param ? null == that.param : param.equals(that.param)); } @SuppressWarnings("unchecked") <A> BoundNullaryPredicate(Predicate<? super A> predicate, A arg); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BoundNullaryPredicate bind(Predicate<? super A> predicate, A arg); }### Answer:
@Test public void testEquals() throws Exception { NullaryPredicate f = new BoundNullaryPredicate(Constant.TRUE,"xyzzy"); assertEquals(f,f); assertObjectsAreEqual(f,new BoundNullaryPredicate(Constant.TRUE,"xyzzy")); assertObjectsAreNotEqual(f,Constant.TRUE); assertObjectsAreNotEqual(f,new BoundNullaryPredicate(Constant.TRUE,"foo")); assertObjectsAreNotEqual(f,new BoundNullaryPredicate(Constant.FALSE,"xyzzy")); assertObjectsAreNotEqual(f,new BoundNullaryPredicate(Constant.TRUE,null)); assertObjectsAreEqual(new BoundNullaryPredicate(Constant.TRUE,null),new BoundNullaryPredicate(Constant.TRUE,null)); assertTrue(!f.equals(null)); }
|
### Question:
BoundNullaryPredicate implements NullaryPredicate { public static <A> BoundNullaryPredicate bind(Predicate<? super A> predicate, A arg) { return null == predicate ? null : new BoundNullaryPredicate(predicate, arg); } @SuppressWarnings("unchecked") <A> BoundNullaryPredicate(Predicate<? super A> predicate, A arg); boolean test(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BoundNullaryPredicate bind(Predicate<? super A> predicate, A arg); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(BoundNullaryPredicate.bind(null,"xyzzy")); }
@Test public void testAdapt() throws Exception { assertNotNull(BoundNullaryPredicate.bind(Constant.TRUE,"xyzzy")); assertNotNull(BoundNullaryPredicate.bind(Constant.TRUE,null)); }
|
### Question:
ProcedureFunction implements Function<A, T> { public T evaluate(A obj) { procedure.run(obj); return null; } ProcedureFunction(Procedure<? super A> procedure); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static ProcedureFunction<A, T> adapt(Procedure<? super A> procedure); }### Answer:
@Test public void testEvaluate() throws Exception { Function<Object, Object> f = new ProcedureFunction<Object, Object>(NoOp.INSTANCE); assertNull(f.evaluate(null)); }
|
### Question:
ProcedureFunction implements Function<A, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof ProcedureFunction<?, ?>)) { return false; } ProcedureFunction<?, ?> that = (ProcedureFunction<?, ?>) obj; return this.procedure.equals(that.procedure); } ProcedureFunction(Procedure<? super A> procedure); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static ProcedureFunction<A, T> adapt(Procedure<? super A> procedure); }### Answer:
@Test public void testEquals() throws Exception { Function<Object, Object> f = new ProcedureFunction<Object, Object>(NoOp.INSTANCE); assertEquals(f,f); assertObjectsAreEqual(f,new ProcedureFunction<Object, Object>(NoOp.INSTANCE)); assertObjectsAreNotEqual(f,Constant.of("x")); assertObjectsAreNotEqual(f, new ProcedureFunction<Object, Object>(new Procedure<Object>() { public void run(Object a) { } })); assertObjectsAreNotEqual(f,Constant.of(null)); assertTrue(!f.equals(null)); }
|
### Question:
ProcedureFunction implements Function<A, T> { public static <A, T> ProcedureFunction<A, T> adapt(Procedure<? super A> procedure) { return null == procedure ? null : new ProcedureFunction<A, T>(procedure); } ProcedureFunction(Procedure<? super A> procedure); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static ProcedureFunction<A, T> adapt(Procedure<? super A> procedure); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(ProcedureFunction.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(ProcedureFunction.adapt(new NoOp())); }
|
### Question:
RightBoundPredicate implements Predicate<A> { public boolean test(A obj) { return predicate.test(obj, param); } @SuppressWarnings("unchecked") <R> RightBoundPredicate(BinaryPredicate<? super A, ? super R> predicate, R arg); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RightBoundPredicate<L> bind(BinaryPredicate<? super L, ? super R> predicate, R arg); }### Answer:
@Test public void testTest() throws Exception { Predicate<Boolean> f = new RightBoundPredicate<Boolean>( new BinaryFunctionBinaryPredicate<Boolean, Object>(LeftIdentity.<Boolean, Object> function()), "foo"); assertTrue(f.test(Boolean.TRUE)); assertFalse(f.test(Boolean.FALSE)); }
|
### Question:
RightBoundPredicate implements Predicate<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof RightBoundPredicate<?>)) { return false; } RightBoundPredicate<?> that = (RightBoundPredicate<?>) obj; return this.predicate.equals(that.predicate) && (null == this.param ? null == that.param : this.param.equals(that.param)); } @SuppressWarnings("unchecked") <R> RightBoundPredicate(BinaryPredicate<? super A, ? super R> predicate, R arg); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RightBoundPredicate<L> bind(BinaryPredicate<? super L, ? super R> predicate, R arg); }### Answer:
@Test public void testEquals() throws Exception { Predicate<Boolean> f = new RightBoundPredicate<Boolean>(Constant.TRUE, "xyzzy"); assertEquals(f, f); assertObjectsAreEqual(f, new RightBoundPredicate<Boolean>(Constant.TRUE, "xyzzy")); assertObjectsAreNotEqual(f, Constant.TRUE); assertObjectsAreNotEqual(f, new RightBoundPredicate<Boolean>(Constant.FALSE, "xyzzy")); assertObjectsAreNotEqual(f, new RightBoundPredicate<Boolean>(Constant.TRUE, "foo")); assertObjectsAreNotEqual(f, new RightBoundPredicate<Boolean>(Constant.TRUE, null)); assertObjectsAreEqual(new RightBoundPredicate<Boolean>(Constant.TRUE, null), new RightBoundPredicate<Boolean>(Constant.TRUE, null)); assertTrue(!f.equals(null)); }
|
### Question:
RightBoundPredicate implements Predicate<A> { public static <L, R> RightBoundPredicate<L> bind(BinaryPredicate<? super L, ? super R> predicate, R arg) { return null == predicate ? null : new RightBoundPredicate<L>(predicate, arg); } @SuppressWarnings("unchecked") <R> RightBoundPredicate(BinaryPredicate<? super A, ? super R> predicate, R arg); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static RightBoundPredicate<L> bind(BinaryPredicate<? super L, ? super R> predicate, R arg); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(RightBoundPredicate.bind(null, "xyzzy")); }
@Test public void testAdapt() throws Exception { assertNotNull(RightBoundPredicate.bind(Constant.FALSE, "xyzzy")); assertNotNull(RightBoundPredicate.bind(Constant.FALSE, null)); }
|
### Question:
NullaryProcedureNullaryFunction implements NullaryFunction<T> { public T evaluate() { procedure.run(); return null; } NullaryProcedureNullaryFunction(NullaryProcedure procedure); T evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryProcedureNullaryFunction<T> adapt(NullaryProcedure procedure); }### Answer:
@Test public void testEvaluate() throws Exception { NullaryFunction<Object> f = new NullaryProcedureNullaryFunction<Object>(NoOp.INSTANCE); assertNull(f.evaluate()); }
|
### Question:
NullaryProcedureNullaryFunction implements NullaryFunction<T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof NullaryProcedureNullaryFunction<?>)) { return false; } NullaryProcedureNullaryFunction<?> that = (NullaryProcedureNullaryFunction<?>) obj; return this.procedure.equals(that.procedure); } NullaryProcedureNullaryFunction(NullaryProcedure procedure); T evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryProcedureNullaryFunction<T> adapt(NullaryProcedure procedure); }### Answer:
@Test public void testEquals() throws Exception { NullaryFunction<Object> f = new NullaryProcedureNullaryFunction<Object>(NoOp.INSTANCE); assertEquals(f,f); assertObjectsAreEqual(f,new NullaryProcedureNullaryFunction<Object>(NoOp.INSTANCE)); assertObjectsAreNotEqual(f,Constant.of("x")); assertObjectsAreNotEqual(f,new NullaryProcedureNullaryFunction<Object>(new NullaryProcedure() { public void run() { } })); assertObjectsAreNotEqual(f,Constant.of(null)); assertTrue(!f.equals(null)); }
|
### Question:
NullaryProcedureNullaryFunction implements NullaryFunction<T> { public static <T> NullaryProcedureNullaryFunction<T> adapt(NullaryProcedure procedure) { return null == procedure ? null : new NullaryProcedureNullaryFunction<T>(procedure); } NullaryProcedureNullaryFunction(NullaryProcedure procedure); T evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryProcedureNullaryFunction<T> adapt(NullaryProcedure procedure); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(NullaryProcedureNullaryFunction.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(NullaryProcedureNullaryFunction.adapt(new NoOp())); }
|
### Question:
LeftBoundFunction implements Function<A, T> { public T evaluate(A obj) { return function.evaluate(param, obj); } @SuppressWarnings("unchecked") <L> LeftBoundFunction(BinaryFunction<? super L, ? super A, ? extends T> function, L arg); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static LeftBoundFunction<R, T> bind(
BinaryFunction<? super L, ? super R, ? extends T> function, L arg); }### Answer:
@Test public void testEvaluate() throws Exception { Function<Object, Object> f = new LeftBoundFunction<Object, Object>(RightIdentity.FUNCTION,"foo"); assertEquals("xyzzy",f.evaluate("xyzzy")); }
|
### Question:
LeftBoundFunction implements Function<A, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof LeftBoundFunction<?, ?>)) { return false; } LeftBoundFunction<?, ?> that = (LeftBoundFunction<?, ?>) obj; return this.function.equals(that.function) && (null == this.param ? null == that.param : this.param.equals(that.param)); } @SuppressWarnings("unchecked") <L> LeftBoundFunction(BinaryFunction<? super L, ? super A, ? extends T> function, L arg); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static LeftBoundFunction<R, T> bind(
BinaryFunction<? super L, ? super R, ? extends T> function, L arg); }### Answer:
@Test public void testEquals() throws Exception { Function<Object, Object> f = new LeftBoundFunction<Object, Object>(RightIdentity.FUNCTION,"xyzzy"); assertEquals(f,f); assertObjectsAreEqual(f,new LeftBoundFunction<Object, Object>(RightIdentity.FUNCTION,"xyzzy")); assertObjectsAreNotEqual(f,Constant.of("xyzzy")); assertObjectsAreNotEqual(f,new LeftBoundFunction<Object, Object>(LeftIdentity.FUNCTION,"xyzzy")); assertObjectsAreNotEqual(f,new LeftBoundFunction<Object, Object>(RightIdentity.FUNCTION,"bar")); assertObjectsAreNotEqual(f,new LeftBoundFunction<Object, Object>(RightIdentity.FUNCTION,null)); assertObjectsAreEqual(new LeftBoundFunction<Object, Object>(RightIdentity.FUNCTION, null),new LeftBoundFunction<Object, Object>(RightIdentity.FUNCTION, null)); assertTrue(!f.equals(null)); }
|
### Question:
LeftBoundFunction implements Function<A, T> { public static <L, R, T> LeftBoundFunction<R, T> bind( BinaryFunction<? super L, ? super R, ? extends T> function, L arg) { return null == function ? null : new LeftBoundFunction<R, T>(function, arg); } @SuppressWarnings("unchecked") <L> LeftBoundFunction(BinaryFunction<? super L, ? super A, ? extends T> function, L arg); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static LeftBoundFunction<R, T> bind(
BinaryFunction<? super L, ? super R, ? extends T> function, L arg); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(LeftBoundFunction.bind(null,"xyzzy")); }
@Test public void testAdapt() throws Exception { assertNotNull(LeftBoundFunction.bind(RightIdentity.FUNCTION,"xyzzy")); assertNotNull(LeftBoundFunction.bind(RightIdentity.FUNCTION,null)); }
|
### Question:
NullaryFunctionFunction implements Function<A, T> { public T evaluate(A obj) { return function.evaluate(); } NullaryFunctionFunction(NullaryFunction<? extends T> function); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryFunctionFunction<A, T> adapt(NullaryFunction<? extends T> function); }### Answer:
@Test public void testEvaluate() throws Exception { Function<Object, Object> f = new NullaryFunctionFunction<Object, Object>(Constant.of("xyzzy")); assertEquals("xyzzy",f.evaluate(null)); assertEquals("xyzzy",f.evaluate("abc")); }
|
### Question:
NullaryFunctionFunction implements Function<A, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof NullaryFunctionFunction<?, ?>)) { return false; } NullaryFunctionFunction<?, ?> that = (NullaryFunctionFunction<?, ?>) obj; return this.function.equals(that.function); } NullaryFunctionFunction(NullaryFunction<? extends T> function); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryFunctionFunction<A, T> adapt(NullaryFunction<? extends T> function); }### Answer:
@Test public void testEquals() throws Exception { Function<Object, Object> f = new NullaryFunctionFunction<Object, Object>(Constant.of("xyzzy")); assertEquals(f,f); assertObjectsAreEqual(f,new NullaryFunctionFunction<Object, Object>(Constant.of("xyzzy"))); assertObjectsAreNotEqual(f,Constant.of("x")); assertObjectsAreNotEqual(f,new NullaryFunctionFunction<Object, Object>(Constant.of(null))); assertObjectsAreNotEqual(f,Constant.of(null)); assertTrue(!f.equals(null)); }
|
### Question:
NullaryFunctionFunction implements Function<A, T> { public static <A, T> NullaryFunctionFunction<A, T> adapt(NullaryFunction<? extends T> function) { return null == function ? null : new NullaryFunctionFunction<A, T>(function); } NullaryFunctionFunction(NullaryFunction<? extends T> function); T evaluate(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryFunctionFunction<A, T> adapt(NullaryFunction<? extends T> function); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(NullaryFunctionFunction.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(NullaryFunctionFunction.adapt(Constant.of("xyzzy"))); }
|
### Question:
NullaryFunctionNullaryProcedure implements NullaryProcedure { public void run() { function.evaluate(); } NullaryFunctionNullaryProcedure(NullaryFunction<?> function); void run(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryFunctionNullaryProcedure adapt(NullaryFunction<?> function); }### Answer:
@Test public void testRun() throws Exception { class EvaluateCounter implements NullaryFunction<Integer> { int count = 0; public Integer evaluate() { return Integer.valueOf(count++); } } EvaluateCounter counter = new EvaluateCounter(); NullaryProcedure p = new NullaryFunctionNullaryProcedure(counter); assertEquals(0,counter.count); p.run(); assertEquals(1,counter.count); p.run(); assertEquals(2,counter.count); }
|
### Question:
NullaryFunctionNullaryProcedure implements NullaryProcedure { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof NullaryFunctionNullaryProcedure)) { return false; } NullaryFunctionNullaryProcedure that = (NullaryFunctionNullaryProcedure) obj; return this.function.equals(that.function); } NullaryFunctionNullaryProcedure(NullaryFunction<?> function); void run(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryFunctionNullaryProcedure adapt(NullaryFunction<?> function); }### Answer:
@Test public void testEquals() throws Exception { NullaryProcedure p = new NullaryFunctionNullaryProcedure(Constant.of("K")); assertEquals(p,p); assertObjectsAreEqual(p,new NullaryFunctionNullaryProcedure(Constant.of("K"))); assertObjectsAreNotEqual(p,NoOp.INSTANCE); assertObjectsAreNotEqual(p,new NullaryFunctionNullaryProcedure(Constant.of("J"))); assertTrue(!p.equals(null)); }
|
### Question:
NullaryFunctionNullaryProcedure implements NullaryProcedure { public static NullaryFunctionNullaryProcedure adapt(NullaryFunction<?> function) { return null == function ? null : new NullaryFunctionNullaryProcedure(function); } NullaryFunctionNullaryProcedure(NullaryFunction<?> function); void run(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryFunctionNullaryProcedure adapt(NullaryFunction<?> function); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(NullaryFunctionNullaryProcedure.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(NullaryFunctionNullaryProcedure.adapt(Constant.of("K"))); }
|
### Question:
FunctionProcedure implements Procedure<A> { public void run(A obj) { function.evaluate(obj); } FunctionProcedure(Function<? super A, ?> function); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FunctionProcedure<A> adapt(Function<? super A, ?> function); }### Answer:
@Test public void testRun() throws Exception { class EvaluateCounter implements Function<Object, Integer> { int count = 0; public Integer evaluate(Object a) { return Integer.valueOf(count++); } } EvaluateCounter counter = new EvaluateCounter(); Procedure<Object> p = new FunctionProcedure<Object>(counter); assertEquals(0,counter.count); p.run(null); assertEquals(1,counter.count); p.run("x"); assertEquals(2,counter.count); }
|
### Question:
WhileGenerate extends LoopGenerator<E> { public void run(final Procedure<? super E> proc) { getWrappedGenerator().run(new Procedure<E>() { public void run(E obj) { if (!test.test(obj)) { WhileGenerate.this.stop(); } else { proc.run(obj); } } }); } 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 testGenerate() { final List<Integer> numbersMinorThanFive = new ArrayList<Integer>(); whileGenerate.run(new Procedure<Integer>() { public void run( Integer obj ) { numbersMinorThanFive.add(obj); } }); assertEquals(4, numbersMinorThanFive.size()); List<Integer> expected = Arrays.asList(1, 2, 3, 4); assertEquals(expected, numbersMinorThanFive); }
|
### Question:
FunctionProcedure implements Procedure<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof FunctionProcedure<?>)) { return false; } FunctionProcedure<?> that = (FunctionProcedure<?>) obj; return this.function.equals(that.function); } FunctionProcedure(Function<? super A, ?> function); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FunctionProcedure<A> adapt(Function<? super A, ?> function); }### Answer:
@Test public void testEquals() throws Exception { Procedure<Object> p = new FunctionProcedure<Object>(Constant.of("K")); assertEquals(p,p); assertObjectsAreEqual(p,new FunctionProcedure<Object>(Constant.of("K"))); assertObjectsAreNotEqual(p,NoOp.INSTANCE); assertObjectsAreNotEqual(p,new FunctionProcedure<Object>(Constant.of("J"))); assertTrue(!p.equals(null)); }
|
### Question:
FunctionProcedure implements Procedure<A> { public static <A> FunctionProcedure<A> adapt(Function<? super A, ?> function) { return null == function ? null : new FunctionProcedure<A>(function); } FunctionProcedure(Function<? super A, ?> function); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FunctionProcedure<A> adapt(Function<? super A, ?> function); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(FunctionProcedure.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(FunctionProcedure.adapt(Constant.of("K"))); }
|
### Question:
LeftBoundProcedure implements Procedure<A> { public void run(A obj) { procedure.run(param, obj); } @SuppressWarnings("unchecked") <L> LeftBoundProcedure(BinaryProcedure<? super L, ? super A> procedure, L arg); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static LeftBoundProcedure<R> bind(BinaryProcedure<? super L, ? super R> procedure, L arg); }### Answer:
@Test public void testRun() throws Exception { Procedure<Object> p = new LeftBoundProcedure<Object>( new BinaryFunctionBinaryProcedure<Object, Object>(RightIdentity.FUNCTION), "foo"); p.run(Boolean.TRUE); p.run(Boolean.FALSE); }
|
### Question:
LeftBoundProcedure implements Procedure<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof LeftBoundProcedure<?>)) { return false; } LeftBoundProcedure<?> that = (LeftBoundProcedure<?>) obj; return procedure.equals(that.procedure) && (null == param ? null == that.param : param.equals(that.param)); } @SuppressWarnings("unchecked") <L> LeftBoundProcedure(BinaryProcedure<? super L, ? super A> procedure, L arg); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static LeftBoundProcedure<R> bind(BinaryProcedure<? super L, ? super R> procedure, L arg); }### Answer:
@Test public void testEquals() throws Exception { Procedure<Object> f = new LeftBoundProcedure<Object>(NoOp.INSTANCE, "xyzzy"); assertEquals(f, f); assertObjectsAreEqual(f, new LeftBoundProcedure<Object>(NoOp.INSTANCE, "xyzzy")); assertObjectsAreNotEqual(f, new NoOp()); assertObjectsAreNotEqual(f, new LeftBoundProcedure<Object>( new BinaryFunctionBinaryProcedure<Object, Object>(RightIdentity.FUNCTION), "xyzzy")); assertObjectsAreNotEqual(f, new LeftBoundProcedure<Object>(NoOp.INSTANCE, "foo")); assertObjectsAreNotEqual(f, new LeftBoundProcedure<Object>(NoOp.INSTANCE, null)); assertObjectsAreEqual(new LeftBoundProcedure<Object>(NoOp.INSTANCE, null), new LeftBoundProcedure<Object>(NoOp.INSTANCE, null)); assertTrue(!f.equals(null)); }
|
### Question:
LeftBoundProcedure implements Procedure<A> { public static <L, R> LeftBoundProcedure<R> bind(BinaryProcedure<? super L, ? super R> procedure, L arg) { return null == procedure ? null : new LeftBoundProcedure<R>(procedure, arg); } @SuppressWarnings("unchecked") <L> LeftBoundProcedure(BinaryProcedure<? super L, ? super A> procedure, L arg); void run(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static LeftBoundProcedure<R> bind(BinaryProcedure<? super L, ? super R> procedure, L arg); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(LeftBoundProcedure.bind(null,"xyzzy")); }
@Test public void testAdapt() throws Exception { assertNotNull(LeftBoundProcedure.bind(new NoOp(),"xyzzy")); assertNotNull(LeftBoundProcedure.bind(new NoOp(),null)); }
|
### Question:
NullaryPredicateNullaryFunction implements NullaryFunction<Boolean> { public Boolean evaluate() { return Boolean.valueOf(predicate.test()); } NullaryPredicateNullaryFunction(NullaryPredicate predicate); Boolean evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryPredicateNullaryFunction adapt(NullaryPredicate predicate); }### Answer:
@Test public void testTestWhenTrue() throws Exception { NullaryFunction<Boolean> f = new NullaryPredicateNullaryFunction(Constant.TRUE); assertEquals(Boolean.TRUE,f.evaluate()); }
@Test public void testTestWhenFalse() throws Exception { NullaryFunction<Boolean> f = new NullaryPredicateNullaryFunction(Constant.FALSE); assertEquals(Boolean.FALSE,f.evaluate()); }
|
### Question:
NullaryPredicateNullaryFunction implements NullaryFunction<Boolean> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof NullaryPredicateNullaryFunction)) { return false; } NullaryPredicateNullaryFunction that = (NullaryPredicateNullaryFunction) obj; return this.predicate.equals(that.predicate); } NullaryPredicateNullaryFunction(NullaryPredicate predicate); Boolean evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryPredicateNullaryFunction adapt(NullaryPredicate predicate); }### Answer:
@Test public void testEquals() throws Exception { NullaryFunction<Boolean> f = new NullaryPredicateNullaryFunction(Constant.TRUE); assertEquals(f,f); assertObjectsAreEqual(f,new NullaryPredicateNullaryFunction(Constant.TRUE)); assertObjectsAreNotEqual(f,Constant.of("x")); assertObjectsAreNotEqual(f,new NullaryPredicateNullaryFunction(Constant.FALSE)); assertTrue(!f.equals(null)); }
|
### Question:
NullaryPredicateNullaryFunction implements NullaryFunction<Boolean> { public static NullaryPredicateNullaryFunction adapt(NullaryPredicate predicate) { return null == predicate ? null : new NullaryPredicateNullaryFunction(predicate); } NullaryPredicateNullaryFunction(NullaryPredicate predicate); Boolean evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static NullaryPredicateNullaryFunction adapt(NullaryPredicate predicate); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(NullaryPredicateNullaryFunction.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(NullaryPredicateNullaryFunction.adapt(Constant.TRUE)); }
|
### Question:
IgnoreLeftPredicate implements BinaryPredicate<L, R> { public boolean test(L left, R right) { return predicate.test(right); } IgnoreLeftPredicate(Predicate<? super R> predicate); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreLeftPredicate<L, R> adapt(Predicate<? super R> predicate); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryPredicate<Object, Boolean> p = new IgnoreLeftPredicate<Object, Boolean>( new FunctionPredicate<Boolean>(Identity.<Boolean> instance())); assertTrue(p.test(null,Boolean.TRUE)); assertTrue(!p.test(null,Boolean.FALSE)); }
|
### Question:
IgnoreLeftPredicate implements BinaryPredicate<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IgnoreLeftPredicate<?, ?>)) { return false; } IgnoreLeftPredicate<?, ?> that = (IgnoreLeftPredicate<?, ?>) obj; return this.predicate.equals(that.predicate); } IgnoreLeftPredicate(Predicate<? super R> predicate); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreLeftPredicate<L, R> adapt(Predicate<? super R> predicate); }### Answer:
@Test public void testEquals() throws Exception { BinaryPredicate<Object, Boolean> p = new IgnoreLeftPredicate<Object, Boolean>( new FunctionPredicate<Boolean>(Identity.<Boolean> instance())); assertEquals(p,p); assertObjectsAreEqual(p,new IgnoreLeftPredicate<Object, Boolean>( new FunctionPredicate<Boolean>(Identity.<Boolean> instance()))); assertObjectsAreNotEqual(p,Constant.TRUE); assertObjectsAreNotEqual(p,new IgnoreLeftPredicate<Object, Object>(Constant.FALSE)); assertObjectsAreNotEqual(p,Constant.FALSE); assertObjectsAreNotEqual(p,new IgnoreLeftPredicate<Object, Object>(Constant.of(null))); assertObjectsAreEqual(new IgnoreLeftPredicate<Object, Object>(Constant.of(null)),new IgnoreLeftPredicate<Object, Object>(Constant.of(null))); assertTrue(!p.equals(null)); }
|
### Question:
IgnoreLeftPredicate implements BinaryPredicate<L, R> { public static <L, R> IgnoreLeftPredicate<L, R> adapt(Predicate<? super R> predicate) { return null == predicate ? null : new IgnoreLeftPredicate<L, R>(predicate); } IgnoreLeftPredicate(Predicate<? super R> predicate); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreLeftPredicate<L, R> adapt(Predicate<? super R> predicate); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(IgnoreLeftPredicate.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(IgnoreLeftPredicate.adapt(Constant.TRUE)); }
|
### Question:
IgnoreRightPredicate implements BinaryPredicate<L, R> { public boolean test(L left, R right) { return predicate.test(left); } IgnoreRightPredicate(Predicate<? super L> predicate); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreRightPredicate<L, R> adapt(Predicate<? super L> predicate); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryPredicate<Boolean, Object> p = new IgnoreRightPredicate<Boolean, Object>( new FunctionPredicate<Boolean>(Identity.<Boolean> instance())); assertTrue(p.test(Boolean.TRUE,null)); assertTrue(!p.test(Boolean.FALSE,null)); }
|
### Question:
IgnoreRightPredicate implements BinaryPredicate<L, R> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IgnoreRightPredicate<?, ?>)) { return false; } IgnoreRightPredicate<?, ?> that = (IgnoreRightPredicate<?, ?>) obj; return this.predicate.equals(that.predicate); } IgnoreRightPredicate(Predicate<? super L> predicate); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreRightPredicate<L, R> adapt(Predicate<? super L> predicate); }### Answer:
@Test public void testEquals() throws Exception { BinaryPredicate<Boolean, Object> p = new IgnoreRightPredicate<Boolean, Object>( new FunctionPredicate<Boolean>(Identity.<Boolean> instance())); assertEquals(p,p); assertObjectsAreEqual(p,new IgnoreRightPredicate<Boolean, Object>( new FunctionPredicate<Boolean>(Identity.<Boolean> instance()))); assertObjectsAreNotEqual(p,Constant.TRUE); assertObjectsAreNotEqual(p,new IgnoreRightPredicate<Boolean, Object>(Constant.FALSE)); assertObjectsAreNotEqual(p,Constant.FALSE); assertTrue(!p.equals(null)); }
|
### Question:
IgnoreRightPredicate implements BinaryPredicate<L, R> { public static <L, R> IgnoreRightPredicate<L, R> adapt(Predicate<? super L> predicate) { return null == predicate ? null : new IgnoreRightPredicate<L, R>(predicate); } IgnoreRightPredicate(Predicate<? super L> predicate); boolean test(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreRightPredicate<L, R> adapt(Predicate<? super L> predicate); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(IgnoreRightPredicate.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(IgnoreRightPredicate.adapt(Constant.TRUE)); }
|
### Question:
BoundNullaryFunction implements NullaryFunction<T> { public T evaluate() { return function.evaluate(arg); } @SuppressWarnings("unchecked") <A> BoundNullaryFunction(Function<? super A, ? extends T> function, A arg); T evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BoundNullaryFunction<T> bind(Function<? super A, ? extends T> function, A arg); }### Answer:
@Test public void testEvaluate() throws Exception { NullaryFunction<Object> f = new BoundNullaryFunction<Object>(Identity.INSTANCE,"xyzzy"); assertEquals("xyzzy",f.evaluate()); }
|
### Question:
BoundNullaryFunction implements NullaryFunction<T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BoundNullaryFunction<?>)) { return false; } BoundNullaryFunction<?> that = (BoundNullaryFunction<?>) obj; if (!(that.function.equals(this.function))) { return false; } return that.arg == this.arg || that.arg != null && that.arg.equals(this.arg); } @SuppressWarnings("unchecked") <A> BoundNullaryFunction(Function<? super A, ? extends T> function, A arg); T evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BoundNullaryFunction<T> bind(Function<? super A, ? extends T> function, A arg); }### Answer:
@Test public void testEquals() throws Exception { NullaryFunction<Object> f = new BoundNullaryFunction<Object>(Identity.INSTANCE,"xyzzy"); assertEquals(f,f); assertObjectsAreEqual(f,new BoundNullaryFunction<Object>(Identity.INSTANCE,"xyzzy")); assertObjectsAreNotEqual(f,Constant.of("xyzzy")); assertObjectsAreNotEqual(f,new BoundNullaryFunction<Object>(Identity.INSTANCE,"foo")); assertObjectsAreNotEqual(f,new BoundNullaryFunction<Object>(Constant.of("xyzzy"),"foo")); assertObjectsAreNotEqual(f,new BoundNullaryFunction<Object>(Identity.INSTANCE,null)); assertTrue(!f.equals(null)); }
|
### Question:
BoundNullaryFunction implements NullaryFunction<T> { public static <A, T> BoundNullaryFunction<T> bind(Function<? super A, ? extends T> function, A arg) { return null == function ? null : new BoundNullaryFunction<T>(function, arg); } @SuppressWarnings("unchecked") <A> BoundNullaryFunction(Function<? super A, ? extends T> function, A arg); T evaluate(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BoundNullaryFunction<T> bind(Function<? super A, ? extends T> function, A arg); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(BoundNullaryFunction.bind(null,"xyzzy")); }
@Test public void testAdapt() throws Exception { assertNotNull(BoundNullaryFunction.bind(Identity.INSTANCE,"xyzzy")); assertNotNull(BoundNullaryFunction.bind(Identity.INSTANCE,null)); }
|
### Question:
FunctionPredicate implements Predicate<A> { public boolean test(A obj) { return function.evaluate(obj).booleanValue(); } FunctionPredicate(Function<? super A, Boolean> function); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FunctionPredicate<A> adapt(Function<? super A, Boolean> function); }### Answer:
@Test public void testTestWhenTrue() throws Exception { Predicate<Object> p = new FunctionPredicate<Object>(Constant.TRUE); assertTrue(p.test(null)); }
@Test public void testTestWhenFalse() throws Exception { Predicate<Object> p = new FunctionPredicate<Object>(Constant.FALSE); assertTrue(!p.test(null)); }
|
### Question:
FunctionPredicate implements Predicate<A> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof FunctionPredicate<?>)) { return false; } FunctionPredicate<?> that = (FunctionPredicate<?>) obj; return this.function.equals(that.function); } FunctionPredicate(Function<? super A, Boolean> function); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FunctionPredicate<A> adapt(Function<? super A, Boolean> function); }### Answer:
@Test public void testEquals() throws Exception { Predicate<Object> p = new FunctionPredicate<Object>(Constant.TRUE); assertEquals(p,p); assertObjectsAreEqual(p,new FunctionPredicate<Object>(Constant.TRUE)); assertObjectsAreNotEqual(p,Constant.TRUE); assertObjectsAreNotEqual(p,new FunctionPredicate<Object>(Constant.FALSE)); assertTrue(!p.equals(null)); }
|
### Question:
FunctionPredicate implements Predicate<A> { public static <A> FunctionPredicate<A> adapt(Function<? super A, Boolean> function) { return null == function ? null : new FunctionPredicate<A>(function); } FunctionPredicate(Function<? super A, Boolean> function); boolean test(A obj); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FunctionPredicate<A> adapt(Function<? super A, Boolean> function); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(FunctionPredicate.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(FunctionPredicate.adapt(Constant.TRUE)); }
|
### Question:
BinaryPredicateBinaryFunction implements BinaryFunction<L, R, Boolean> { public Boolean evaluate(L left, R right) { return predicate.test(left, right) ? Boolean.TRUE : Boolean.FALSE; } BinaryPredicateBinaryFunction(BinaryPredicate<? super L, ? super R> predicate); Boolean evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryPredicateBinaryFunction<L, R> adapt(BinaryPredicate<? super L, ? super R> predicate); }### Answer:
@Test public void testTestWhenTrue() throws Exception { BinaryFunction<Object, Object, Boolean> f = new BinaryPredicateBinaryFunction<Object, Object>(Constant.TRUE); assertEquals(Boolean.TRUE, f.evaluate(null,null)); }
@Test public void testTestWhenFalse() throws Exception { BinaryFunction<Object, Object, Boolean> f = new BinaryPredicateBinaryFunction<Object, Object>(Constant.FALSE); assertEquals(Boolean.FALSE, f.evaluate(null,null)); }
|
### Question:
BinaryPredicateBinaryFunction implements BinaryFunction<L, R, Boolean> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof BinaryPredicateBinaryFunction<?, ?>)) { return false; } BinaryPredicateBinaryFunction<?, ?> that = (BinaryPredicateBinaryFunction<?, ?>) obj; return this.predicate.equals(that.predicate); } BinaryPredicateBinaryFunction(BinaryPredicate<? super L, ? super R> predicate); Boolean evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryPredicateBinaryFunction<L, R> adapt(BinaryPredicate<? super L, ? super R> predicate); }### Answer:
@Test public void testEquals() throws Exception { BinaryFunction<Object, Object, Boolean> f = new BinaryPredicateBinaryFunction<Object, Object>(Constant.TRUE); assertEquals(f,f); assertObjectsAreEqual(f,new BinaryPredicateBinaryFunction<Object, Object>(Constant.TRUE)); assertObjectsAreNotEqual(f,Constant.of("x")); assertObjectsAreNotEqual(f,new BinaryPredicateBinaryFunction<Object, Object>(Constant.FALSE)); assertTrue(!f.equals(null)); }
|
### Question:
BinaryPredicateBinaryFunction implements BinaryFunction<L, R, Boolean> { public static <L, R> BinaryPredicateBinaryFunction<L, R> adapt(BinaryPredicate<? super L, ? super R> predicate) { return null == predicate ? null : new BinaryPredicateBinaryFunction<L, R>(predicate); } BinaryPredicateBinaryFunction(BinaryPredicate<? super L, ? super R> predicate); Boolean evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static BinaryPredicateBinaryFunction<L, R> adapt(BinaryPredicate<? super L, ? super R> predicate); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(BinaryPredicateBinaryFunction.adapt(null)); }
@Test public void testAdapt() throws Exception { assertNotNull(BinaryPredicateBinaryFunction.adapt(Constant.TRUE)); }
|
### Question:
FullyBoundNullaryProcedure implements NullaryProcedure { public void run() { procedure.run(left, right); } @SuppressWarnings("unchecked") <L, R> FullyBoundNullaryProcedure(BinaryProcedure<? super L, ? super R> procedure, L left, R right); void run(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FullyBoundNullaryProcedure bind(
BinaryProcedure<? super L, ? super R> procedure, L left, R right); }### Answer:
@Test public void testRun() throws Exception { NullaryProcedure p = new FullyBoundNullaryProcedure(new BinaryFunctionBinaryProcedure<Object, Object>( RightIdentity.FUNCTION), "foo", null); p.run(); }
|
### Question:
FullyBoundNullaryProcedure implements NullaryProcedure { public static <L, R> FullyBoundNullaryProcedure bind( BinaryProcedure<? super L, ? super R> procedure, L left, R right) { return null == procedure ? null : new FullyBoundNullaryProcedure(procedure, left, right); } @SuppressWarnings("unchecked") <L, R> FullyBoundNullaryProcedure(BinaryProcedure<? super L, ? super R> procedure, L left, R right); void run(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static FullyBoundNullaryProcedure bind(
BinaryProcedure<? super L, ? super R> procedure, L left, R right); }### Answer:
@Test public void testAdaptNull() throws Exception { assertNull(FullyBoundNullaryProcedure.bind(null, "xyzzy", null)); }
@Test public void testAdapt() throws Exception { assertNotNull(FullyBoundNullaryProcedure.bind(new NoOp(), "xyzzy", "foobar")); assertNotNull(FullyBoundNullaryProcedure.bind(new NoOp(), null, null)); }
|
### Question:
IgnoreRightFunction implements BinaryFunction<L, R, T> { public T evaluate(L left, R right) { return function.evaluate(left); } IgnoreRightFunction(Function<? super L, ? extends T> function); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreRightFunction<L, R, T> adapt(Function<? super L, ? extends T> function); }### Answer:
@Test public void testEvaluate() throws Exception { BinaryFunction<String, String, String> f = new IgnoreRightFunction<String, String, String>(new Identity<String>()); assertNull(f.evaluate(null,null)); assertNull(f.evaluate(null,"xyzzy")); assertEquals("xyzzy",f.evaluate("xyzzy",null)); assertEquals("xyzzy",f.evaluate("xyzzy","abc")); }
|
### Question:
IgnoreRightFunction implements BinaryFunction<L, R, T> { @Override public boolean equals(Object obj) { if (obj == this) { return true; } if (!(obj instanceof IgnoreRightFunction<?, ?, ?>)) { return false; } IgnoreRightFunction<?, ?, ?> that = (IgnoreRightFunction<?, ?, ?>) obj; return this.function.equals(that.function); } IgnoreRightFunction(Function<? super L, ? extends T> function); T evaluate(L left, R right); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); static IgnoreRightFunction<L, R, T> adapt(Function<? super L, ? extends T> function); }### Answer:
@Test public void testEquals() throws Exception { BinaryFunction<String, String, String> f = new IgnoreRightFunction<String, String, String>(Constant.of("xyzzy")); assertEquals(f,f); assertObjectsAreEqual(f,new IgnoreRightFunction<String, String, String>(Constant.of("xyzzy"))); assertObjectsAreNotEqual(f,Constant.of("x")); assertObjectsAreNotEqual(f,new IgnoreRightFunction<String, String, String>(Constant.<String>of(null))); assertObjectsAreNotEqual(f,Constant.of(null)); assertObjectsAreEqual(new IgnoreRightFunction<String, String, String>(Constant.<String>of(null)),new IgnoreRightFunction<String, String, String>(Constant.<String>of(null))); assertTrue(!f.equals(null)); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.