/*
    * 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;
  
  import static com.google.common.base.Preconditions.checkNotNull;
  import static com.google.common.truth.Truth.assertThat;
  
  import com.google.common.base.Functions;
  import com.google.common.base.Optional;
  import com.google.common.collect.ImmutableList;
  import com.google.common.testing.ClassSanityTester.FactoryMethodReturnsNullException;
  import com.google.common.testing.ClassSanityTester.ParameterHasNoDistinctValueException;
  import com.google.common.testing.ClassSanityTester.ParameterNotInstantiableException;
  import com.google.common.testing.NullPointerTester.Visibility;
  
  import junit.framework.AssertionFailedError;
  import junit.framework.TestCase;
  
  import java.io.Serializable;
  import java.lang.reflect.InvocationTargetException;
  import java.util.AbstractList;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Set;
  import java.util.concurrent.TimeUnit;
  
  import javax.annotation.Nullable;
  
  /**
   * Unit tests for {@link ClassSanityTester}.
   *
   * @author Ben Yu
   */
  public class ClassSanityTesterTest extends TestCase {
  
    private final ClassSanityTester tester = new ClassSanityTester();
  
    public void testEqualsOnReturnValues_good() throws Exception {
      tester.forAllPublicStaticMethods(GoodEqualsFactory.class).testEquals();
    }
  
    public static class GoodEqualsFactory {
      public static Object good(String a, int b,
          // oneConstantOnly doesn't matter since it's not nullable and can be only 1 value.
          @SuppressWarnings("unused") OneConstantEnum oneConstantOnly,
          // noConstant doesn't matter since it can only be null
          @SuppressWarnings("unused") @Nullable NoConstantEnum noConstant) {
        return new GoodEquals(a, b);
      }
      // instance method ignored
      public Object badIgnored() {
        return new BadEquals();
      }
      // primitive ignored
      public int returnsInt() {
        throw new UnsupportedOperationException();
      }
      // void ignored
      public void voidMethod() {
        throw new UnsupportedOperationException();
      }
      // non-public method ignored
      static Object badButNotPublic() {
        return new BadEquals();
      }
    }
  
    public void testForAllPublicStaticMethods_noPublicStaticMethods() throws Exception {
      try {
        tester.forAllPublicStaticMethods(NoPublicStaticMethods.class).testEquals();
      } catch (AssertionFailedError expected) {
        assertEquals(
            "No public static methods that return java.lang.Object or subtype are found in "
                + NoPublicStaticMethods.class + ".",
            expected.getMessage());
        return;
      }
      fail();
    }
  
    public void testEqualsOnReturnValues_bad() throws Exception {
      try {
        tester.forAllPublicStaticMethods(BadEqualsFactory.class).testEquals();
      } catch (AssertionFailedError expected) {
        return;
     }
     fail();
   }
 
   private static class BadEqualsFactory {
     /** oneConstantOnly matters now since it can be either null or the constant. */
     @SuppressWarnings("unused") // Called by reflection
     public static Object bad(String a, int b,
         @Nullable OneConstantEnum oneConstantOnly) {
       return new GoodEquals(a, b);
     }
   }
 
   public void testNullsOnReturnValues_good() throws Exception {
     tester.forAllPublicStaticMethods(GoodNullsFactory.class).testNulls();
   }
 
   private static class GoodNullsFactory {
     @SuppressWarnings("unused") // Called by reflection
     public static Object good(String s) {
       return new GoodNulls(s);
     }
   }
 
   public void testNullsOnReturnValues_bad() throws Exception {
     try {
       tester
           .forAllPublicStaticMethods(BadNullsFactory.class)
           .thatReturn(Object.class)
           .testNulls();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail();
   }
 
   public void testNullsOnReturnValues_returnTypeFiltered() throws Exception {
     try {
       tester
           .forAllPublicStaticMethods(BadNullsFactory.class)
           .thatReturn(Iterable.class)
           .testNulls();
     } catch (AssertionFailedError expected) {
       assertEquals(
           "No public static methods that return java.lang.Iterable or subtype are found in "
               + BadNullsFactory.class + ".",
           expected.getMessage());
       return;
     }
     fail();
   }
   
   public static class BadNullsFactory {
     public static Object bad(@SuppressWarnings("unused") String a) {
       return new BadNulls();
     }
   }
 
   public void testSerializableOnReturnValues_good() throws Exception {
     tester.forAllPublicStaticMethods(GoodSerializableFactory.class).testSerializable();
   }
 
   public static class GoodSerializableFactory {
     public static Object good(Runnable r) {
       return r;
     }
     public static Object good(AnInterface i) {
       return i;
     }
   }
 
   public void testSerializableOnReturnValues_bad() throws Exception {
     try {
       tester.forAllPublicStaticMethods(BadSerializableFactory.class).testSerializable();
     } catch (AssertionError expected) {
       return;
     }
     fail();
   }
 
   public static class BadSerializableFactory {
     public static Object bad() {
       return new Serializable() {
         @SuppressWarnings("unused")
         private final Object notSerializable = new Object();
       };
     }
   }
 
   public void testEqualsAndSerializableOnReturnValues_equalsIsGoodButNotSerializable()
       throws Exception {
     try {
       tester.forAllPublicStaticMethods(GoodEqualsFactory.class).testEqualsAndSerializable();
     } catch (AssertionError expected) {
       return;
     }
     fail("should have failed");
   }
 
   public void testEqualsAndSerializableOnReturnValues_serializableButNotEquals()
       throws Exception {
     try {
       tester.forAllPublicStaticMethods(GoodSerializableFactory.class).testEqualsAndSerializable();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail("should have failed");
   }
 
   public void testEqualsAndSerializableOnReturnValues_good()
       throws Exception {
     tester.forAllPublicStaticMethods(GoodEqualsAndSerialiableFactory.class)
         .testEqualsAndSerializable();
   }
 
   public static class GoodEqualsAndSerialiableFactory {
     public static Object good(AnInterface s) {
       return Functions.constant(s);
     }
   }
 
   public void testEqualsForReturnValues_factoryReturnsNullButNotAnnotated() throws Exception {
     try {
       tester.forAllPublicStaticMethods(FactoryThatReturnsNullButNotAnnotated.class)
           .testEquals();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail();
   }
 
   public void testNullsForReturnValues_factoryReturnsNullButNotAnnotated() throws Exception {
     try {
       tester.forAllPublicStaticMethods(FactoryThatReturnsNullButNotAnnotated.class)
           .testNulls();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail();
   }
 
   public void testSerializableForReturnValues_factoryReturnsNullButNotAnnotated() throws Exception {
     try {
       tester.forAllPublicStaticMethods(FactoryThatReturnsNullButNotAnnotated.class)
           .testSerializable();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail();
   }
 
   public void testEqualsAndSerializableForReturnValues_factoryReturnsNullButNotAnnotated()
       throws Exception {
     try {
       tester.forAllPublicStaticMethods(FactoryThatReturnsNullButNotAnnotated.class)
           .testEqualsAndSerializable();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail();
   }
 
   public static class FactoryThatReturnsNullButNotAnnotated {
     public static Object bad() {
       return null;
     }
   }
 
   public void testEqualsForReturnValues_factoryReturnsNullAndAnnotated() throws Exception {
     tester.forAllPublicStaticMethods(FactoryThatReturnsNullAndAnnotated.class)
         .testEquals();
   }
 
   public void testNullsForReturnValues_factoryReturnsNullAndAnnotated() throws Exception {
     tester.forAllPublicStaticMethods(FactoryThatReturnsNullAndAnnotated.class)
         .testNulls();
   }
 
   public void testSerializableForReturnValues_factoryReturnsNullAndAnnotated() throws Exception {
     tester.forAllPublicStaticMethods(FactoryThatReturnsNullAndAnnotated.class)
         .testSerializable();
   }
 
   public void testEqualsAndSerializableForReturnValues_factoryReturnsNullAndAnnotated()
       throws Exception {
     tester.forAllPublicStaticMethods(FactoryThatReturnsNullAndAnnotated.class)
         .testEqualsAndSerializable();
   }
 
   public static class FactoryThatReturnsNullAndAnnotated {
     @Nullable public static Object bad() {
       return null;
     }
   }
 
   public void testGoodEquals() throws Exception {
     tester.testEquals(GoodEquals.class);
   }
 
   public void testEquals_interface() {
     tester.testEquals(AnInterface.class);
   }
 
   public void testEquals_abstractClass() {
     tester.testEquals(AnAbstractClass.class);
   }
 
   public void testEquals_enum() {
     tester.testEquals(OneConstantEnum.class);
   }
 
   public void testBadEquals() throws Exception {
     try {
       tester.testEquals(BadEquals.class);
     } catch (AssertionFailedError expected) {
       assertThat(expected.getMessage()).contains("create(null)");
       return;
     }
     fail("should have failed");
   }
 
   public void testBadEquals_withParameterizedType() throws Exception {
     try {
       tester.testEquals(BadEqualsWithParameterizedType.class);
     } catch (AssertionFailedError expected) {
       assertThat(expected.getMessage()).contains("create([[1]])");
       return;
     }
     fail("should have failed");
   }
 
   public void testBadEquals_withSingleParameterValue() throws Exception {
     try {
       tester.doTestEquals(ConstructorParameterWithOptionalNotInstantiable.class);
       fail();
     } catch (ParameterHasNoDistinctValueException expected) {}
   }
 
   public void testGoodReferentialEqualityComparison() throws Exception {
     tester.testEquals(UsesEnum.class);
     tester.testEquals(UsesReferentialEquality.class);
     tester.testEquals(SameListInstance.class);
   }
 
   public void testEqualsUsingReferentialEquality() throws Exception {
     assertBadUseOfReferentialEquality(SameIntegerInstance.class);
     assertBadUseOfReferentialEquality(SameLongInstance.class);
     assertBadUseOfReferentialEquality(SameFloatInstance.class);
     assertBadUseOfReferentialEquality(SameDoubleInstance.class);
     assertBadUseOfReferentialEquality(SameShortInstance.class);
     assertBadUseOfReferentialEquality(SameByteInstance.class);
     assertBadUseOfReferentialEquality(SameCharacterInstance.class);
     assertBadUseOfReferentialEquality(SameBooleanInstance.class);
     assertBadUseOfReferentialEquality(SameObjectInstance.class);
     assertBadUseOfReferentialEquality(SameStringInstance.class);
     assertBadUseOfReferentialEquality(SameInterfaceInstance.class);
   }
 
   private void assertBadUseOfReferentialEquality(Class<?> cls) throws Exception {
     try {
       tester.testEquals(cls);
     } catch (AssertionFailedError expected) {
       assertThat(expected.getMessage()).contains(cls.getSimpleName() + "(");
       return;
     }
     fail("should have failed");
   }
 
   public void testParameterNotInstantiableForEqualsTest() throws Exception {
     try {
       tester.doTestEquals(ConstructorParameterNotInstantiable.class);
       fail("should have failed");
     } catch (ParameterNotInstantiableException expected) {}
   }
 
   public void testNoDistinctValueForEqualsTest() throws Exception {
     try {
       tester.doTestEquals(ConstructorParameterSingleValue.class);
       fail("should have failed");
     } catch (ParameterHasNoDistinctValueException expected) {}
   }
 
   public void testConstructorThrowsForEqualsTest() throws Exception {
     try {
       tester.doTestEquals(ConstructorThrows.class);
       fail("should have failed");
     } catch (InvocationTargetException expected) {}
   }
 
   public void testFactoryMethodReturnsNullForEqualsTest() throws Exception {
     try {
       tester.doTestEquals(FactoryMethodReturnsNullAndAnnotated.class);
       fail("should have failed");
     } catch (FactoryMethodReturnsNullException expected) {}
   }
 
   public void testFactoryMethodReturnsNullButNotAnnotatedInEqualsTest() throws Exception {
     try {
       tester.testEquals(FactoryMethodReturnsNullButNotAnnotated.class);
     } catch (AssertionFailedError expected) {
       return;
     }
     fail("should have failed");
   }
 
   public void testNoEqualsChecksOnEnum() throws Exception {
     tester.testEquals(OneConstantEnum.class);
     tester.testEquals(NoConstantEnum.class);
     tester.testEquals(TimeUnit.class);
   }
 
   public void testNoEqualsChecksOnInterface() throws Exception {
     tester.testEquals(Runnable.class);
   }
 
   public void testNoEqualsChecksOnAnnotation() throws Exception {
     tester.testEquals(Nullable.class);
   }
 
   public void testGoodNulls() throws Exception {
     tester.testNulls(GoodNulls.class);
   }
 
   public void testNoNullCheckNeededDespitNotInstantiable() throws Exception {
     tester.doTestNulls(NoNullCheckNeededDespitNotInstantiable.class, Visibility.PACKAGE);
   }
 
   public void testNulls_interface() {
     tester.testNulls(AnInterface.class);
   }
 
   public void testNulls_abstractClass() {
     tester.testNulls(AnAbstractClass.class);
   }
 
   public void testNulls_enum() throws Exception {
     tester.testNulls(OneConstantEnum.class);
     tester.testNulls(NoConstantEnum.class);
     tester.testNulls(TimeUnit.class);
   }
 
   public void testNulls_parameterOptionalNotInstantiable() throws Exception {
     tester.testNulls(ConstructorParameterWithOptionalNotInstantiable.class);
   }
 
   public void testEnumFailsToCheckNull() throws Exception {
     try {
       tester.testNulls(EnumFailsToCheckNull.class);
     } catch (AssertionFailedError expected) {
       return;
     }
     fail("should have failed");
   }
 
   public void testNoNullChecksOnInterface() throws Exception {
     tester.testNulls(Runnable.class);
   }
 
   public void testNoNullChecksOnAnnotation() throws Exception {
     tester.testNulls(Nullable.class);
   }
 
   public void testBadNulls() throws Exception {
     try {
       tester.testNulls(BadNulls.class);
     } catch (AssertionFailedError expected) {
       return;
     }
     fail("should have failed");
   }
 
   public void testInstantiate_factoryMethodReturnsNullButNotAnnotated() throws Exception {
     try {
       tester.instantiate(FactoryMethodReturnsNullButNotAnnotated.class);
     } catch (AssertionFailedError expected) {
       assertThat(expected.getMessage()).contains("@Nullable");
       return;
     }
     fail("should have failed");
   }
 
   public void testInstantiate_factoryMethodReturnsNullAndAnnotated() throws Exception {
     try {
       tester.instantiate(FactoryMethodReturnsNullAndAnnotated.class);
       fail("should have failed");
     } catch (FactoryMethodReturnsNullException expected) {}
   }
 
   public void testInstantiate_factoryMethodAcceptsNull() throws Exception {
     assertNull(tester.instantiate(FactoryMethodAcceptsNull.class).name);
   }
 
   public void testInstantiate_factoryMethodDoesNotAcceptNull() throws Exception {
     assertNotNull(tester.instantiate(FactoryMethodDoesNotAcceptNull.class).name);
   }
 
   public void testInstantiate_constructorAcceptsNull() throws Exception {
     assertNull(tester.instantiate(ConstructorAcceptsNull.class).name);
   }
 
   public void testInstantiate_constructorDoesNotAcceptNull() throws Exception {
     assertNotNull(tester.instantiate(ConstructorDoesNotAcceptNull.class).name);
   }
 
   public void testInstantiate_notInstantiable() throws Exception {
     assertNull(tester.instantiate(NotInstantiable.class));
   }
 
   public void testInstantiate_noConstantEnum() throws Exception {
     assertNull(tester.instantiate(NoConstantEnum.class));
   }
 
   public void testInstantiate_oneConstantEnum() throws Exception {
     assertEquals(OneConstantEnum.A, tester.instantiate(OneConstantEnum.class));
   }
 
   public void testInstantiate_interface() throws Exception {
     assertNull(tester.instantiate(Runnable.class));
   }
 
   public void testInstantiate_abstractClass() throws Exception {
     assertNull(tester.instantiate(AbstractList.class));
   }
 
   public void testInstantiate_annotation() throws Exception {
     assertNull(tester.instantiate(Nullable.class));
   }
 
   public void testInstantiate_setDefault() throws Exception {
     NotInstantiable x = new NotInstantiable();
     tester.setDefault(NotInstantiable.class, x);
     assertNotNull(tester.instantiate(ConstructorParameterNotInstantiable.class));
   }
 
   public void testSetDistinctValues_equalInstances() {
     try {
       tester.setDistinctValues(String.class, "", "");
       fail();
     } catch (IllegalArgumentException expected) {}
   }
 
   public void testInstantiate_setDistinctValues() throws Exception {
     NotInstantiable x = new NotInstantiable();
     NotInstantiable y = new NotInstantiable();
     tester.setDistinctValues(NotInstantiable.class, x, y);
     assertNotNull(tester.instantiate(ConstructorParameterNotInstantiable.class));
   }
 
   public void testInstantiate_setSampleInstances_empty() throws Exception {
     tester.setSampleInstances(NotInstantiable.class, ImmutableList.<NotInstantiable>of());
     try {
       tester.instantiate(ConstructorParameterNotInstantiable.class);
       fail();
     } catch (ParameterNotInstantiableException expected) {}
   }
 
   public void testInstantiate_constructorThrows() throws Exception {
     try {
       tester.instantiate(ConstructorThrows.class);
       fail();
     } catch (InvocationTargetException expected) {}
   }
 
   public void testInstantiate_factoryMethodThrows() throws Exception {
     try {
       tester.instantiate(FactoryMethodThrows.class);
       fail();
     } catch (InvocationTargetException expected) {}
   }
 
   public void testInstantiate_constructorParameterNotInstantiable() throws Exception {
     try {
       tester.instantiate(ConstructorParameterNotInstantiable.class);
       fail();
     } catch (ParameterNotInstantiableException expected) {}
   }
 
   public void testInstantiate_factoryMethodParameterNotInstantiable() throws Exception {
     try {
       tester.instantiate(FactoryMethodParameterNotInstantiable.class);
       fail();
     } catch (ParameterNotInstantiableException expected) {}
   }
 
   public void testInstantiate_instantiableFactoryMethodChosen() throws Exception {
     assertEquals("good", tester.instantiate(InstantiableFactoryMethodChosen.class).name);
   }
 
   public void testInterfaceProxySerializable() throws Exception {
     SerializableTester.reserializeAndAssert(tester.instantiate(HasAnInterface.class));
   }
 
   public void testReturnValuesFromAnotherPackageIgnoredForNullTests() throws Exception {
     new ClassSanityTester().forAllPublicStaticMethods(JdkObjectFactory.class).testNulls();
   }
 
   /** String doesn't check nulls as we expect. But the framework should ignore. */
   private static class JdkObjectFactory {
     @SuppressWarnings("unused") // Called by reflection
     public static Object create() {
       return new ArrayList<String>();
     }
   }
 
   static class HasAnInterface implements Serializable {
     private final AnInterface i;
 
     public HasAnInterface(AnInterface i) {
       this.i = i;
     }
 
     @Override public boolean equals(@Nullable Object obj) {
       if (obj instanceof HasAnInterface) {
         HasAnInterface that = (HasAnInterface) obj;
         return i.equals(that.i);
       } else {
         return false;
       }
     }
 
     @Override public int hashCode() {
       return i.hashCode();
     }
   }
 
   static class InstantiableFactoryMethodChosen {
     final String name;
 
     private InstantiableFactoryMethodChosen(String name) {
       this.name = name;
     }
 
     public InstantiableFactoryMethodChosen(NotInstantiable x) {
       checkNotNull(x);
       this.name = "x1";
     }
 
     public static InstantiableFactoryMethodChosen create(NotInstantiable x) {
       return new InstantiableFactoryMethodChosen(x);
     }
 
     public static InstantiableFactoryMethodChosen create(String s) {
       checkNotNull(s);
       return new InstantiableFactoryMethodChosen("good");
     }
   }
 
   public void testInstantiate_instantiableConstructorChosen() throws Exception {
     assertEquals("good", tester.instantiate(InstantiableConstructorChosen.class).name);
   }
 
   public void testEquals_setOfNonInstantiable() throws Exception {
     try {
       new ClassSanityTester().doTestEquals(SetWrapper.class);
       fail();
     } catch (ParameterNotInstantiableException expected) {}
   }
 
   private abstract static class Wrapper {
     private final Object wrapped;
 
     Wrapper(Object wrapped) {
       this.wrapped = checkNotNull(wrapped);
     }
 
     @Override public boolean equals(@Nullable Object obj) {
       // In general getClass().isInstance() is bad for equals.
       // But here we fully control the subclasses to ensure symmetry.
       if (getClass().isInstance(obj)) {
         Wrapper that = (Wrapper) obj;
         return wrapped.equals(that.wrapped);
       }
       return false;
     }
 
     @Override public int hashCode() {
       return wrapped.hashCode();
     }
 
     @Override public String toString() {
       return wrapped.toString();
     }
   }
 
   private static class SetWrapper extends Wrapper {
     public SetWrapper(Set<NotInstantiable> wrapped) {
       super(wrapped);
     }
   }
 
   static class InstantiableConstructorChosen {
     final String name;
 
     public InstantiableConstructorChosen(String name) {
       checkNotNull(name);
       this.name = "good";
     }
 
     public InstantiableConstructorChosen(NotInstantiable x) {
       checkNotNull(x);
       this.name = "x1";
     }
 
     public static InstantiableFactoryMethodChosen create(NotInstantiable x) {
       return new InstantiableFactoryMethodChosen(x);
     }
   }
 
   static class GoodEquals {
 
     private final String a;
     private final int b;
 
     private GoodEquals(String a, int b) {
       this.a = checkNotNull(a);
       this.b = b;
     }
 
     // ignored by testEquals()
     GoodEquals(@SuppressWarnings("unused") NotInstantiable x) {
       this.a = "x";
       this.b = -1;
     }
 
     // will keep trying
     public GoodEquals(@SuppressWarnings("unused") NotInstantiable x, int b) {
       this.a = "x";
       this.b = b;
     }
 
     // keep trying
     @SuppressWarnings("unused")
     static GoodEquals create(int a, int b) {
       throw new RuntimeException();
     }
 
     // keep trying
     @SuppressWarnings("unused")
     @Nullable public static GoodEquals createMayReturnNull(int a, int b) {
       return null;
     }
 
     // Good!
     static GoodEquals create(String a, int b) {
       return new GoodEquals(a, b);
     }
 
     @Override public boolean equals(@Nullable Object obj) {
       if (obj instanceof GoodEquals) {
         GoodEquals that = (GoodEquals) obj;
         return a.equals(that.a) && b == that.b;
       } else {
         return false;
       }
     }
 
     @Override public int hashCode() {
       return 0;
     }
   }
 
   static class BadEquals {
 
     public BadEquals() {} // ignored by testEquals() since it has less parameters.
 
     public static BadEquals create(@SuppressWarnings("unused") @Nullable String s) {
       return new BadEquals();
     }
 
     @Override public boolean equals(@Nullable Object obj) {
       return obj instanceof BadEquals;
     }
 
     @Override public int hashCode() {
       return 0;
     }
   }
 
   static class SameIntegerInstance {
     private final Integer i;
 
     public SameIntegerInstance(Integer i) {
       this.i = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return i.hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameIntegerInstance) {
         SameIntegerInstance that = (SameIntegerInstance) obj;
         return i == that.i;
       }
       return false;
     }
   }
 
   static class SameLongInstance {
     private final Long i;
 
     public SameLongInstance(Long i) {
       this.i = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return i.hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameLongInstance) {
         SameLongInstance that = (SameLongInstance) obj;
         return i == that.i;
       }
       return false;
     }
   }
 
   static class SameFloatInstance {
     private final Float i;
 
     public SameFloatInstance(Float i) {
       this.i = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return i.hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameFloatInstance) {
         SameFloatInstance that = (SameFloatInstance) obj;
         return i == that.i;
       }
       return false;
     }
   }
 
   static class SameDoubleInstance {
     private final Double i;
 
     public SameDoubleInstance(Double i) {
       this.i = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return i.hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameDoubleInstance) {
         SameDoubleInstance that = (SameDoubleInstance) obj;
         return i == that.i;
       }
       return false;
     }
   }
 
   static class SameShortInstance {
     private final Short i;
 
     public SameShortInstance(Short i) {
       this.i = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return i.hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameShortInstance) {
         SameShortInstance that = (SameShortInstance) obj;
         return i == that.i;
       }
       return false;
     }
   }
 
   static class SameByteInstance {
     private final Byte i;
 
     public SameByteInstance(Byte i) {
       this.i = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return i.hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameByteInstance) {
         SameByteInstance that = (SameByteInstance) obj;
         return i == that.i;
       }
       return false;
     }
   }
 
   static class SameCharacterInstance {
     private final Character i;
 
     public SameCharacterInstance(Character i) {
       this.i = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return i.hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameCharacterInstance) {
         SameCharacterInstance that = (SameCharacterInstance) obj;
         return i == that.i;
       }
       return false;
     }
   }
 
   static class SameBooleanInstance {
     private final Boolean i;
 
     public SameBooleanInstance(Boolean i) {
       this.i = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return i.hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameBooleanInstance) {
         SameBooleanInstance that = (SameBooleanInstance) obj;
         return i == that.i;
       }
       return false;
     }
   }
 
   static class SameStringInstance {
     private final String s;
 
     public SameStringInstance(String s) {
       this.s = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return s.hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameStringInstance) {
         SameStringInstance that = (SameStringInstance) obj;
         return s == that.s;
       }
       return false;
     }
   }
 
   static class SameObjectInstance {
     private final Object s;
 
     public SameObjectInstance(Object s) {
       this.s = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return s.hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameObjectInstance) {
         SameObjectInstance that = (SameObjectInstance) obj;
         return s == that.s;
       }
       return false;
     }
   }
 
   static class SameInterfaceInstance {
     private final Runnable s;
 
     public SameInterfaceInstance(Runnable s) {
       this.s = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return s.hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameInterfaceInstance) {
         SameInterfaceInstance that = (SameInterfaceInstance) obj;
         return s == that.s;
       }
       return false;
     }
   }
 
   static class SameListInstance {
     private final List<?> s;
 
     public SameListInstance(List<?> s) {
       this.s = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return System.identityHashCode(s);
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameListInstance) {
         SameListInstance that = (SameListInstance) obj;
         return s == that.s;
       }
       return false;
     }
   }
 
   static class UsesReferentialEquality {
     private final ReferentialEquality s;
 
     public UsesReferentialEquality(ReferentialEquality s) {
       this.s = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return s.hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof UsesReferentialEquality) {
         UsesReferentialEquality that = (UsesReferentialEquality) obj;
         return s == that.s;
       }
       return false;
     }
   }
 
   static class UsesEnum {
     private final TimeUnit s;
 
     public UsesEnum(TimeUnit s) {
       this.s = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return s.hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof UsesEnum) {
         UsesEnum that = (UsesEnum) obj;
         return s == that.s;
       }
       return false;
     }
   }
 
   public static class ReferentialEquality {
     public ReferentialEquality() {}
   }
 
   static class BadEqualsWithParameterizedType {
 
     // ignored by testEquals() since it has less parameters.
     public BadEqualsWithParameterizedType() {}
 
     public static BadEqualsWithParameterizedType create(
         @SuppressWarnings("unused") ImmutableList<Iterable<? extends String>> s) {
       return new BadEqualsWithParameterizedType();
     }
 
     @Override public boolean equals(@Nullable Object obj) {
       return obj instanceof BadEqualsWithParameterizedType;
     }
 
     @Override public int hashCode() {
       return 0;
     }
   }
 
   static class GoodNulls {
     public GoodNulls(String s) {
       checkNotNull(s);
     }
 
     public void rejectNull(String s) {
       checkNotNull(s);
     }
   }
 
   public static class BadNulls {
     public void failsToRejectNull(@SuppressWarnings("unused") String s) {}
   }
 
   public static class NoNullCheckNeededDespitNotInstantiable {
 
     public NoNullCheckNeededDespitNotInstantiable(NotInstantiable x) {
       checkNotNull(x);
     }
 
     @SuppressWarnings("unused") // reflected
     void primitiveOnly(int i) {}
 
     @SuppressWarnings("unused") //reflected
     void nullableOnly(@Nullable String s) {}
     public void noParameter() {}
 
     @SuppressWarnings("unused") //reflected
     void primitiveAndNullable(@Nullable String s, int i) {}
   }
 
   static class FactoryMethodReturnsNullButNotAnnotated {
     private FactoryMethodReturnsNullButNotAnnotated() {}
 
     static FactoryMethodReturnsNullButNotAnnotated returnsNull() {
       return null;
     }
   }
 
   static class FactoryMethodReturnsNullAndAnnotated {
     private FactoryMethodReturnsNullAndAnnotated() {}
 
     @Nullable public static FactoryMethodReturnsNullAndAnnotated returnsNull() {
       return null;
     }
   }
 
   static class FactoryMethodAcceptsNull {
 
     final String name;
 
     private FactoryMethodAcceptsNull(String name) {
       this.name = name;
     }
 
     static FactoryMethodAcceptsNull create(@Nullable String name) {
       return new FactoryMethodAcceptsNull(name);
     }
   }
 
   static class FactoryMethodDoesNotAcceptNull {
 
     final String name;
 
     private FactoryMethodDoesNotAcceptNull(String name) {
       this.name = checkNotNull(name);
     }
 
     public static FactoryMethodDoesNotAcceptNull create(String name) {
       return new FactoryMethodDoesNotAcceptNull(name);
     }
   }
 
   static class ConstructorAcceptsNull {
 
     final String name;
 
     public ConstructorAcceptsNull(@Nullable String name) {
       this.name = name;
     }
   }
 
   static class ConstructorDoesNotAcceptNull {
 
     final String name;
 
     ConstructorDoesNotAcceptNull(String name) {
       this.name = checkNotNull(name);
     }
   }
 
   static class ConstructorParameterNotInstantiable {
     public ConstructorParameterNotInstantiable(@SuppressWarnings("unused") NotInstantiable x) {}
   }
 
   // Test that we should get a distinct parameter error when doing equals test.
   static class ConstructorParameterWithOptionalNotInstantiable {
     public ConstructorParameterWithOptionalNotInstantiable(Optional<NotInstantiable> x) {
       checkNotNull(x);
     }
     @Override public boolean equals(@Nullable Object obj) {
       throw new UnsupportedOperationException();
     }
     @Override public int hashCode() {
       throw new UnsupportedOperationException();
     }
   }
 
   static class ConstructorParameterSingleValue {
     public ConstructorParameterSingleValue(@SuppressWarnings("unused") Singleton s) {}
     @Override public boolean equals(Object obj) {
       return obj instanceof ConstructorParameterSingleValue;
     }
     @Override public int hashCode() {
       return 1;
     }
 
     public static class Singleton {
       public static final Singleton INSTANCE = new Singleton();
       private Singleton() {}
     }
   }
 
   static class FactoryMethodParameterNotInstantiable {
 
     private FactoryMethodParameterNotInstantiable() {}
 
     static FactoryMethodParameterNotInstantiable create(
         @SuppressWarnings("unused") NotInstantiable x) {
       return new FactoryMethodParameterNotInstantiable();
     }
   }
 
   static class ConstructorThrows {
     public ConstructorThrows() {
       throw new RuntimeException();
     }
   }
 
   static class FactoryMethodThrows {
     private FactoryMethodThrows() {}
 
     public static FactoryMethodThrows create() {
       throw new RuntimeException();
     }
   }
 
   static class NotInstantiable {
     private NotInstantiable() {}
   }
 
   private enum NoConstantEnum {}
 
   private enum OneConstantEnum {
     A
   }
 
   private enum EnumFailsToCheckNull {
     A;
 
     @SuppressWarnings("unused") 
     public void failToCheckNull(String s) {}
   }
 
   private interface AnInterface {}
 
   private static abstract class AnAbstractClass {
     @SuppressWarnings("unused")
     public AnAbstractClass(String s) {}
 
     @SuppressWarnings("unused")
     public void failsToCheckNull(String s) {}
   }
 
   private static class NoPublicStaticMethods {
     @SuppressWarnings("unused") // To test non-public factory isn't used.
     static String notPublic() {
       return "";
     }
   }
 }