Java

1
/*
2
 * Copyright (C) 2009 The Guava Authors
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 * http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16

17
package com.google.common.testing;
18

19
import java.io.Serializable;
20
import junit.framework.AssertionFailedError;
21
import junit.framework.TestCase;
22
import org.checkerframework.checker.nullness.qual.Nullable;
23

24
/**
25
 * Tests for {@link SerializableTester}.
26
 *
27
 * @author Nick Kralevich
28
 */
29
public class SerializableTesterTest extends TestCase {
30
  public void testStringAssertions() {
31
    String original = "hello world";
32
    String copy = SerializableTester.reserializeAndAssert(original);
33
    assertEquals(original, copy);
34
    assertNotSame(original, copy);
35
  }
36

37
  public void testClassWhichDoesNotImplementEquals() {
38
    ClassWhichDoesNotImplementEquals orig = new ClassWhichDoesNotImplementEquals();
39
    boolean errorNotThrown = false;
40
    try {
41
      SerializableTester.reserializeAndAssert(orig);
42
      errorNotThrown = true;
43
    } catch (AssertionFailedError error) {
44
      // expected
45
      assertContains("must be Object#equals to", error.getMessage());
46
    }
47
    assertFalse(errorNotThrown);
48
  }
49

50
  public void testClassWhichIsAlwaysEqualButHasDifferentHashcodes() {
51
    ClassWhichIsAlwaysEqualButHasDifferentHashcodes orig =
52
        new ClassWhichIsAlwaysEqualButHasDifferentHashcodes();
53
    boolean errorNotThrown = false;
54
    try {
55
      SerializableTester.reserializeAndAssert(orig);
56
      errorNotThrown = true;
57
    } catch (AssertionFailedError error) {
58
      // expected
59
      assertContains("must be equal to the Object#hashCode", error.getMessage());
60
    }
61
    assertFalse(errorNotThrown);
62
  }
63

64
  public void testObjectWhichIsEqualButChangesClass() {
65
    ObjectWhichIsEqualButChangesClass orig = new ObjectWhichIsEqualButChangesClass();
66
    boolean errorNotThrown = false;
67
    try {
68
      SerializableTester.reserializeAndAssert(orig);
69
      errorNotThrown = true;
70
    } catch (AssertionFailedError error) {
71
      // expected
72
      assertContains("expected:<class ", error.getMessage());
73
    }
74
    assertFalse(errorNotThrown);
75
  }
76

77
  private static class ClassWhichDoesNotImplementEquals implements Serializable {
78
    private static final long serialVersionUID = 1L;
79
  }
80

81
  private static class ClassWhichIsAlwaysEqualButHasDifferentHashcodes implements Serializable {
82
    private static final long serialVersionUID = 2L;
83

84
    @SuppressWarnings("EqualsHashCode")
85
    @Override
86
    public boolean equals(@Nullable Object other) {
87
      return (other instanceof ClassWhichIsAlwaysEqualButHasDifferentHashcodes);
88
    }
89
  }
90

91
  private static class ObjectWhichIsEqualButChangesClass implements Serializable {
92
    private static final long serialVersionUID = 1L;
93

94
    @Override
95
    public boolean equals(@Nullable Object other) {
96
      return (other instanceof ObjectWhichIsEqualButChangesClass || other instanceof OtherForm);
97
    }
98

99
    @Override
100
    public int hashCode() {
101
      return 1;
102
    }
103

104
    private Object writeReplace() {
105
      return new OtherForm();
106
    }
107

108
    private static class OtherForm implements Serializable {
109
      @Override
110
      public boolean equals(@Nullable Object other) {
111
        return (other instanceof ObjectWhichIsEqualButChangesClass || other instanceof OtherForm);
112
      }
113

114
      @Override
115
      public int hashCode() {
116
        return 1;
117
      }
118
    }
119
  }
120

121
  private static void assertContains(String expectedSubstring, String actual) {
122
    // TODO(kevinb): use a Truth assertion here
123
    if (!actual.contains(expectedSubstring)) {
124
      fail("expected <" + actual + "> to contain <" + expectedSubstring + ">");
125
    }
126
  }
127
}
128