001/*
002 * Copyright (C) 2009 The Guava Authors
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017package com.google.common.collect.testing.google;
018
019import static com.google.common.collect.testing.Helpers.mapEntry;
020
021import com.google.common.annotations.GwtCompatible;
022import com.google.common.collect.ImmutableMap;
023import com.google.common.collect.ImmutableSet;
024import com.google.common.collect.Iterables;
025import com.google.common.collect.Maps;
026import com.google.common.collect.Ordering;
027import com.google.common.collect.testing.AnEnum;
028import com.google.common.collect.testing.SampleElements;
029import com.google.common.collect.testing.TestEnumMapGenerator;
030import com.google.common.collect.testing.TestListGenerator;
031import com.google.common.collect.testing.TestMapGenerator;
032import com.google.common.collect.testing.TestStringListGenerator;
033import com.google.common.collect.testing.TestStringMapGenerator;
034import com.google.common.collect.testing.TestUnhashableCollectionGenerator;
035import com.google.common.collect.testing.UnhashableObject;
036import java.util.Arrays;
037import java.util.Collection;
038import java.util.EnumMap;
039import java.util.List;
040import java.util.Map;
041import java.util.Map.Entry;
042
043/**
044 * Generators of different types of map and related collections, such as keys, entries and values.
045 *
046 * @author Hayward Chan
047 */
048@GwtCompatible
049public class MapGenerators {
050  public static class ImmutableMapGenerator extends TestStringMapGenerator {
051    @Override
052    protected Map<String, String> create(Entry<String, String>[] entries) {
053      ImmutableMap.Builder<String, String> builder = ImmutableMap.builder();
054      for (Entry<String, String> entry : entries) {
055        builder.put(entry.getKey(), entry.getValue());
056      }
057      return builder.build();
058    }
059  }
060
061  public static class ImmutableMapCopyOfGenerator extends TestStringMapGenerator {
062    @Override
063    protected Map<String, String> create(Entry<String, String>[] entries) {
064      Map<String, String> builder = Maps.newLinkedHashMap();
065      for (Entry<String, String> entry : entries) {
066        builder.put(entry.getKey(), entry.getValue());
067      }
068      return ImmutableMap.copyOf(builder);
069    }
070  }
071
072  public static class ImmutableMapCopyOfEntriesGenerator extends TestStringMapGenerator {
073    @Override
074    protected Map<String, String> create(Entry<String, String>[] entries) {
075      return ImmutableMap.copyOf(Arrays.asList(entries));
076    }
077  }
078
079  public static class ImmutableMapUnhashableValuesGenerator
080      extends TestUnhashableCollectionGenerator<Collection<UnhashableObject>> {
081
082    @Override
083    public Collection<UnhashableObject> create(UnhashableObject[] elements) {
084      ImmutableMap.Builder<Integer, UnhashableObject> builder = ImmutableMap.builder();
085      int key = 1;
086      for (UnhashableObject value : elements) {
087        builder.put(key++, value);
088      }
089      return builder.build().values();
090    }
091  }
092
093  public static class ImmutableMapKeyListGenerator extends TestStringListGenerator {
094    @Override
095    public List<String> create(String[] elements) {
096      ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
097      for (int i = 0; i < elements.length; i++) {
098        builder.put(elements[i], i);
099      }
100      return builder.build().keySet().asList();
101    }
102  }
103
104  public static class ImmutableMapValueListGenerator extends TestStringListGenerator {
105    @Override
106    public List<String> create(String[] elements) {
107      ImmutableMap.Builder<Integer, String> builder = ImmutableMap.builder();
108      for (int i = 0; i < elements.length; i++) {
109        builder.put(i, elements[i]);
110      }
111      return builder.build().values().asList();
112    }
113  }
114
115  public static class ImmutableMapEntryListGenerator
116      implements TestListGenerator<Entry<String, Integer>> {
117
118    @Override
119    public SampleElements<Entry<String, Integer>> samples() {
120      return new SampleElements<>(
121          mapEntry("foo", 5),
122          mapEntry("bar", 3),
123          mapEntry("baz", 17),
124          mapEntry("quux", 1),
125          mapEntry("toaster", -2));
126    }
127
128    @SuppressWarnings("unchecked")
129    @Override
130    public Entry<String, Integer>[] createArray(int length) {
131      return new Entry[length];
132    }
133
134    @Override
135    public Iterable<Entry<String, Integer>> order(List<Entry<String, Integer>> insertionOrder) {
136      return insertionOrder;
137    }
138
139    @Override
140    public List<Entry<String, Integer>> create(Object... elements) {
141      ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
142      for (Object o : elements) {
143        @SuppressWarnings("unchecked")
144        Entry<String, Integer> entry = (Entry<String, Integer>) o;
145        builder.put(entry);
146      }
147      return builder.build().entrySet().asList();
148    }
149  }
150
151  public static class ImmutableEnumMapGenerator extends TestEnumMapGenerator {
152    @Override
153    protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
154      Map<AnEnum, String> map = Maps.newHashMap();
155      for (Entry<AnEnum, String> entry : entries) {
156        // checkArgument(!map.containsKey(entry.getKey()));
157        map.put(entry.getKey(), entry.getValue());
158      }
159      return Maps.immutableEnumMap(map);
160    }
161  }
162
163  public static class ImmutableMapCopyOfEnumMapGenerator extends TestEnumMapGenerator {
164    @Override
165    protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
166      EnumMap<AnEnum, String> map = new EnumMap<>(AnEnum.class);
167      for (Entry<AnEnum, String> entry : entries) {
168        map.put(entry.getKey(), entry.getValue());
169      }
170      return ImmutableMap.copyOf(map);
171    }
172
173    @Override
174    public Iterable<Entry<AnEnum, String>> order(List<Entry<AnEnum, String>> insertionOrder) {
175      return new Ordering<Entry<AnEnum, String>>() {
176
177        @Override
178        public int compare(Entry<AnEnum, String> left, Entry<AnEnum, String> right) {
179          return left.getKey().compareTo(right.getKey());
180        }
181      }.sortedCopy(insertionOrder);
182    }
183  }
184
185  public static class ImmutableMapValuesAsSingletonSetGenerator
186      implements TestMapGenerator<String, Collection<Integer>> {
187
188    @Override
189    public SampleElements<Entry<String, Collection<Integer>>> samples() {
190      return new SampleElements<>(
191          mapEntry("one", collectionOf(10000)),
192          mapEntry("two", collectionOf(-2000)),
193          mapEntry("three", collectionOf(300)),
194          mapEntry("four", collectionOf(-40)),
195          mapEntry("five", collectionOf(5)));
196    }
197
198    // javac7 can't infer the type parameters correctly in samples()
199    private static Collection<Integer> collectionOf(int item) {
200      return ImmutableSet.of(item);
201    }
202
203    @Override
204    public Map<String, Collection<Integer>> create(Object... elements) {
205      ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
206      // assumes that each set is a singleton or less (as is done for the samples)
207      for (Object elem : elements) {
208        @SuppressWarnings("unchecked") // safe by generator contract
209        Entry<String, Collection<Integer>> entry = (Entry<String, Collection<Integer>>) elem;
210        Integer value = Iterables.getOnlyElement(entry.getValue());
211        builder.put(entry.getKey(), value);
212      }
213      return builder.build().asMultimap().asMap();
214    }
215
216    @Override
217    @SuppressWarnings({"unchecked", "rawtypes"}) // needed for arrays
218    public Entry<String, Collection<Integer>>[] createArray(int length) {
219      return new Entry[length];
220    }
221
222    @Override
223    public Iterable<Entry<String, Collection<Integer>>> order(
224        List<Entry<String, Collection<Integer>>> insertionOrder) {
225      return insertionOrder;
226    }
227
228    @Override
229    public String[] createKeyArray(int length) {
230      return new String[length];
231    }
232
233    @Override
234    @SuppressWarnings({"unchecked", "rawtypes"}) // needed for arrays
235    public ImmutableSet<Integer>[] createValueArray(int length) {
236      return new ImmutableSet[length];
237    }
238  }
239}