Best code snippets using com.google.common.testing.SerializableTester.reserializeAndAssert(Showing top 15 results out of 315)

public void testCreate() {
 ConcurrentHashMultiset<Integer> multiset = ConcurrentHashMultiset.create();
 assertTrue(multiset.isEmpty());
 reserializeAndAssert(multiset);
}

public void testObjectWhichIsEqualButChangesClass() {
 ObjectWhichIsEqualButChangesClass orig = new ObjectWhichIsEqualButChangesClass();
 boolean errorNotThrown = false;
 try {
  SerializableTester.reserializeAndAssert(orig);
  errorNotThrown = true;
 } catch (AssertionFailedError error) {
  // expected
  assertContains("expected:<class ", error.getMessage());
 }
 assertFalse(errorNotThrown);
}

@GwtIncompatible // SerializableTester
public void testNewSetMultimapSerialization() {
 CountingSupplier<Set<Integer>> factory = new SetSupplier();
 Map<Color, Collection<Integer>> map = Maps.newHashMap();
 SetMultimap<Color, Integer> multimap = Multimaps.newSetMultimap(map, factory);
 multimap.putAll(Color.BLUE, asList(3, 1, 4));
 multimap.putAll(Color.RED, asList(2, 7, 1, 8));
 SerializableTester.reserializeAndAssert(multimap);
}

@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);
}

public void testSerialization_andThen() {
 Converter<String, Long> converterA = Longs.stringConverter();
 Converter<Long, String> reverseConverter = Longs.stringConverter().reverse();
 Converter<String, String> composedConverter = converterA.andThen(reverseConverter);
 SerializableTester.reserializeAndAssert(composedConverter);
}

@GwtIncompatible // SerializableTester
public void testDifferentComparator_serialization() {
 // don't use Collections.reverseOrder(); it didn't reserialize to the same instance in JDK5
 Comparator<Comparable<?>> comparator = Ordering.natural().reverse();
 SortedSet<String> set =
   new ImmutableSortedSet.Builder<String>(comparator).add("a", "b", "c").build();
 SortedSet<String> copy = SerializableTester.reserializeAndAssert(set);
 assertTrue(Iterables.elementsEqual(set, copy));
 assertEquals(set.comparator(), copy.comparator());
}

@GwtIncompatible // SerializableTester
public void testOf_serialization() {
 SortedSet<String> set = of("e", "f", "b", "d", "c");
 SortedSet<String> copy = SerializableTester.reserializeAndAssert(set);
 assertTrue(Iterables.elementsEqual(set, copy));
 assertEquals(set.comparator(), copy.comparator());
}

@GwtIncompatible // SerializableTester
public void testNewSetFromMapSerialization() {
 Set<Integer> set = Sets.newSetFromMap(new LinkedHashMap<Integer, Boolean>());
 set.addAll(SOME_COLLECTION);
 Set<Integer> copy = SerializableTester.reserializeAndAssert(set);
 assertThat(copy).containsExactly(0, 1).inOrder();
}

@GwtIncompatible // SerializableTester
public void testSingle_serialization() {
 SortedSet<String> set = new SafeTreeSet<>();
 set.add("e");
 SortedSet<String> copy = SerializableTester.reserializeAndAssert(set);
 assertEquals(set.comparator(), copy.comparator());
}

 @GwtIncompatible // SerializableTester
 private static void checkSerialization(Predicate<? super Integer> predicate) {
  Predicate<? super Integer> reserialized = SerializableTester.reserializeAndAssert(predicate);
  assertEvalsLike(predicate, reserialized);
 }
}

public void testAsConverter_serialization() {
 ImmutableBiMap<String, Integer> biMap =
   ImmutableBiMap.of(
     "one", 1,
     "two", 2);
 Converter<String, Integer> converter = Maps.asConverter(biMap);
 SerializableTester.reserializeAndAssert(converter);
}

public void testCreateFromIterable() {
 Iterable<Integer> iterable = asList(1, 2, 2, 3, 4);
 ConcurrentHashMultiset<Integer> multiset = ConcurrentHashMultiset.create(iterable);
 assertEquals(2, multiset.count(2));
 reserializeAndAssert(multiset);
}

@GwtIncompatible // SerializableTester, ImmutableSortedAsList
public void testSubsetAsListReturnTypeAndSerialization() {
 ImmutableSet<String> set = ImmutableSortedSet.of("a", "e", "i", "o", "u").subSet("c", "r");
 ImmutableList<String> list = set.asList();
 assertTrue(list instanceof ImmutableSortedAsList);
 ImmutableList<String> copy = SerializableTester.reserializeAndAssert(list);
 assertTrue(copy instanceof ImmutableSortedAsList);
}

 @Override
 public void testSerialization() {
  SerializableTester.reserializeAndAssert(create());
 }
}

 @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());
 }
}