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;
  
  import static com.google.common.base.Preconditions.checkNotNull;
  import static org.truth0.Truth.ASSERT;
  
  
  
  import java.util.List;
  
  import  javax.annotation.Nullable;

Unit tests for ClassSanityTester.

Author(s):
Ben Yu
  
  public class ClassSanityTesterTest extends TestCase {
  
    private final ClassSanityTester tester = new ClassSanityTester();
  
    public void testEqualsOnReturnValues_good() throws Exception {
    }
  
    public static class GoodEqualsFactory {
      public static Object good(String aint 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(ab);
      }
      // 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();
      }
    }
  
      try {
      } 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 {
      } 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 aint b,
         @Nullable OneConstantEnum oneConstantOnly) {
       return new GoodEquals(ab);
     }
   }
 
   public void testNullsOnReturnValues_good() throws Exception {
   }
 
   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 {
       
           .forAllPublicStaticMethods(BadNullsFactory.class)
           .thatReturn(Object.class)
           .testNulls();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail();
   }
 
     try {
       
           .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 {
   }
 
   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 {
     } catch (AssertionError expected) {
       return;
     }
     fail();
   }
 
   public static class BadSerializableFactory {
     public static Object bad() {
       return new Serializable() {
         @SuppressWarnings("unused")
         private final Object notSerializable = new Object();
       };
     }
   }
 
       throws Exception {
     try {
     } catch (AssertionError expected) {
       return;
     }
     fail("should have failed");
   }
 
       throws Exception {
     try {
     } catch (AssertionFailedError expected) {
       return;
     }
     fail("should have failed");
   }
 
       throws Exception {
         .testEqualsAndSerializable();
   }
 
   public static class GoodEqualsAndSerialiableFactory {
     public static Object good(AnInterface s) {
       return Functions.constant(s);
     }
   }
 
     try {
           .testEquals();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail();
   }
 
     try {
           .testNulls();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail();
   }
 
     try {
           .testSerializable();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail();
   }
 
       throws Exception {
     try {
           .testEqualsAndSerializable();
     } catch (AssertionFailedError expected) {
       return;
     }
     fail();
   }
 
   public static class FactoryThatReturnsNullButNotAnnotated {
     public static Object bad() {
       return null;
     }
   }
 
         .testEquals();
   }
 
         .testNulls();
   }
 
         .testSerializable();
   }
 
       throws Exception {
         .testEqualsAndSerializable();
   }
 
   public static class FactoryThatReturnsNullAndAnnotated {
     @Nullable public static Object bad() {
       return null;
     }
   }
 
   public void testGoodEquals() throws Exception {
     .testEquals(GoodEquals.class);
   }
 
   public void testEquals_interface() {
     .testEquals(AnInterface.class);
   }
 
   public void testEquals_abstractClass() {
   }
 
   public void testEquals_enum() {
   }
 
   public void testBadEquals() throws Exception {
     try {
       .testEquals(BadEquals.class);
     } catch (AssertionFailedError expected) {
       .that(expected.getMessage()).contains("create(null)");
       return;
     }
     fail("should have failed");
   }
 
   public void testBadEquals_withParameterizedType() throws Exception {
     try {
     } catch (AssertionFailedError expected) {
       .that(expected.getMessage()).contains("create([[1]])");
       return;
     }
     fail("should have failed");
   }
 
   public void testGoodReferentialEqualityComparison() throws Exception {
     .testEquals(UsesEnum.class);
   }
 
   public void testEqualsUsingReferentialEquality() throws Exception {
   }
 
   private void assertBadUseOfReferentialEquality(Class<?> clsthrows Exception {
     try {
       .testEquals(cls);
     } catch (AssertionFailedError expected) {
       .that(expected.getMessage()).contains(cls.getSimpleName() + "(");
       return;
     }
     fail("should have failed");
   }
 
     try {
       fail("should have failed");
     } catch (ParameterNotInstantiableException expected) {}
   }
 
   public void testConstructorThrowsForEqualsTest() throws Exception {
     try {
       fail("should have failed");
     } catch (InvocationTargetException expected) {}
   }
 
     try {
       fail("should have failed");
     } catch (FactoryMethodReturnsNullException expected) {}
   }
 
     try {
     } catch (AssertionFailedError expected) {
       return;
     }
     fail("should have failed");
   }
 
   public void testNoEqualsChecksOnEnum() throws Exception {
     .testEquals(TimeUnit.class);
   }
 
   public void testNoEqualsChecksOnInterface() throws Exception {
     .testEquals(Runnable.class);
   }
 
   public void testNoEqualsChecksOnAnnotation() throws Exception {
     .testEquals(Nullable.class);
   }
 
   public void testGoodNulls() throws Exception {
     .testNulls(GoodNulls.class);
   }
 
   }
 
   public void testNulls_interface() {
     .testNulls(AnInterface.class);
   }
 
   public void testNulls_abstractClass() {
   }
 
   public void testNulls_enum() throws Exception {
     .testNulls(TimeUnit.class);
   }
 
   public void testEnumFailsToCheckNull() throws Exception {
     try {
     } catch (AssertionFailedError expected) {
       return;
     }
     fail("should have failed");
   }
 
   public void testNoNullChecksOnInterface() throws Exception {
     .testNulls(Runnable.class);
   }
 
   public void testNoNullChecksOnAnnotation() throws Exception {
     .testNulls(Nullable.class);
   }
 
   public void testBadNulls() throws Exception {
     try {
       .testNulls(BadNulls.class);
     } catch (AssertionFailedError expected) {
       return;
     }
     fail("should have failed");
   }
 
     try {
     } catch (AssertionFailedError expected) {
       .that(expected.getMessage()).contains("@Nullable");
       return;
     }
     fail("should have failed");
   }
 
     try {
       fail("should have failed");
     } catch (FactoryMethodReturnsNullException expected) {}
   }
 
   public void testInstantiate_factoryMethodAcceptsNull() throws Exception {
   }
 
   }
 
   public void testInstantiate_constructorAcceptsNull() throws Exception {
   }
 
   }
 
   public void testInstantiate_notInstantiable() throws Exception {
   }
 
   public void testInstantiate_noConstantEnum() throws Exception {
   }
 
   public void testInstantiate_oneConstantEnum() throws Exception {
   }
 
   public void testInstantiate_interface() throws Exception {
   }
 
   public void testInstantiate_abstractClass() throws Exception {
   }
 
   public void testInstantiate_annotation() throws Exception {
     assertNull(.instantiate(Nullable.class));
   }
 
   public void testInstantiate_setDefault() throws Exception {
     NotInstantiable x = new NotInstantiable();
     .setDefault(NotInstantiable.classx);
   }
 
   public void testInstantiate_setSampleInstances() throws Exception {
     NotInstantiable x = new NotInstantiable();
     .setSampleInstances(NotInstantiable.class, ImmutableList.of(x));
   }
 
   public void testInstantiate_setSampleInstances_empty() throws Exception {
     .setSampleInstances(NotInstantiable.class, ImmutableList.<NotInstantiable>of());
     try {
       fail();
     } catch (ParameterNotInstantiableException expected) {}
   }
 
   public void testInstantiate_constructorThrows() throws Exception {
     try {
       fail();
     } catch (InvocationTargetException expected) {}
   }
 
   public void testInstantiate_factoryMethodThrows() throws Exception {
     try {
       fail();
     } catch (InvocationTargetException expected) {}
   }
 
     try {
       fail();
     } catch (ParameterNotInstantiableException expected) {}
   }
 
     try {
       fail();
     } catch (ParameterNotInstantiableException expected) {}
   }
 
   }
 
   public void testInterfaceProxySerializable() throws Exception {
     SerializableTester.reserializeAndAssert(.instantiate(HasAnInterface.class));
   }
 
   }

  
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;
     }
 
     @Override public boolean equals(@Nullable Object obj) {
       if (obj instanceof HasAnInterface) {
         HasAnInterface that = (HasAnInterfaceobj;
         return .equals(that.i);
       } else {
         return false;
       }
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
   }
 
   static class InstantiableFactoryMethodChosen {
     final String name;
 
     private InstantiableFactoryMethodChosen(String name) {
       this. = name;
     }
 
       checkNotNull(x);
       this. = "x1";
     }
 
       return new InstantiableFactoryMethodChosen(x);
     }
 
     public static InstantiableFactoryMethodChosen create(String s) {
       checkNotNull(s);
       return new InstantiableFactoryMethodChosen("good");
     }
   }
 
   }
 
   static class InstantiableConstructorChosen {
     final String name;
 
     public InstantiableConstructorChosen(String name) {
       checkNotNull(name);
       this. = "good";
     }
 
       checkNotNull(x);
       this. = "x1";
     }
 
       return new InstantiableFactoryMethodChosen(x);
     }
   }
 
   static class GoodEquals {
 
     private final String a;
     private final int b;
 
     private GoodEquals(String aint b) {
       this. = checkNotNull(a);
       this. = b;
     }
 
     // ignored by testEquals()
     GoodEquals(@SuppressWarnings("unused"NotInstantiable x) {
       this. = "x";
       this. = -1;
     }
 
     // will keep trying
     public GoodEquals(@SuppressWarnings("unused"NotInstantiable xint b) {
       this. = "x";
       this. = b;
     }
 
     // keep trying
     @SuppressWarnings("unused")
     static GoodEquals create(int aint b) {
       throw new RuntimeException();
     }
 
     // keep trying
     @SuppressWarnings("unused")
     @Nullable public static GoodEquals createMayReturnNull(int aint b) {
       return null;
     }
 
     // Good!
     static GoodEquals create(String aint b) {
       return new GoodEquals(ab);
     }
 
     @Override public boolean equals(@Nullable Object obj) {
       if (obj instanceof GoodEquals) {
         GoodEquals that = (GoodEqualsobj;
         return .equals(that.a) &&  == 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. = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameIntegerInstance) {
         SameIntegerInstance that = (SameIntegerInstanceobj;
         return  == that.i;
       }
       return false;
     }
   }
 
   static class SameLongInstance {
     private final Long i;
 
     public SameLongInstance(Long i) {
       this. = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameLongInstance) {
         SameLongInstance that = (SameLongInstanceobj;
         return  == that.i;
       }
       return false;
     }
   }
 
   static class SameFloatInstance {
     private final Float i;
 
     public SameFloatInstance(Float i) {
       this. = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameFloatInstance) {
         SameFloatInstance that = (SameFloatInstanceobj;
         return  == that.i;
       }
       return false;
     }
   }
 
   static class SameDoubleInstance {
     private final Double i;
 
     public SameDoubleInstance(Double i) {
       this. = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameDoubleInstance) {
         SameDoubleInstance that = (SameDoubleInstanceobj;
         return  == that.i;
       }
       return false;
     }
   }
 
   static class SameShortInstance {
     private final Short i;
 
     public SameShortInstance(Short i) {
       this. = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameShortInstance) {
         SameShortInstance that = (SameShortInstanceobj;
         return  == that.i;
       }
       return false;
     }
   }
 
   static class SameByteInstance {
     private final Byte i;
 
     public SameByteInstance(Byte i) {
       this. = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override
     @SuppressWarnings("NumericEquality")
     public boolean equals(Object obj) {
       if (obj instanceof SameByteInstance) {
         SameByteInstance that = (SameByteInstanceobj;
         return  == that.i;
       }
       return false;
     }
   }
 
   static class SameCharacterInstance {
     private final Character i;
 
     public SameCharacterInstance(Character i) {
       this. = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameCharacterInstance) {
         SameCharacterInstance that = (SameCharacterInstanceobj;
         return  == that.i;
       }
       return false;
     }
   }
 
   static class SameBooleanInstance {
     private final Boolean i;
 
     public SameBooleanInstance(Boolean i) {
       this. = checkNotNull(i);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameBooleanInstance) {
         SameBooleanInstance that = (SameBooleanInstanceobj;
         return  == that.i;
       }
       return false;
     }
   }
 
   static class SameStringInstance {
     private final String s;
 
     public SameStringInstance(String s) {
       this. = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameStringInstance) {
         SameStringInstance that = (SameStringInstanceobj;
         return  == that.s;
       }
       return false;
     }
   }
 
   static class SameObjectInstance {
     private final Object s;
 
     public SameObjectInstance(Object s) {
       this. = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameObjectInstance) {
         SameObjectInstance that = (SameObjectInstanceobj;
         return  == that.s;
       }
       return false;
     }
   }
 
   static class SameInterfaceInstance {
     private final Runnable s;
 
     public SameInterfaceInstance(Runnable s) {
       this. = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameInterfaceInstance) {
         SameInterfaceInstance that = (SameInterfaceInstanceobj;
         return  == that.s;
       }
       return false;
     }
   }
 
   static class SameListInstance {
     private final List<?> s;
 
     public SameListInstance(List<?> s) {
       this. = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return System.identityHashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof SameListInstance) {
         SameListInstance that = (SameListInstanceobj;
         return  == that.s;
       }
       return false;
     }
   }
 
   static class UsesReferentialEquality {
     private final ReferentialEquality s;
 
       this. = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof UsesReferentialEquality) {
         UsesReferentialEquality that = (UsesReferentialEqualityobj;
         return  == that.s;
       }
       return false;
     }
   }
 
   static class UsesEnum {
     private final TimeUnit s;
 
     public UsesEnum(TimeUnit s) {
       this. = checkNotNull(s);
     }
 
     @Override public int hashCode() {
       return .hashCode();
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof UsesEnum) {
         UsesEnum that = (UsesEnumobj;
         return  == that.s;
       }
       return false;
     }
  }
  public static class ReferentialEquality {
    public ReferentialEquality() {}
  }
    // ignored by testEquals() since it has less parameters.
    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 {
      checkNotNull(x);
    }
    @SuppressWarnings("unused"// reflected
    void primitiveOnly(int i) {}
    @SuppressWarnings("unused"//reflected