Java SerializableTester.reserialize方法代码示例

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
public <A extends Iterable<? extends String>, B extends A> void testSerializable() {
  reserialize(TypeToken.of(String.class));
  reserialize(TypeToken.of(String.class).getTypes());
  reserialize(TypeToken.of(String.class).getTypes().classes());
  reserialize(TypeToken.of(String.class).getTypes().interfaces());
  reserialize(TypeToken.of(String.class).getTypes().rawTypes());
  reserialize(TypeToken.of(String.class).getTypes().classes().rawTypes());
  reserialize(TypeToken.of(String.class).getTypes().interfaces().rawTypes());
  reserialize(new TypeToken<int[]>() {});
  reserialize(new TypeToken<Map<String, Integer>>() {});
  reserialize(new IKnowMyType<Map<? super String, ? extends int[]>>() {}.type());
  reserialize(TypeToken.of(new TypeCapture<B>() {}.capture()).getTypes().rawTypes());
  try {
    SerializableTester.reserialize(TypeToken.of(new TypeCapture<B>() {}.capture()));
    fail();
  } catch (RuntimeException expected) {}
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@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));
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
public void testSerialization() {
  EvictingQueue<String> original = EvictingQueue.create(5);
  original.add("one");
  original.add("two");
  original.add("three");

  EvictingQueue<String> copy = SerializableTester.reserialize(original);
  assertEquals(copy.maxSize, original.maxSize);
  assertEquals("one", copy.remove());
  assertEquals("two", copy.remove());
  assertEquals("three", copy.remove());
  assertTrue(copy.isEmpty());
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@Test
public void serializable() {
    ActorCreationRequest expected = makeRequest();
    ActorCreationRequest actual = SerializableTester.reserialize(expected);

    assertThat(expected.getActorConfig(), is(actual.getActorConfig()));
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@GwtIncompatible // SerializableTester
public void testSerializationContainingSelf() {
  Multiset<Multiset<?>> multiset = HashMultiset.create();
  multiset.add(multiset, 2);
  Multiset<Multiset<?>> copy = SerializableTester.reserialize(multiset);
  assertEquals(2, copy.size());
  assertSame(copy, copy.iterator().next());
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@CanIgnoreReturnValue
private static <T> T reserialize(T object) {
  T copy = SerializableTester.reserialize(object);
  new EqualsTester()
      .addEqualityGroup(object, copy)
      .testEquals();
  return copy;
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@Test
public void serializable() {
    AgentKey expected = AGENT_KEY;
    AgentKey actual = SerializableTester.reserialize(expected);
    assertThat(expected.getName(), is(actual.getName()));
    assertThat(expected, is(actual));
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@Test
public void serializable() {
    JgroupsStateKey expected = makeKey();
    JgroupsStateKey actual = SerializableTester.reserialize(expected);

    assertThat(expected, is(actual));
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@Test
public void serialize_deserialize() {
    AgentRegistrationMessage received = SerializableTester.reserialize(msg);

    assertThat(received.getCreationTime(), is(msg.getCreationTime()));
    assertThat(received.getKey(), is(msg.getKey()));
    assertThat(received.getEndpoint(), is(msg.getEndpoint()));
    assertNotNull(received.getSystemConfig());
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@Test
public void serializable() {
    MetricValuesMessage expected = metricValues(3);
    MetricValuesMessage actual = SerializableTester.reserialize(expected);

    assertThat(actual.metrics().size(), is(expected.metrics().size()));
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
void go() {
  SerializableTester.reserialize(TypeToken.of(new TypeCapture<T>() {}.capture()));
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@GwtIncompatible // SerializableTester
public void testEmpty_serialization() {
  SortedSet<String> set = of();
  SortedSet<String> copy = SerializableTester.reserialize(set);
  assertSame(set, copy);
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@Override
public Multiset<E> create(Object... elements) {
  return (Multiset<E>) SerializableTester.reserialize(gen.create(elements));
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
public void testSerializationProxyLoading() {
  CacheLoader<Object, Object> loader = new SerializableCacheLoader();
  RemovalListener<Object, Object> listener = new SerializableRemovalListener<Object, Object>();
  SerializableWeigher<Object, Object> weigher = new SerializableWeigher<Object, Object>();
  Ticker ticker = new SerializableTicker();
  @SuppressWarnings("unchecked") // createMock
  LocalLoadingCache<Object, Object> one = (LocalLoadingCache) CacheBuilder.newBuilder()
      .weakKeys()
      .softValues()
      .expireAfterAccess(123, SECONDS)
      .expireAfterWrite(456, MINUTES)
      .maximumWeight(789)
      .weigher(weigher)
      .concurrencyLevel(12)
      .removalListener(listener)
      .ticker(ticker)
      .build(loader);
  // add a non-serializable entry
  one.getUnchecked(new Object());
  assertEquals(1, one.size());
  assertFalse(one.asMap().isEmpty());
  LocalLoadingCache<Object, Object> two = SerializableTester.reserialize(one);
  assertEquals(0, two.size());
  assertTrue(two.asMap().isEmpty());

  LocalCache<Object, Object> localCacheOne = one.localCache;
  LocalCache<Object, Object> localCacheTwo = two.localCache;

  assertEquals(localCacheOne.keyStrength, localCacheTwo.keyStrength);
  assertEquals(localCacheOne.keyStrength, localCacheTwo.keyStrength);
  assertEquals(localCacheOne.valueEquivalence, localCacheTwo.valueEquivalence);
  assertEquals(localCacheOne.valueEquivalence, localCacheTwo.valueEquivalence);
  assertEquals(localCacheOne.maxWeight, localCacheTwo.maxWeight);
  assertEquals(localCacheOne.weigher, localCacheTwo.weigher);
  assertEquals(localCacheOne.expireAfterAccessNanos, localCacheTwo.expireAfterAccessNanos);
  assertEquals(localCacheOne.expireAfterWriteNanos, localCacheTwo.expireAfterWriteNanos);
  assertEquals(localCacheOne.refreshNanos, localCacheTwo.refreshNanos);
  assertEquals(localCacheOne.removalListener, localCacheTwo.removalListener);
  assertEquals(localCacheOne.ticker, localCacheTwo.ticker);

  // serialize the reconstituted version to be sure we haven't lost the ability to reserialize
  LocalLoadingCache<Object, Object> three = SerializableTester.reserialize(two);
  LocalCache<Object, Object> localCacheThree = three.localCache;

  assertEquals(localCacheTwo.defaultLoader, localCacheThree.defaultLoader);
  assertEquals(localCacheTwo.keyStrength, localCacheThree.keyStrength);
  assertEquals(localCacheTwo.keyStrength, localCacheThree.keyStrength);
  assertEquals(localCacheTwo.valueEquivalence, localCacheThree.valueEquivalence);
  assertEquals(localCacheTwo.valueEquivalence, localCacheThree.valueEquivalence);
  assertEquals(localCacheTwo.maxWeight, localCacheThree.maxWeight);
  assertEquals(localCacheTwo.weigher, localCacheThree.weigher);
  assertEquals(localCacheTwo.expireAfterAccessNanos, localCacheThree.expireAfterAccessNanos);
  assertEquals(localCacheTwo.expireAfterWriteNanos, localCacheThree.expireAfterWriteNanos);
  assertEquals(localCacheTwo.removalListener, localCacheThree.removalListener);
  assertEquals(localCacheTwo.ticker, localCacheThree.ticker);
}
 

import com.google.common.testing.SerializableTester; //导入方法依赖的package包/类
@Override
public Set<E> create(Object... elements) {
  return (Set<E>) SerializableTester.reserialize(gen.create(elements));
}