Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2012 The Guava Authors
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.google.common.testing;
 
 
 
 import java.io.File;
 import java.io.Reader;
 import java.io.Writer;
 import java.util.List;
 import java.util.Map;
Tests for FreshValueGenerator.

Author(s):
Ben Yu
public class FreshValueGeneratorTest extends TestCase {
  public void testFreshInstance() {
        String.classCharSequence.class,
        Appendable.classStringBuffer.classStringBuilder.class,
        Pattern.classMatchResult.class,
        Number.classint.classInteger.class,
        long.classLong.class,
        short.classShort.class,
        byte.classByte.class,
        boolean.classBoolean.class,
        char.classCharacter.class,
        int[].classObject[].class,
        UnsignedInteger.classUnsignedLong.class,
        BigInteger.classBigDecimal.class,
        Throwable.classError.classException.classRuntimeException.class,
        Charset.classLocale.classCurrency.class,
        List.classMap.Entry.class,
        Object.class,
        Equivalence.classPredicate.classFunction.class,
        Comparable.classComparator.classOrdering.class,
        Class.classType.classTypeToken.class,
        TimeUnit.classTicker.class,
        Joiner.classSplitter.classCharMatcher.class,
        InputStream.classByteArrayInputStream.class,
        Reader.classReadable.classStringReader.class,
        OutputStream.classByteArrayOutputStream.class,
        Writer.classStringWriter.classFile.class,
        Buffer.classByteBuffer.classCharBuffer.class,
        ShortBuffer.classIntBuffer.classLongBuffer.class,
        FloatBuffer.classDoubleBuffer.class,
        String[].classObject[].classint[].class);
  }
  public void testStringArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    String[] a1 = generator.generate(String[].class);
    String[] a2 = generator.generate(String[].class);
    assertFalse(a1[0].equals(a2[0]));
  }
  public void testPrimitiveArray() {
    FreshValueGenerator generator = new FreshValueGenerator();
    int[] a1 = generator.generate(int[].class);
    int[] a2 = generator.generate(int[].class);
    assertTrue(a1[0] != a2[0]);
  }
  public void testImmutableList() {
    assertValueAndTypeEquals(ImmutableList.of(new FreshValueGenerator().generate(String.class)),
        new FreshValueGenerator().generate(new TypeToken<ImmutableList<String>>() {}));
    assertValueAndTypeEquals(ImmutableList.of(new FreshValueGenerator().generate(int.class)),
        new FreshValueGenerator().generate(new TypeToken<ImmutableList<Integer>>() {}));
    assertValueAndTypeEquals(ImmutableList.of(new FreshValueGenerator().generate(String.class)),
        new FreshValueGenerator().generate(new TypeToken<ImmutableList<?>>() {}));
    assertValueAndTypeEquals(ImmutableList.of(),
        new FreshValueGenerator().generate(new TypeToken<ImmutableList<EmptyEnum>>() {}));
  }
  public void testImmutableSet() {
        new FreshValueGenerator().generate(new TypeToken<ImmutableSet<String>>() {}));
        new FreshValueGenerator().generate(new TypeToken<ImmutableSet<Number>>() {}));
        new FreshValueGenerator().generate(new TypeToken<ImmutableSet<? extends Number>>() {}));
    assertValueAndTypeEquals(ImmutableSet.of(),
        new FreshValueGenerator().generate(new TypeToken<ImmutableSet<EmptyEnum>>() {}));
  }
  public void testImmutableSortedSet() {
        ImmutableSortedSet.of(new FreshValueGenerator().generate(String.class)),
        new FreshValueGenerator().generate(new TypeToken<ImmutableSortedSet<String>>() {}));
    assertValueAndTypeEquals(ImmutableSortedSet.of(),
  }
  public void testImmutableMultiset() {
    assertValueAndTypeEquals(ImmutableMultiset.of(new FreshValueGenerator().generate(String.class)),
        new FreshValueGenerator().generate(new TypeToken<ImmutableMultiset<String>>() {}));
    assertValueAndTypeEquals(ImmutableMultiset.of(new FreshValueGenerator().generate(Number.class)),
        new FreshValueGenerator().generate(new TypeToken<ImmutableMultiset<Number>>() {}));
    assertValueAndTypeEquals(ImmutableMultiset.of(),
  }
  public void testImmutableCollection() {
    assertValueAndTypeEquals(ImmutableList.of(new FreshValueGenerator().generate(String.class)),
        new FreshValueGenerator().generate(new TypeToken<ImmutableCollection<String>>() {}));
    assertValueAndTypeEquals(ImmutableList.of(),
  }
  public void testImmutableMap() {
    FreshValueGenerator generator = new FreshValueGenerator();
        ImmutableMap.of(generator.generate(String.class), generator.generate(int.class)),
        new FreshValueGenerator().generate(new TypeToken<ImmutableMap<StringInteger>>() {}));
    assertValueAndTypeEquals(ImmutableMap.of(),
        new FreshValueGenerator().generate(new TypeToken<ImmutableMap<EmptyEnumString>>() {}));
  }
  public void testImmutableSortedMap() {
    FreshValueGenerator generator = new FreshValueGenerator();
        ImmutableSortedMap.of(generator.generate(String.class), generator.generate(int.class)),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableSortedMap<StringInteger>>() {}));
    assertValueAndTypeEquals(ImmutableSortedMap.of(),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableSortedMap<EmptyEnumString>>() {}));
  }
  public void testImmutableMultimap() {
    FreshValueGenerator generator = new FreshValueGenerator();
        ImmutableMultimap.of(generator.generate(String.class), generator.generate(int.class)),
        new FreshValueGenerator().generate(new TypeToken<ImmutableMultimap<StringInteger>>() {}));
    assertValueAndTypeEquals(ImmutableMultimap.of(),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableMultimap<EmptyEnumString>>() {}));
  }
  public void testImmutableListMultimap() {
    FreshValueGenerator generator = new FreshValueGenerator();
        ImmutableListMultimap.of(generator.generate(String.class), generator.generate(int.class)),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableListMultimap<StringInteger>>() {}));
    assertValueAndTypeEquals(ImmutableListMultimap.of(),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableListMultimap<EmptyEnumString>>() {}));
  }
  public void testImmutableSetMultimap() {
    FreshValueGenerator generator = new FreshValueGenerator();
        ImmutableSetMultimap.of(generator.generate(String.class), generator.generate(int.class)),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableSetMultimap<StringInteger>>() {}));
    assertValueAndTypeEquals(ImmutableSetMultimap.of(),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableSetMultimap<EmptyEnumString>>() {}));
  }
  public void testImmutableBiMap() {
    FreshValueGenerator generator = new FreshValueGenerator();
        ImmutableBiMap.of(generator.generate(String.class), generator.generate(int.class)),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableBiMap<StringInteger>>() {}));
    assertValueAndTypeEquals(ImmutableBiMap.of(),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableBiMap<EmptyEnumString>>() {}));
  }
  public void testImmutableTable() {
    FreshValueGenerator generator = new FreshValueGenerator();
        ImmutableTable.of(
            generator.generate(String.class), generator.generate(int.class),
            generator.generate(new TypeToken<ImmutableList<String>>() {})),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableTable<StringIntegerImmutableList<String>>>() {}));
    assertValueAndTypeEquals(ImmutableTable.of(),
        new FreshValueGenerator().generate(
            new TypeToken<ImmutableTable<EmptyEnumStringInteger>>() {}));
  }
  public void testList() {
        new FreshValueGenerator().generate(new TypeToken<List<String>>() {}));
        new FreshValueGenerator().generate(new TypeToken<List<Integer>>() {}));
        new FreshValueGenerator().generate(new TypeToken<List<?>>() {}));
  }
  public void testArrayList() {
        new FreshValueGenerator().generate(new TypeToken<ArrayList<String>>() {}));
        new FreshValueGenerator().generate(new TypeToken<ArrayList<Integer>>() {}));
        new FreshValueGenerator().generate(new TypeToken<ArrayList<?>>() {}));
  }
  public void testLinkedList() {
        new FreshValueGenerator().generate(new TypeToken<LinkedList<String>>() {}));
  }
  public void testSet() {
        newLinkedHashSet(new FreshValueGenerator().generate(Number.class)),
        new FreshValueGenerator().generate(new TypeToken<Set<? extends Number>>() {}));
  }
  public void testHashSet() {
        newLinkedHashSet(new FreshValueGenerator().generate(Number.class)),
        new FreshValueGenerator().generate(new TypeToken<HashSet<? extends Number>>() {}));
  }
  public void testLinkedHashSet() {
        newLinkedHashSet(new FreshValueGenerator().generate(Number.class)),
        new FreshValueGenerator().generate(new TypeToken<LinkedHashSet<? extends Number>>() {}));
  }
  public void testTreeSet() {
    TreeSet<Stringexpected = Sets.newTreeSet();
    expected.add(new FreshValueGenerator().generate(String.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<TreeSet<? extends CharSequence>>() {}));
  }
  public void testSortedSet() {
    TreeSet<Stringexpected = Sets.newTreeSet();
    expected.add(new FreshValueGenerator().generate(String.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<SortedSet<String>>() {}));
  }
  public void testMultiset() {
    Multiset<Stringexpected = HashMultiset.create();
    expected.add(new FreshValueGenerator().generate(String.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<Multiset<String>>() {}));
  }
  public void testSortedMultiset() {
    SortedMultiset<Stringexpected = TreeMultiset.create();
    expected.add(new FreshValueGenerator().generate(String.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<SortedMultiset<String>>() {}));
  }
  public void testHashMultiset() {
    HashMultiset<Stringexpected = HashMultiset.create();
    expected.add(new FreshValueGenerator().generate(String.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<HashMultiset<String>>() {}));
  }
  public void testLinkedHashMultiset() {
    LinkedHashMultiset<Stringexpected = LinkedHashMultiset.create();
    expected.add(new FreshValueGenerator().generate(String.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<LinkedHashMultiset<String>>() {}));
  }
  public void testTreeMultiset() {
    TreeMultiset<Stringexpected = TreeMultiset.create();
    expected.add(new FreshValueGenerator().generate(String.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<TreeMultiset<String>>() {}));
  }
  public void testImmutableSortedMultiset() {
        ImmutableSortedMultiset.of(new FreshValueGenerator().generate(String.class)),
  }
  public void testCollection() {
        new FreshValueGenerator().generate(new TypeToken<Collection<String>>() {}));
  }
  public void testIterable() {
        new FreshValueGenerator().generate(new TypeToken<Iterable<String>>() {}));
  }
  public void testMap() {
    assertFreshInstance(new TypeToken<Map<String, ?>>() {});
    FreshValueGenerator generator = new FreshValueGenerator();
    Map<StringIntegerexpected = Maps.newLinkedHashMap();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<Map<StringInteger>>() {}));
  }
  public void testHashMap() {
    assertFreshInstance(new TypeToken<HashMap<String, ?>>() {});
    FreshValueGenerator generator = new FreshValueGenerator();
    HashMap<StringIntegerexpected = Maps.newLinkedHashMap();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<HashMap<StringInteger>>() {}));
        new FreshValueGenerator().generate(new TypeToken<HashMap<EmptyEnumInteger>>() {}));
  }
  public void testLinkedHashMap() {
    FreshValueGenerator generator = new FreshValueGenerator();
    LinkedHashMap<StringIntegerexpected = Maps.newLinkedHashMap();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<LinkedHashMap<StringInteger>>() {}));
        new FreshValueGenerator().generate(new TypeToken<LinkedHashMap<EmptyEnumString>>() {}));
  }
  public void testTreeMap() {
    assertFreshInstance(new TypeToken<TreeMap<String, ?>>() {});
    FreshValueGenerator generator = new FreshValueGenerator();
    TreeMap<StringIntegerexpected = Maps.newTreeMap();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<TreeMap<StringInteger>>() {}));
  }
  public void testSortedMap() {
    FreshValueGenerator generator = new FreshValueGenerator();
    TreeMap<StringIntegerexpected = Maps.newTreeMap();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(
            new TypeToken<SortedMap<StringInteger>>() {}));
  }
  public void testConcurrentMap() {
    FreshValueGenerator generator = new FreshValueGenerator();
    ConcurrentMap<StringIntegerexpected = Maps.newConcurrentMap();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<ConcurrentMap<StringInteger>>() {}));
  }
  public void testMultimap() {
    assertFreshInstance(new TypeToken<Multimap<String, ?>>() {});
    FreshValueGenerator generator = new FreshValueGenerator();
    Multimap<StringIntegerexpected = ArrayListMultimap.create();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<Multimap<StringInteger>>() {}));
  }
  public void testHashMultimap() {
    FreshValueGenerator generator = new FreshValueGenerator();
    HashMultimap<StringIntegerexpected = HashMultimap.create();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(new TypeToken<HashMultimap<StringInteger>>() {}));
  }
  public void testLinkedHashMultimap() {
    FreshValueGenerator generator = new FreshValueGenerator();
    LinkedHashMultimap<StringIntegerexpected = LinkedHashMultimap.create();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(
            new TypeToken<LinkedHashMultimap<StringInteger>>() {}));
  }
  public void testListMultimap() {
    FreshValueGenerator generator = new FreshValueGenerator();
    ListMultimap<StringIntegerexpected = ArrayListMultimap.create();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(
            new TypeToken<ListMultimap<StringInteger>>() {}));
  }
  public void testArrayListMultimap() {
    FreshValueGenerator generator = new FreshValueGenerator();
    ArrayListMultimap<StringIntegerexpected = ArrayListMultimap.create();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(
            new TypeToken<ArrayListMultimap<StringInteger>>() {}));
  }
  public void testSetMultimap() {
    FreshValueGenerator generator = new FreshValueGenerator();
    SetMultimap<StringIntegerexpected = LinkedHashMultimap.create();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(
            new TypeToken<SetMultimap<StringInteger>>() {}));
  }
  public void testBiMap() {
    assertFreshInstance(new TypeToken<BiMap<String, ?>>() {});
    FreshValueGenerator generator = new FreshValueGenerator();
    BiMap<StringIntegerexpected = HashBiMap.create();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(
            new TypeToken<BiMap<StringInteger>>() {}));
  }
  public void testHashBiMap() {
    FreshValueGenerator generator = new FreshValueGenerator();
    HashBiMap<StringIntegerexpected = HashBiMap.create();
    expected.put(generator.generate(String.class), generator.generate(int.class));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(
            new TypeToken<HashBiMap<StringInteger>>() {}));
  }
  public void testTable() {
    assertFreshInstance(new TypeToken<Table<String, ?, ?>>() {});
    FreshValueGenerator generator = new FreshValueGenerator();
    Table<StringIntegerList<String>> 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<StringIntegerList<String>>>() {}));
  }
  public void testHashBasedTable() {
    assertFreshInstance(new TypeToken<HashBasedTable<String, ?, ?>>() {});
    FreshValueGenerator generator = new FreshValueGenerator();
    HashBasedTable<StringIntegerList<String>> 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<HashBasedTable<StringIntegerList<String>>>() {}));
  }
  public void testRowSortedTable() {
    assertFreshInstance(new TypeToken<RowSortedTable<String, ?, ?>>() {});
    FreshValueGenerator generator = new FreshValueGenerator();
    RowSortedTable<StringIntegerList<String>> expected = TreeBasedTable.create();
    expected.put(generator.generate(String.class), generator.generate(int.class),
            generator.generate(new TypeToken<List<String>>() {}));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(
            new TypeToken<RowSortedTable<StringIntegerList<String>>>() {}));
  }
  public void testTreeBasedTable() {
    assertFreshInstance(new TypeToken<TreeBasedTable<String, ?, ?>>() {});
    FreshValueGenerator generator = new FreshValueGenerator();
    TreeBasedTable<StringIntegerList<String>> expected = TreeBasedTable.create();
    expected.put(generator.generate(String.class), generator.generate(int.class),
            generator.generate(new TypeToken<List<String>>() {}));
    assertValueAndTypeEquals(expected,
        new FreshValueGenerator().generate(
            new TypeToken<TreeBasedTable<StringIntegerList<String>>>() {}));
  }
  public void testObject() {
        new FreshValueGenerator().generate(Object.class));
  }
  public void testEnums() {
    assertEqualInstance(EmptyEnum.classnull);
  }
    FreshValueGenerator generator = new FreshValueGenerator();
    generator.addSampleInstances(String.class, ImmutableList.of("a""b"));
    assertEquals("a"generator.generate(String.class));
    assertEquals("b"generator.generate(String.class));
    assertEquals("a"generator.generate(String.class));
  }
    FreshValueGenerator generator = new FreshValueGenerator();
    generator.addSampleInstances(String.class, ImmutableList.of("a"));
    assertEquals("a"generator.generate(String.class));
    assertEquals("a"generator.generate(String.class));
  }
    FreshValueGenerator generator = new FreshValueGenerator();
    generator.addSampleInstances(String.class, ImmutableList.<String>of());
        generator.generate(String.class));
  }
  public void testFreshCurrency() {
    FreshValueGenerator generator = new FreshValueGenerator();
    // repeat a few times to make sure we don't stumble upon a bad Locale
    assertNotNull(generator.generate(Currency.class));
    assertNotNull(generator.generate(Currency.class));
    assertNotNull(generator.generate(Currency.class));
  }
  public void testNulls() throws Exception {
    new ClassSanityTester()
        .setDefault(Method.classFreshValueGeneratorTest.class.getDeclaredMethod("testNulls"))
        .testNulls(FreshValueGenerator.class);
  }
  private static void assertFreshInstances(Class<?>... types) {
    for (Class<?> type : types) {
      assertFreshInstance(type);
    }
  }
  private static <T> void assertFreshInstance(TypeToken<T> type) {
    FreshValueGenerator generator = new FreshValueGenerator();
    T value1 = generator.generate(type);
    T value2 = generator.generate(type);
    assertNotNull("Null returned for " + typevalue1);
    assertFalse("Equal instance " + value1 + " returned for " + typevalue1.equals(value2));
  }
  private static <T> void assertFreshInstance(Class<T> type) {
    assertFreshInstance(TypeToken.of(type));
  }
  private static <T> void assertEqualInstance(Class<T> type, T value) {
    FreshValueGenerator generator = new FreshValueGenerator();
    assertEquals(valuegenerator.generate(type));
    assertEquals(valuegenerator.generate(type));
  }
  private enum EmptyEnum {}
  private enum OneConstantEnum {
    CONSTANT1
  }
  private enum TwoConstantEnum {
    CONSTANT1, CONSTANT2
  }
  private static void assertValueAndTypeEquals(Object expectedObject actual) {
    assertEquals(expectedactual);
    assertEquals(expected.getClass(), actual.getClass());
  }
  private static <E> LinkedHashSet<E> newLinkedHashSet(E element) {
    LinkedHashSet<E> set = Sets.newLinkedHashSet();
    set.add(element);
    return set;
  }
  private static <E> LinkedList<E> newLinkedList(E element) {
    LinkedList<E> list = Lists.newLinkedList();
    list.add(element);
    return list;
  }