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 junit.framework.AssertionFailedError; 20 import junit.framework.TestCase; 21 22 import java.io.Serializable; 23 24 /** 25 * Tests for {@link SerializableTester}. 26 * 27 * @author Nick Kralevich 28 */ 29 public class SerializableTesterTest extends TestCase { testStringAssertions()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 testClassWhichDoesNotImplementEquals()37 public void testClassWhichDoesNotImplementEquals() { 38 ClassWhichDoesNotImplementEquals orig = 39 new ClassWhichDoesNotImplementEquals(); 40 boolean errorNotThrown = false; 41 try { 42 SerializableTester.reserializeAndAssert(orig); 43 errorNotThrown = true; 44 } catch (AssertionFailedError error) { 45 // expected 46 assertContains("must be Object#equals to", error.getMessage()); 47 } 48 assertFalse(errorNotThrown); 49 } 50 testClassWhichIsAlwaysEqualButHasDifferentHashcodes()51 public void testClassWhichIsAlwaysEqualButHasDifferentHashcodes() { 52 ClassWhichIsAlwaysEqualButHasDifferentHashcodes orig = 53 new ClassWhichIsAlwaysEqualButHasDifferentHashcodes(); 54 boolean errorNotThrown = false; 55 try { 56 SerializableTester.reserializeAndAssert(orig); 57 errorNotThrown = true; 58 } catch (AssertionFailedError error) { 59 // expected 60 assertContains("must be equal to the Object#hashCode", error.getMessage()); 61 } 62 assertFalse(errorNotThrown); 63 } 64 testObjectWhichIsEqualButChangesClass()65 public void testObjectWhichIsEqualButChangesClass() { 66 ObjectWhichIsEqualButChangesClass orig = 67 new ObjectWhichIsEqualButChangesClass(); 68 boolean errorNotThrown = false; 69 try { 70 SerializableTester.reserializeAndAssert(orig); 71 errorNotThrown = true; 72 } catch (AssertionFailedError error) { 73 // expected 74 assertContains("expected:<class ", error.getMessage()); 75 } 76 assertFalse(errorNotThrown); 77 } 78 79 private static class ClassWhichDoesNotImplementEquals 80 implements Serializable { 81 private static final long serialVersionUID = 1L; 82 } 83 84 private static class ClassWhichIsAlwaysEqualButHasDifferentHashcodes 85 implements Serializable { 86 private static final long serialVersionUID = 2L; 87 88 @Override equals(Object other)89 public boolean equals(Object other) { 90 return (other instanceof ClassWhichIsAlwaysEqualButHasDifferentHashcodes); 91 } 92 } 93 94 private static class ObjectWhichIsEqualButChangesClass 95 implements Serializable { 96 private static final long serialVersionUID = 1L; 97 98 @Override equals(Object other)99 public boolean equals(Object other) { 100 return (other instanceof ObjectWhichIsEqualButChangesClass 101 || other instanceof OtherForm); 102 } 103 104 @Override hashCode()105 public int hashCode() { 106 return 1; 107 } 108 writeReplace()109 private Object writeReplace() { 110 return new OtherForm(); 111 } 112 113 private static class OtherForm implements Serializable { 114 @Override equals(Object other)115 public boolean equals(Object other) { 116 return (other instanceof ObjectWhichIsEqualButChangesClass 117 || other instanceof OtherForm); 118 } 119 120 @Override hashCode()121 public int hashCode() { 122 return 1; 123 } 124 } 125 } 126 assertContains(String expectedSubstring, String actual)127 private static void assertContains(String expectedSubstring, String actual) { 128 // TODO(kevinb): use a Truth assertion here 129 if (!actual.contains(expectedSubstring)) { 130 fail("expected <" + actual + "> to contain <" + expectedSubstring + ">"); 131 } 132 } 133 } 134