/*
* Copyright (C) 2012 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.common.testing.anotherpackage;
import static com.google.common.truth.Truth.assertThat;
import com.google.common.base.Equivalence;
import com.google.common.base.Function;
import com.google.common.base.Functions;
import com.google.common.base.Joiner;
import com.google.common.base.Predicate;
import com.google.common.collect.Ordering;
import com.google.common.primitives.UnsignedInteger;
import com.google.common.primitives.UnsignedLong;
import com.google.common.testing.ForwardingWrapperTester;
import com.google.common.testing.NullPointerTester;
import junit.framework.TestCase;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.concurrent.TimeUnit;
import java.util.regex.Pattern;
/**
* Tests for {@link ForwardingWrapperTester}. Live in a different package to detect reflection
* access issues, if any.
*
* @author Ben Yu
*/
public class ForwardingWrapperTesterTest extends TestCase {
private final ForwardingWrapperTester tester = new ForwardingWrapperTester();
public void testGoodForwarder() {
tester.testForwarding(Arithmetic.class,
new Function<Arithmetic, Arithmetic>() {
@Override public Arithmetic apply(Arithmetic arithmetic) {
return new ForwardingArithmetic(arithmetic);
}
});
tester.testForwarding(ParameterTypesDifferent.class,
new Function<ParameterTypesDifferent, ParameterTypesDifferent>() {
@Override public ParameterTypesDifferent apply(ParameterTypesDifferent delegate) {
return new ParameterTypesDifferentForwarder(delegate);
}
});
}
public void testVoidMethodForwarding() {
tester.testForwarding(Runnable.class,
new Function<Runnable, Runnable>() {
@Override public Runnable apply(final Runnable runnable) {
return new ForwardingRunnable(runnable);
}
});
}
public void testToStringForwarding() {
tester.testForwarding(Runnable.class,
new Function<Runnable, Runnable>() {
@Override public Runnable apply(final Runnable runnable) {
return new ForwardingRunnable(runnable) {
@Override public String toString() {
return runnable.toString();
}
};
}
});
}
public void testFailsToForwardToString() {
assertFailure(Runnable.class, new Function<Runnable, Runnable>() {
@Override public Runnable apply(final Runnable runnable) {
return new ForwardingRunnable(runnable) {
@Override public String toString() {
return "";
}
};
}
}, "toString()");
}
public void testFailsToForwardHashCode() {
tester.includingEquals();
assertFailure(Runnable.class, new Function<Runnable, Runnable>() {
@Override public Runnable apply(final Runnable runnable) {
return new ForwardingRunnable(runnable) {
@Override public boolean equals(Object o) {
if (o instanceof ForwardingRunnable) {
ForwardingRunnable that = (ForwardingRunnable) o;
return runnable.equals(that.runnable);
}
return false;
}
};
}
}, "Runnable");
}
public void testEqualsAndHashCodeForwarded() {
tester.includingEquals();
tester.testForwarding(Runnable.class, new Function<Runnable, Runnable>() {
@Override public Runnable apply(final Runnable runnable) {
return new ForwardingRunnable(runnable) {
@Override public boolean equals(Object o) {
if (o instanceof ForwardingRunnable) {
ForwardingRunnable that = (ForwardingRunnable) o;
return runnable.equals(that.runnable);
}
return false;
}
@Override public int hashCode() {
return runnable.hashCode();
}
};
}
});
}
public void testFailsToForwardEquals() {
tester.includingEquals();
assertFailure(Runnable.class, new Function<Runnable, Runnable>() {
@Override public Runnable apply(final Runnable runnable) {
return new ForwardingRunnable(runnable) {
@Override public int hashCode() {
return runnable.hashCode();
}
};
}
}, "Runnable");
}
public void testFailsToForward() {
assertFailure(Runnable.class,
new Function<Runnable, Runnable>() {
@Override public Runnable apply(Runnable runnable) {
return new ForwardingRunnable(runnable) {
@Override public void run() {}
};
}
}, "run()", "Failed to forward");
}
public void testRedundantForwarding() {
assertFailure(Runnable.class,
new Function<Runnable, Runnable>() {
@Override public Runnable apply(final Runnable runnable) {
return new Runnable() {
@Override public void run() {
runnable.run();
runnable.run();
}
};
}
}, "run()", "invoked more than once");
}
public void testFailsToForwardParameters() {
assertFailure(Adder.class, new Function<Adder, Adder>() {
@Override public Adder apply(Adder adder) {
return new FailsToForwardParameters(adder);
}
}, "add(", "Parameter #0");
}
public void testForwardsToTheWrongMethod() {
assertFailure(Arithmetic.class, new Function<Arithmetic, Arithmetic>() {
@Override public Arithmetic apply(Arithmetic adder) {
return new ForwardsToTheWrongMethod(adder);
}
}, "minus");
}
public void testFailsToForwardReturnValue() {
assertFailure(Adder.class, new Function<Adder, Adder>() {
@Override public Adder apply(Adder adder) {
return new FailsToForwardReturnValue(adder);
}
}, "add(", "Return value");
}
public void testFailsToPropagateException() {
assertFailure(Adder.class, new Function<Adder, Adder>() {
@Override public Adder apply(Adder adder) {
return new FailsToPropagageException(adder);
}
}, "add(", "exception");
}
public void testNotInterfaceType() {
try {
new ForwardingWrapperTester().testForwarding(String.class, Functions.<String>identity());
fail();
} catch (IllegalArgumentException expected) {}
}
public void testNulls() {
new NullPointerTester()
.setDefault(Class.class, Runnable.class)
.testAllPublicInstanceMethods(new ForwardingWrapperTester());
}
private <T> void assertFailure(
Class<T> interfaceType, Function<T, ? extends T> wrapperFunction,
String... expectedMessages) {
try {
tester.testForwarding(interfaceType, wrapperFunction);
} catch (AssertionError expected) {
for (String message : expectedMessages) {
assertThat(expected.getMessage()).contains(message);
}
return;
}
fail("expected failure not reported");
}
private class ForwardingRunnable implements Runnable {
private final Runnable runnable;
ForwardingRunnable(Runnable runnable) {
this.runnable = runnable;
}
@Override public void run() {
runnable.run();
}
@Override public String toString() {
return runnable.toString();
}
}
private interface Adder {
int add(int a, int b);
}
private static class ForwardingArithmetic implements Arithmetic {
private final Arithmetic arithmetic;
public ForwardingArithmetic(Arithmetic arithmetic) {
this.arithmetic = arithmetic;
}
@Override public int add(int a, int b) {
return arithmetic.add(a, b);
}
@Override public int minus(int a, int b) {
return arithmetic.minus(a, b);
}
@Override public String toString() {
return arithmetic.toString();
}
}
private static class FailsToForwardParameters implements Adder {
private final Adder adder;
FailsToForwardParameters(Adder adder) {
this.adder = adder;
}
@Override public int add(int a, int b) {
return adder.add(b, a);
}
@Override public String toString() {
return adder.toString();
}
}
private static class FailsToForwardReturnValue implements Adder {
private final Adder adder;
FailsToForwardReturnValue(Adder adder) {
this.adder = adder;
}
@Override public int add(int a, int b) {
return adder.add(a, b) + 1;
}
@Override public String toString() {
return adder.toString();
}
}
private static class FailsToPropagageException implements Adder {
private final Adder adder;
FailsToPropagageException(Adder adder) {
this.adder = adder;
}
@Override public int add(int a, int b) {
try {
return adder.add(a, b);
} catch (Exception e) {
// swallow!
return 0;
}
}
@Override public String toString() {
return adder.toString();
}
}
public interface Arithmetic extends Adder {
int minus(int a, int b);
}
private static class ForwardsToTheWrongMethod implements Arithmetic {
private final Arithmetic arithmetic;
ForwardsToTheWrongMethod(Arithmetic arithmetic) {
this.arithmetic = arithmetic;
}
@Override public int minus(int a, int b) { // bad!
return arithmetic.add(b, a);
}
@Override public int add(int a, int b) {
return arithmetic.add(b, a);
}
@Override public String toString() {
return arithmetic.toString();
}
}
private interface ParameterTypesDifferent {
void foo(String s, Runnable r, Number n, Iterable<?> it, boolean b, Equivalence<String> eq,
Exception e, InputStream in, Comparable<?> c, Ordering<Integer> ord,
Charset charset, TimeUnit unit, Class<?> cls, Joiner joiner,
Pattern pattern, UnsignedInteger ui, UnsignedLong ul, StringBuilder sb,
Predicate<?> pred, Function<?, ?> func, Object obj);
}
private static class ParameterTypesDifferentForwarder implements ParameterTypesDifferent {
private final ParameterTypesDifferent delegate;
public ParameterTypesDifferentForwarder(ParameterTypesDifferent delegate) {
this.delegate = delegate;
}
@Override public void foo(
String s, Runnable r, Number n, Iterable<?> it, boolean b, Equivalence<String> eq,
Exception e, InputStream in, Comparable<?> c, Ordering<Integer> ord,
Charset charset, TimeUnit unit, Class<?> cls, Joiner joiner,
Pattern pattern, UnsignedInteger ui, UnsignedLong ul, StringBuilder sb,
Predicate<?> pred, Function<?, ?> func, Object obj) {
delegate.foo(s,
r, n, it, b, eq, e, in, c, ord, charset, unit, cls, joiner, pattern,
ui, ul, sb, pred, func, obj);
}
@Override public String toString() {
return delegate.toString();
}
}
public void testCovariantReturn() {
new ForwardingWrapperTester().testForwarding(Sub.class, new Function<Sub, Sub>() {
@Override public Sub apply(Sub sub) {
return new ForwardingSub(sub);
}
});
}
interface Base {
CharSequence getId();
}
interface Sub extends Base {
@Override String getId();
}
private static class ForwardingSub implements Sub {
private final Sub delegate;
ForwardingSub(Sub delegate) {
this.delegate = delegate;
}
@Override public String getId() {
return delegate.getId();
}
@Override public String toString() {
return delegate.toString();
}
}
private interface Equals {
@Override boolean equals(Object obj);
@Override int hashCode();
@Override String toString();
}
private static class NoDelegateToEquals implements Equals {
private static Function<Equals, Equals> WRAPPER = new Function<Equals, Equals>() {
@Override public NoDelegateToEquals apply(Equals delegate) {
return new NoDelegateToEquals(delegate);
}
};
private final Equals delegate;
NoDelegateToEquals(Equals delegate) {
this.delegate = delegate;
}
@Override public String toString() {
return delegate.toString();
}
}
public void testExplicitEqualsAndHashCodeNotDelegatedByDefault() {
new ForwardingWrapperTester()
.testForwarding(Equals.class, NoDelegateToEquals.WRAPPER);
}
public void testExplicitEqualsAndHashCodeDelegatedWhenExplicitlyAsked() {
try {
new ForwardingWrapperTester()
.includingEquals()
.testForwarding(Equals.class, NoDelegateToEquals.WRAPPER);
} catch (AssertionError expected) {
return;
}
fail("Should have failed");
}
/**
* An interface for the 2 ways that a chaining call might be defined.
*/
private interface ChainingCalls {
// A method that is defined to 'return this'
ChainingCalls chainingCall();
// A method that just happens to return a ChainingCalls object
ChainingCalls nonChainingCall();
}
private static class ForwardingChainingCalls implements ChainingCalls {
final ChainingCalls delegate;
ForwardingChainingCalls(ChainingCalls delegate) {
this.delegate = delegate;
}
@Override public ForwardingChainingCalls chainingCall() {
delegate.chainingCall();
return this;
}
@Override public ChainingCalls nonChainingCall() {
return delegate.nonChainingCall();
}
@Override public String toString() {
return delegate.toString();
}
}
public void testChainingCalls() {
tester.testForwarding(ChainingCalls.class,
new Function<ChainingCalls, ChainingCalls>() {
@Override public ChainingCalls apply(ChainingCalls delegate) {
return new ForwardingChainingCalls(delegate);
}
});
}
}