@Generates private static <K, V> LinkedHashMap<K, V> generateLinkedHashMap(K key, V value) { LinkedHashMap<K, V> map = Maps.newLinkedHashMap(); map.put(key, value); return map; }
@Generates private static <E> LinkedHashSet<E> generateLinkedHashSet(E freshElement) { LinkedHashSet<E> set = Sets.newLinkedHashSet(); set.add(freshElement); return set; }
@Generates private static <K, V> ConcurrentMap<K, V> generateConcurrentMap(K key, V value) { ConcurrentMap<K, V> map = Maps.newConcurrentMap(); map.put(key, value); return map; }
@Generates private DoubleBuffer generateDoubleBuffer() { return DoubleBuffer.allocate(generateInt()); } }
@Generates private static <R, C, V> ImmutableTable<R, C, V> generateImmutableTable( R row, C column, V value) { return ImmutableTable.of(row, column, value); }
@Generates private static <K extends Comparable<? super K>, V> NavigableMap<K, V> generateNavigableMap( K key, V value) { return generateTreeMap(key, value); }
@Generates private static <E> HashMultiset<E> generateHashMultiset(E freshElement) { HashMultiset<E> multiset = HashMultiset.create(); multiset.add(freshElement); return multiset; }
@SuppressWarnings("rawtypes") // TreeBasedTable.create() is defined as such @Generates private static <R extends Comparable, C extends Comparable, V> TreeBasedTable<R, C, V> generateTreeBasedTable(R row, C column, V value) { TreeBasedTable<R, C, V> table = TreeBasedTable.create(); table.put(row, column, value); return table; }
@Generates private static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> generateImmutableSortedMap(K key, V value) { return ImmutableSortedMap.of(key, value); }
@Generates private static <E extends Comparable<E>> ImmutableSortedMultiset<E> generateImmutableSortedMultiset(E freshElement) { return ImmutableSortedMultiset.of(freshElement); }
@Generates private static <E extends Comparable<E>> TreeMultiset<E> generateTreeMultiset(E freshElement) { TreeMultiset<E> multiset = TreeMultiset.create(); multiset.add(freshElement); return multiset; }
@Generates private static <K, V> HashMultimap<K, V> generateHashMultimap(K key, V value) { HashMultimap<K, V> multimap = HashMultimap.create(); multimap.put(key, value); return multimap; }
@Generates private static <K, V> ArrayListMultimap<K, V> generateArrayListMultimap(K key, V value) { ArrayListMultimap<K, V> multimap = ArrayListMultimap.create(); multimap.put(key, value); return multimap; }
@Generates private static <K extends Comparable<? super K>, V> SortedMap<K, V> generateSortedMap( K key, V value) { return generateNavigableMap(key, value); }
@Generates private static <E extends Comparable<? super E>> TreeSet<E> generateTreeSet(E freshElement) { TreeSet<E> set = Sets.newTreeSet(); set.add(freshElement); return set; }
@Generates private static <E> LinkedList<E> generateLinkedList(E freshElement) { LinkedList<E> list = Lists.newLinkedList(); list.add(freshElement); return list; }
@Generates private Class<?> generateClass() { return pickInstance( ImmutableList.of( int.class, long.class, void.class, Object.class, Object[].class, Iterable.class), Object.class); }
@SuppressWarnings("rawtypes") // TreeBasedTable.create() is defined as such @Generates private static <R extends Comparable, C extends Comparable, V> RowSortedTable<R, C, V> generateRowSortedTable(R row, C column, V value) { return generateTreeBasedTable(row, column, value); }
@Generates private static <E> LinkedHashMultiset<E> generateLinkedHashMultiset(E freshElement) { LinkedHashMultiset<E> multiset = LinkedHashMultiset.create(); multiset.add(freshElement); return multiset; }
@Generates private static <E extends Comparable<? super E>> ImmutableSortedSet<E> generateImmutableSortedSet( E freshElement) { return ImmutableSortedSet.of(freshElement); }