/** * Returns a fresh instance for {@code type} if possible. The returned instance could be: * * <ul> * <li>exactly of the given type, including generic type parameters, such as {@code * ImmutableList<String>}; * <li>of the raw type; * <li>null if no value can be generated. * </ul> */ @Nullable final Object generateFresh(TypeToken<?> type) { Object generated = generate(type); if (generated != null) { freshness.incrementAndGet(); } return generated; }
private static Object[] getParameterValues(Method method) { FreshValueGenerator paramValues = new FreshValueGenerator(); final List<Object> passedArgs = Lists.newArrayList(); for (Class<?> paramType : method.getParameterTypes()) { passedArgs.add(paramValues.generate(paramType)); } return passedArgs.toArray(); }
public void testImmutableTable() { assertFreshInstance(new TypeToken<ImmutableTable<String, Integer, ImmutableList<String>>>() {}); FreshValueGenerator generator = new FreshValueGenerator(); assertValueAndTypeEquals( ImmutableTable.of( generator.generate(String.class), generator.generate(int.class), generator.generate(new TypeToken<ImmutableList<String>>() {})), new FreshValueGenerator().generate( new TypeToken<ImmutableTable<String, Integer, ImmutableList<String>>>() {})); }
public void testImmutableMap() { assertFreshInstance(new TypeToken<ImmutableMap<String, Integer>>() {}); FreshValueGenerator generator = new FreshValueGenerator(); assertValueAndTypeEquals( ImmutableMap.of(generator.generate(String.class), generator.generate(int.class)), new FreshValueGenerator().generate(new TypeToken<ImmutableMap<String, Integer>>() {})); }
public void testTable() { assertFreshInstance(new TypeToken<Table<String, ?, ?>>() {}); FreshValueGenerator generator = new FreshValueGenerator(); Table<String, Integer, Object> expected = HashBasedTable.create(); expected.put(generator.generate(String.class), generator.generate(int.class), generator.generate(new TypeToken<List<String>>() {})); assertValueAndTypeEquals(expected, new FreshValueGenerator().generate( new TypeToken<Table<String, Integer, List<String>>>() {})); assertNotInstantiable(new TypeToken<Table<EmptyEnum, String, Integer>>() {}); }
public void testImmutableSet() { assertFreshInstance(new TypeToken<ImmutableSet<String>>() {}); assertValueAndTypeEquals(ImmutableSet.of(new FreshValueGenerator().generate(String.class)), new FreshValueGenerator().generate(new TypeToken<ImmutableSet<String>>() {})); assertValueAndTypeEquals(ImmutableSet.of(new FreshValueGenerator().generate(Number.class)), new FreshValueGenerator().generate(new TypeToken<ImmutableSet<Number>>() {})); assertValueAndTypeEquals(ImmutableSet.of(new FreshValueGenerator().generate(Number.class)), new FreshValueGenerator().generate(new TypeToken<ImmutableSet<? extends Number>>() {})); }
public void testArrayListMultimap() { assertFreshInstance(new TypeToken<ArrayListMultimap<String, ?>>() {}); FreshValueGenerator generator = new FreshValueGenerator(); ArrayListMultimap<String, Integer> expected = ArrayListMultimap.create(); expected.put(generator.generate(String.class), generator.generate(int.class)); assertValueAndTypeEquals(expected, new FreshValueGenerator().generate( new TypeToken<ArrayListMultimap<String, Integer>>() {})); }
public void testImmutableSetMultimap() { assertFreshInstance(new TypeToken<ImmutableSetMultimap<String, Integer>>() {}); FreshValueGenerator generator = new FreshValueGenerator(); assertValueAndTypeEquals( ImmutableSetMultimap.of(generator.generate(String.class), generator.generate(int.class)), new FreshValueGenerator().generate( new TypeToken<ImmutableSetMultimap<String, Integer>>() {})); }
public void testImmutableSortedMap() { assertFreshInstance(new TypeToken<ImmutableSortedMap<String, Integer>>() {}); FreshValueGenerator generator = new FreshValueGenerator(); assertValueAndTypeEquals( ImmutableSortedMap.of(generator.generate(String.class), generator.generate(int.class)), new FreshValueGenerator().generate( new TypeToken<ImmutableSortedMap<String, Integer>>() {})); }
public void testImmutableListMultimap() { assertFreshInstance(new TypeToken<ImmutableListMultimap<String, Integer>>() {}); FreshValueGenerator generator = new FreshValueGenerator(); assertValueAndTypeEquals( ImmutableListMultimap.of(generator.generate(String.class), generator.generate(int.class)), new FreshValueGenerator().generate( new TypeToken<ImmutableListMultimap<String, Integer>>() {})); }
public void testMultiset() { assertFreshInstance(new TypeToken<Multiset<String>>() {}); Multiset<String> expected = HashMultiset.create(); expected.add(new FreshValueGenerator().generate(String.class)); assertValueAndTypeEquals(expected, new FreshValueGenerator().generate(new TypeToken<Multiset<String>>() {})); assertNotInstantiable(new TypeToken<Multiset<EmptyEnum>>() {}); }
public void testTreeSet() { assertFreshInstance(new TypeToken<TreeSet<String>>() {}); TreeSet<String> expected = Sets.newTreeSet(); expected.add(new FreshValueGenerator().generate(String.class)); assertValueAndTypeEquals(expected, new FreshValueGenerator().generate(new TypeToken<TreeSet<? extends CharSequence>>() {})); assertNotInstantiable(new TypeToken<TreeSet<EmptyEnum>>() {}); }
public void testIterable() { assertFreshInstance(new TypeToken<Iterable<String>>() {}); assertValueAndTypeEquals(Lists.newArrayList(new FreshValueGenerator().generate(String.class)), new FreshValueGenerator().generate(new TypeToken<Iterable<String>>() {})); assertNotInstantiable(new TypeToken<Iterable<EmptyEnum>>() {}); }
public void testLinkedHashMultiset() { assertFreshInstance(new TypeToken<LinkedHashMultiset<String>>() {}); LinkedHashMultiset<String> expected = LinkedHashMultiset.create(); expected.add(new FreshValueGenerator().generate(String.class)); assertValueAndTypeEquals(expected, new FreshValueGenerator().generate(new TypeToken<LinkedHashMultiset<String>>() {})); }