Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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 org.truth0.Truth.ASSERT;
 
 
 
Tests for com.google.common.testing.ForwardingWrapperTester. Live in a different package to detect reflection access issues, if any.

Author(s):
Ben Yu
 
 public class ForwardingWrapperTesterTest extends TestCase {
 
   private final ForwardingWrapperTester tester = new ForwardingWrapperTester();
 
   public void testGoodForwarder() {
         new Function<ArithmeticArithmetic>() {
           @Override public Arithmetic apply(Arithmetic arithmetic) {
             return new ForwardingArithmetic(arithmetic);
           }
         });
           @Override public ParameterTypesDifferent apply(ParameterTypesDifferent delegate) {
             return new ParameterTypesDifferentForwarder(delegate);
           }
         });
   }
 
   public void testVoidMethodForwarding() {
         new Function<RunnableRunnable>() {
           @Override public Runnable apply(final Runnable runnable) {
             return new ForwardingRunnable(runnable);
           }
         });
   }
 
   public void testToStringForwarding() {
         new Function<RunnableRunnable>() {
           @Override public Runnable apply(final Runnable runnable) {
             return new ForwardingRunnable(runnable) {
               @Override public String toString() {
                 return runnable.toString();
               }
             };
           }
         });
   }
 
   public void testFailsToForwardToString() {
     assertFailure(Runnable.classnew Function<RunnableRunnable>() {
       @Override public Runnable apply(final Runnable runnable) {
         return new ForwardingRunnable(runnable) {
           @Override public String toString() {
             return "";
           }
         };
       }
     }, "toString()");
   }
 
   public void testFailsToForwardHashCode() {
    assertFailure(Runnable.classnew Function<RunnableRunnable>() {
      @Override public Runnable apply(final Runnable runnable) {
        return new ForwardingRunnable(runnable) {
          @Override public boolean equals(Object o) {
            if (o instanceof ForwardingRunnable) {
              ForwardingRunnable that = (ForwardingRunnableo;
              return runnable.equals(that.runnable);
            }
            return false;
          }
        };
      }
    }, "Runnable");
  }
  public void testEqualsAndHashCodeForwarded() {
      @Override public Runnable apply(final Runnable runnable) {
        return new ForwardingRunnable(runnable) {
          @Override public boolean equals(Object o) {
            if (o instanceof ForwardingRunnable) {
              ForwardingRunnable that = (ForwardingRunnableo;
              return runnable.equals(that.runnable);
            }
            return false;
          }
          @Override public int hashCode() {
            return runnable.hashCode();
          }
        };
      }
    });
  }
  public void testFailsToForwardEquals() {
    assertFailure(Runnable.classnew Function<RunnableRunnable>() {
      @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<RunnableRunnable>() {
          @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<RunnableRunnable>() {
          @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.classnew Function<AdderAdder>() {
      @Override public Adder apply(Adder adder) {
        return new FailsToForwardParameters(adder);
      }
    }, "add(""Parameter #0");
  }
  public void testForwardsToTheWrongMethod() {
      @Override public Arithmetic apply(Arithmetic adder) {
        return new ForwardsToTheWrongMethod(adder);
      }
    }, "minus");
  }
  public void testFailsToForwardReturnValue() {
    assertFailure(Adder.classnew Function<AdderAdder>() {
      @Override public Adder apply(Adder adder) {
        return new FailsToForwardReturnValue(adder);
      }
    }, "add(""Return value");
  }
  public void testFailsToPropagateException() {
    assertFailure(Adder.classnew Function<AdderAdder>() {
      @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.classRunnable.class)
  }
  private <T> void assertFailure(
      Class<T> interfaceTypeFunction<T, ? extends T> wrapperFunction,
      String... expectedMessages) {
    try {
      .testForwarding(interfaceTypewrapperFunction);
    } catch (AssertionError expected) {
      for (String message : expectedMessages) {
        .that(expected.getMessage()).contains(message);
      }
      return;
    }
    fail("expected failure not reported");
  }
  private class ForwardingRunnable implements Runnable {
    private final Runnable runnable;
    ForwardingRunnable(Runnable runnable) {
      this. = runnable;
    }
    @Override public void run() {
      .run();
    }
    @Override public String toString() {
      return .toString();
    }
  }
  private interface Adder {
    int add(int aint b);
  }
  private static class ForwardingArithmetic implements Arithmetic {
    private final Arithmetic arithmetic;
    public ForwardingArithmetic(Arithmetic arithmetic) {
      this. = arithmetic;
    }
    @Override public int add(int aint b) {
      return .add(ab);
    }
    @Override public int minus(int aint b) {
      return .minus(ab);
    }
    @Override public String toString() {
      return .toString();
    }
  }
  private static class FailsToForwardParameters implements Adder {
    private final Adder adder;
      this. = adder;
    }
    @Override public int add(int aint b) {
      return .add(ba);
    }
    @Override public String toString() {
      return .toString();
    }
  }
  private static class FailsToForwardReturnValue implements Adder {
    private final Adder adder;
      this. = adder;
    }
    @Override public int add(int aint b) {
      return .add(ab) + 1;
    }
    @Override public String toString() {
      return .toString();
    }
  }
  private static class FailsToPropagageException implements Adder {
    private final Adder adder;
      this. = adder;
    }
    @Override public int add(int aint b) {
      try {
        return .add(ab);
      } catch (Exception e) {
        // swallow!
        return 0;
      }
    }
    @Override public String toString() {
      return .toString();
    }
  }
  public interface Arithmetic extends Adder {
    int minus(int aint b);
  }
  private static class ForwardsToTheWrongMethod implements Arithmetic {
    private final Arithmetic arithmetic;
    ForwardsToTheWrongMethod(Arithmetic arithmetic) {
      this. = arithmetic;
    }
    @Override public int minus(int aint b) { // bad!
      return .add(ba);
    }
    @Override public int add(int aint b) {
      return .add(ba);
    }
    @Override public String toString() {
      return .toString();
    }
  }
  private interface ParameterTypesDifferent {
    void foo(String sRunnable rNumber nIterable<?> itboolean bEquivalence<Stringeq,
        Exception eInputStream inComparable<?> cOrdering<Integerord
        Charset charsetTimeUnit unitClass<?> clsJoiner joiner,
        Pattern patternUnsignedInteger uiUnsignedLong ulStringBuilder sb,
        Predicate<?> predFunction<?, ?> funcObject obj);
  }
  private static class ParameterTypesDifferentForwarder implements ParameterTypesDifferent {
    private final ParameterTypesDifferent delegate;
      this. = delegate;
    }
    @Override public void foo(
        String sRunnable rNumber nIterable<?> itboolean bEquivalence<Stringeq,
        Exception eInputStream inComparable<?> cOrdering<Integerord
        Charset charsetTimeUnit unitClass<?> clsJoiner joiner,
        Pattern patternUnsignedInteger uiUnsignedLong ulStringBuilder sb,
        Predicate<?> predFunction<?, ?> funcObject obj) {
      .foo(s,
          rnitbeqeincordcharsetunitclsjoinerpattern,
          uiulsbpredfuncobj);
    }
    @Override public String toString() {
      return .toString();
    }
  }
  public void testCovariantReturn() {
    new ForwardingWrapperTester().testForwarding(Sub.classnew Function<SubSub>() {
      @Override public Sub apply(Sub sub) {
        return new ForwardingSub(sub);
      }
    });
  }
  interface Base {
  }
  interface Sub extends Base {
    @Override String getId();
  }
  private static class ForwardingSub implements Sub {
    private final Sub delegate;
    ForwardingSub(Sub delegate) {
      this. = delegate;
    }
    @Override public String getId() {
      return .getId();
    }
    @Override public String toString() {
      return .toString();
    }
  }
  private interface Equals {
    @Override boolean equals(Object obj);
    @Override int hashCode();
  }
  private static class NoDelegateToEquals implements Equals {
    private static Function<EqualsEqualsWRAPPER = new Function<EqualsEquals>() {
      @Override public NoDelegateToEquals apply(Equals delegate) {
        return new NoDelegateToEquals(delegate);
      }
    };
    private final Equals delegate;
    NoDelegateToEquals(Equals delegate) {
      this. = delegate;
    }
    @Override public String toString() {
      return .toString();
    }
  }
  }
    try {
      new ForwardingWrapperTester()
          .includingEquals()
          .testForwarding(Equals.class.);
    } 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'
    // A method that just happens to return a ChainingCalls object
  }
  private static class ForwardingChainingCalls implements ChainingCalls {
    final ChainingCalls delegate;
      this. = delegate;
    }
      .chainingCall();
      return this;
    }
    @Override public ChainingCalls nonChainingCall() {
      return .nonChainingCall();
    }
    @Override public String toString() {
      return .toString();
    }
  }
  public void testChainingCalls() {
        new Function<ChainingCallsChainingCalls>() {
          @Override public ChainingCalls apply(ChainingCalls delegate) {
            return new ForwardingChainingCalls(delegate);
          }
        });
  }
New to GrepCode? Check out our FAQ X