Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2011 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.checkState;
 import static org.truth0.Truth.ASSERT;
 
 
Tests for EquivalenceTester.

Author(s):
Gregory Kick
 
 public class EquivalenceTesterTest extends TestCase {
 
   @Override public void setUp() throws Exception {
     super.setUp();
     this. = new MockEquivalence();
     this. = EquivalenceTester.of();
   }

  
Test null reference yields error
 
   public void testOf_NullPointerException() {
     try {
       EquivalenceTester.of(null);
       fail("Should fail on null reference");
     } catch (NullPointerException expected) {}
   }
 
   public void testTest_NoData() {
     .test();
   }
 
   public void testTest() {
     Object group1Item1 = new TestObject(1, 1);
     Object group1Item2 = new TestObject(1, 2);
     Object group2Item1 = new TestObject(2, 1);
     Object group2Item2 = new TestObject(2, 2);
 
     .expectEquivalent(group1Item1group1Item2);
     .expectDistinct(group1Item1group2Item1);
     .expectDistinct(group1Item1group2Item2);
     .expectEquivalent(group1Item2group1Item1);
     .expectDistinct(group1Item2group2Item1);
     .expectDistinct(group1Item2group2Item2);
     .expectDistinct(group2Item1group1Item1);
     .expectDistinct(group2Item1group1Item2);
     .expectEquivalent(group2Item1group2Item2);
     .expectDistinct(group2Item2group1Item1);
     .expectDistinct(group2Item2group1Item2);
     .expectEquivalent(group2Item2group2Item1);
 
     .expectHash(group1Item1, 1);
     .expectHash(group1Item2, 1);
     .expectHash(group2Item1, 2);
     .expectHash(group2Item2, 2);
 
 
     .addEquivalenceGroup(group1Item1group1Item2)
         .addEquivalenceGroup(group2Item1group2Item2)
         .test();
   }
 
   public void testTest_symmetric() {
     Object group1Item1 = new TestObject(1, 1);
     Object group1Item2 = new TestObject(1, 2);
 
     .expectEquivalent(group1Item1group1Item2);
     .expectDistinct(group1Item2group1Item1);
 
     .expectHash(group1Item1, 1);
     .expectHash(group1Item2, 1);
 
    try {
      .addEquivalenceGroup(group1Item1group1Item2).test();
    } catch (AssertionFailedError expected) {
      .that(expected.getMessage()).contains(
          "TestObject{group=1, item=2} [group 1, item 2] must be equivalent to "
          + "TestObject{group=1, item=1} [group 1, item 1]");
      return;
    }
    fail();
  }
  public void testTest_trasitive() {
    Object group1Item1 = new TestObject(1, 1);
    Object group1Item2 = new TestObject(1, 2);
    Object group1Item3 = new TestObject(1, 3);
    .expectEquivalent(group1Item1group1Item2);
    .expectEquivalent(group1Item1group1Item3);
    .expectEquivalent(group1Item2group1Item1);
    .expectDistinct(group1Item2group1Item3);
    .expectEquivalent(group1Item3group1Item1);
    .expectEquivalent(group1Item3group1Item2);
    .expectHash(group1Item1, 1);
    .expectHash(group1Item2, 1);
    .expectHash(group1Item3, 1);
    try {
      .addEquivalenceGroup(group1Item1group1Item2group1Item3).test();
    } catch (AssertionFailedError expected) {
      .that(expected.getMessage()).contains(
          "TestObject{group=1, item=2} [group 1, item 2] must be equivalent to "
          + "TestObject{group=1, item=3} [group 1, item 3]");
      return;
    }
    fail();
  }
  public void testTest_inequivalence() {
    Object group1Item1 = new TestObject(1, 1);
    Object group2Item1 = new TestObject(2, 1);
    .expectEquivalent(group1Item1group2Item1);
    .expectDistinct(group2Item1group1Item1);
    .expectHash(group1Item1, 1);
    .expectHash(group2Item1, 2);
    try {
      .addEquivalenceGroup(group1Item1).addEquivalenceGroup(group2Item1).test();
    } catch (AssertionFailedError expected) {
      .that(expected.getMessage()).contains(
          "TestObject{group=1, item=1} [group 1, item 1] must not be equivalent to "
          + "TestObject{group=2, item=1} [group 2, item 1]");
      return;
    }
    fail();
  }
  public void testTest_hash() {
    Object group1Item1 = new TestObject(1, 1);
    Object group1Item2 = new TestObject(1, 2);
    .expectEquivalent(group1Item1group1Item2);
    .expectEquivalent(group1Item2group1Item1);
    .expectHash(group1Item1, 1);
    .expectHash(group1Item2, 2);
    try {
      .addEquivalenceGroup(group1Item1group1Item2).test();
    } catch (AssertionFailedError expected) {
      String expectedMessage =
          "the hash (1) of TestObject{group=1, item=1} [group 1, item 1] must be "
          + "equal to the hash (2) of TestObject{group=1, item=2} [group 1, item 2]";
      if (!expected.getMessage().contains(expectedMessage)) {
        fail("<" + expected.getMessage() + "> expected to contain <" + expectedMessage + ">");
      }
      return;
    }
    fail();
  }

  
An object with a friendly toString().
  private static final class TestObject {
    final int group;
    final int item;
    TestObject(int group , int item) {
      this. = group;
      this. = item;
    }
    @Override public String toString() {
      return Objects.toStringHelper("TestObject")
          .add("group")
          .add("item")
          .toString();
    }
  }
  private static final class MockEquivalence extends Equivalence<Object> {
        ImmutableTable.builder();
        ImmutableMap.builder();
    void expectEquivalent(Object aObject b) {
      checkRecording();
      .put(abtrue);
    }
    void expectDistinct(Object aObject b) {
      checkRecording();
      .put(abfalse);
    }
    void expectHash(Object objectint hash) {
      checkRecording();
      .put(objecthash);
    }
    void replay() {
      checkRecording();
    }
    @Override protected boolean doEquivalent(Object aObject b) {
      return .get(ab);
    }
    @Override protected int doHash(Object object) {
      return .get(object);
    }
    void checkRecording() {
      checkState( == null &&  == null);
    }
  }
New to GrepCode? Check out our FAQ X