@Override public SortedMultiset<E> create(Object... entries) { return SerializableTester.reserialize(((SortedMultiset<E>) super.create(entries))); } })
public void testSerialization() { SerializableTester.reserializeAndAssert(HostAndPort.fromParts("host", 80)); SerializableTester.reserializeAndAssert(HostAndPort.fromString("host")); SerializableTester.reserializeAndAssert(HostAndPort.fromString("host:80")); SerializableTester.reserializeAndAssert(HostAndPort.fromString("[::1]:104")); SerializableTester.reserializeAndAssert(HostAndPort.fromParts("1::2", 103)); } }
@GwtIncompatible // SerializableTester public void testViewSerialization() { Map<String, Integer> map = ImmutableSortedMap.of("one", 1, "two", 2, "three", 3); SerializableTester.reserializeAndAssert(map.entrySet()); SerializableTester.reserializeAndAssert(map.keySet()); assertEquals( Lists.newArrayList(map.values()), Lists.newArrayList(SerializableTester.reserialize(map.values()))); }
@GwtIncompatible // SerializableTester public void testViewSerialization() { Map<String, Integer> map = ImmutableSortedMap.of("one", 1, "two", 2, "three", 3); SerializableTester.reserializeAndAssert(map.entrySet()); SerializableTester.reserializeAndAssert(map.keySet()); assertEquals( Lists.newArrayList(map.values()), Lists.newArrayList(SerializableTester.reserialize(map.values()))); }
public void testNewWildcardType_serializable() { SerializableTester.reserializeAndAssert(Types.supertypeOf(String.class)); SerializableTester.reserializeAndAssert(Types.subtypeOf(String.class)); SerializableTester.reserializeAndAssert(Types.subtypeOf(Object.class)); }
@Override public M create(Object... elements) { return SerializableTester.reserialize( ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator()) .create(elements)); }
@GwtIncompatible // SerializableTester public void testViewSerialization() { Map<String, Integer> map = ImmutableSortedMap.of("one", 1, "two", 2, "three", 3); SerializableTester.reserializeAndAssert(map.entrySet()); SerializableTester.reserializeAndAssert(map.keySet()); assertEquals( Lists.newArrayList(map.values()), Lists.newArrayList(SerializableTester.reserialize(map.values()))); }
@Override public void testSerialization() { SerializableTester.reserializeAndAssert(create()); } }
@Override protected SortedMap<String, Integer> makeEmptyMap() throws UnsupportedOperationException { NavigableMap<String, Integer> map = new SafeTreeMap<>(); return SerializableTester.reserialize(map); }
@GwtIncompatible // SerializableTester public void testSerialization() { Multimap<String, Integer> multimap = createMultimap(); SerializableTester.reserializeAndAssert(multimap); assertEquals(multimap.size(), SerializableTester.reserialize(multimap).size()); SerializableTester.reserializeAndAssert(multimap.get("foo")); LenientSerializableTester.reserializeAndAssertLenient(multimap.keySet()); LenientSerializableTester.reserializeAndAssertLenient(multimap.keys()); SerializableTester.reserializeAndAssert(multimap.asMap()); Collection<Integer> valuesCopy = SerializableTester.reserialize(multimap.values()); assertEquals(HashMultiset.create(multimap.values()), HashMultiset.create(valuesCopy)); }
@GwtIncompatible // SerializableTester public void testForMapSerialization() { Map<String, Integer> map = Maps.newHashMap(); map.put("foo", 1); map.put("bar", 2); Multimap<String, Integer> multimapView = Multimaps.forMap(map); SerializableTester.reserializeAndAssert(multimapView); }
public void testEqualsAndHashCode() { new EqualsTester() .addEqualityGroup(Optional.absent(), reserialize(Optional.absent())) .addEqualityGroup(Optional.of(new Long(5)), reserialize(Optional.of(new Long(5)))) .addEqualityGroup(Optional.of(new Long(42)), reserialize(Optional.of(new Long(42)))) .testEquals(); }
@GwtIncompatible // SerializableTester public void testSerialization() { Multimap<String, Integer> multimap = createMultimap(); SerializableTester.reserializeAndAssert(multimap); assertEquals(multimap.size(), SerializableTester.reserialize(multimap).size()); SerializableTester.reserializeAndAssert(multimap.get("foo")); LenientSerializableTester.reserializeAndAssertLenient(multimap.keySet()); LenientSerializableTester.reserializeAndAssertLenient(multimap.keys()); SerializableTester.reserializeAndAssert(multimap.asMap()); Collection<Integer> valuesCopy = SerializableTester.reserialize(multimap.values()); assertEquals(HashMultiset.create(multimap.values()), HashMultiset.create(valuesCopy)); }
@GwtIncompatible // SerializableTester public void testSeveral_serialization() { SortedSet<String> set = new SafeTreeSet<>(); set.add("a"); set.add("b"); set.add("c"); SortedSet<String> copy = SerializableTester.reserializeAndAssert(set); assertEquals(set.comparator(), copy.comparator()); } }
@CollectionFeature.Require(SERIALIZABLE_INCLUDING_VIEWS) public void testEntrySetSerialization() { Set<Multiset.Entry<E>> expected = getMultiset().entrySet(); assertEquals(expected, SerializableTester.reserialize(expected)); }
public void testJavaSerialization() { BloomFilter<byte[]> bf = BloomFilter.create(Funnels.byteArrayFunnel(), 100); for (int i = 0; i < 10; i++) { bf.put(Ints.toByteArray(i)); } BloomFilter<byte[]> copy = SerializableTester.reserialize(bf); for (int i = 0; i < 10; i++) { assertTrue(copy.mightContain(Ints.toByteArray(i))); } assertEquals(bf.expectedFpp(), copy.expectedFpp()); SerializableTester.reserializeAndAssert(bf); }
@GwtIncompatible // SerializableTester public void testComposeSerialization() { Function<String, String> trim = TrimStringFunction.INSTANCE; Predicate<String> equalsFoo = Predicates.equalTo("Foo"); Predicate<String> trimEqualsFoo = Predicates.compose(equalsFoo, trim); SerializableTester.reserializeAndAssert(trimEqualsFoo); }
@CollectionFeature.Require(SERIALIZABLE) public void testInverseSerialization() { BiMapPair<K, V> pair = new BiMapPair<>(getMap()); BiMapPair<K, V> copy = SerializableTester.reserialize(pair); assertEquals(pair.forward, copy.forward); assertEquals(pair.backward, copy.backward); assertSame(copy.backward, copy.forward.inverse()); assertSame(copy.forward, copy.backward.inverse()); }
public void testExplicit_sortingExample() { Comparator<Integer> c = Ordering.explicit(2, 8, 6, 1, 7, 5, 3, 4, 0, 9); List<Integer> list = Arrays.asList(0, 3, 5, 6, 7, 8, 9); Collections.sort(list, c); assertThat(list).containsExactly(8, 6, 7, 5, 3, 0, 9).inOrder(); reserializeAndAssert(c); }
@CollectionFeature.Require(SERIALIZABLE) public void testReserialize() { // For a bare Collection, the most we can guarantee is that the elements are preserved. Helpers.assertEqualIgnoringOrder( actualContents(), SerializableTester.reserialize(actualContents())); } }