Coverage Summary for Class: DerivedGoogleCollectionGenerators (com.google.common.collect.testing.google)

1 /*
2  * Copyright (C) 2012 The Guava Authors
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package com.google.common.collect.testing.google;
18 
19 import com.google.common.annotations.GwtCompatible;
20 import com.google.common.collect.BiMap;
21 import com.google.common.collect.testing.DerivedGenerator;
22 import com.google.common.collect.testing.Helpers;
23 import com.google.common.collect.testing.OneSizeTestContainerGenerator;
24 import com.google.common.collect.testing.SampleElements;
25 import com.google.common.collect.testing.TestMapGenerator;
26 import com.google.common.collect.testing.TestSetGenerator;
27 import com.google.common.collect.testing.TestSubjectGenerator;
28 import java.util.ArrayList;
29 import java.util.Collection;
30 import java.util.List;
31 import java.util.Map;
32 import java.util.Map.Entry;
33 import java.util.Set;
34 
35 /**
36  * Derived suite generators for Guava collection interfaces, split out of the suite builders so that
37  * they are available to GWT.
38  *
39  * @author Louis Wasserman
40  */
41 @GwtCompatible
42 public final class DerivedGoogleCollectionGenerators {
43   public static class MapGenerator<K, V> implements TestMapGenerator<K, V>, DerivedGenerator {
44 
45     private final OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> generator;
46 
47     public MapGenerator(
48         OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> oneSizeTestContainerGenerator) {
49       this.generator = oneSizeTestContainerGenerator;
50     }
51 
52     @Override
53     public SampleElements<Entry<K, V>> samples() {
54       return generator.samples();
55     }
56 
57     @Override
58     public Map<K, V> create(Object... elements) {
59       return generator.create(elements);
60     }
61 
62     @Override
63     public Entry<K, V>[] createArray(int length) {
64       return generator.createArray(length);
65     }
66 
67     @Override
68     public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
69       return generator.order(insertionOrder);
70     }
71 
72     @SuppressWarnings("unchecked")
73     @Override
74     public K[] createKeyArray(int length) {
75       return (K[]) new Object[length];
76     }
77 
78     @SuppressWarnings("unchecked")
79     @Override
80     public V[] createValueArray(int length) {
81       return (V[]) new Object[length];
82     }
83 
84     @Override
85     public TestSubjectGenerator<?> getInnerGenerator() {
86       return generator;
87     }
88   }
89 
90   public static class InverseBiMapGenerator<K, V>
91       implements TestBiMapGenerator<V, K>, DerivedGenerator {
92 
93     private final OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> generator;
94 
95     public InverseBiMapGenerator(
96         OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> oneSizeTestContainerGenerator) {
97       this.generator = oneSizeTestContainerGenerator;
98     }
99 
100     @Override
101     public SampleElements<Entry<V, K>> samples() {
102       SampleElements<Entry<K, V>> samples = generator.samples();
103       return new SampleElements<>(
104           reverse(samples.e0()),
105           reverse(samples.e1()),
106           reverse(samples.e2()),
107           reverse(samples.e3()),
108           reverse(samples.e4()));
109     }
110 
111     private Entry<V, K> reverse(Entry<K, V> entry) {
112       return Helpers.mapEntry(entry.getValue(), entry.getKey());
113     }
114 
115     @SuppressWarnings("unchecked")
116     @Override
117     public BiMap<V, K> create(Object... elements) {
118       Entry<?, ?>[] entries = new Entry<?, ?>[elements.length];
119       for (int i = 0; i < elements.length; i++) {
120         entries[i] = reverse((Entry<K, V>) elements[i]);
121       }
122       return generator.create((Object[]) entries).inverse();
123     }
124 
125     @SuppressWarnings("unchecked")
126     @Override
127     public Entry<V, K>[] createArray(int length) {
128       return new Entry[length];
129     }
130 
131     @Override
132     public Iterable<Entry<V, K>> order(List<Entry<V, K>> insertionOrder) {
133       return insertionOrder;
134     }
135 
136     @SuppressWarnings("unchecked")
137     @Override
138     public V[] createKeyArray(int length) {
139       return (V[]) new Object[length];
140     }
141 
142     @SuppressWarnings("unchecked")
143     @Override
144     public K[] createValueArray(int length) {
145       return (K[]) new Object[length];
146     }
147 
148     @Override
149     public TestSubjectGenerator<?> getInnerGenerator() {
150       return generator;
151     }
152   }
153 
154   public static class BiMapValueSetGenerator<K, V>
155       implements TestSetGenerator<V>, DerivedGenerator {
156     private final OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> mapGenerator;
157     private final SampleElements<V> samples;
158 
159     public BiMapValueSetGenerator(
160         OneSizeTestContainerGenerator<BiMap<K, V>, Entry<K, V>> mapGenerator) {
161       this.mapGenerator = mapGenerator;
162       final SampleElements<Entry<K, V>> mapSamples = this.mapGenerator.samples();
163       this.samples =
164           new SampleElements<V>(
165               mapSamples.e0().getValue(),
166               mapSamples.e1().getValue(),
167               mapSamples.e2().getValue(),
168               mapSamples.e3().getValue(),
169               mapSamples.e4().getValue());
170     }
171 
172     @Override
173     public SampleElements<V> samples() {
174       return samples;
175     }
176 
177     @Override
178     public Set<V> create(Object... elements) {
179       @SuppressWarnings("unchecked")
180       V[] valuesArray = (V[]) elements;
181 
182       // Start with a suitably shaped collection of entries
183       Collection<Entry<K, V>> originalEntries = mapGenerator.getSampleElements(elements.length);
184 
185       // Create a copy of that, with the desired value for each value
186       Collection<Entry<K, V>> entries = new ArrayList<>(elements.length);
187       int i = 0;
188       for (Entry<K, V> entry : originalEntries) {
189         entries.add(Helpers.mapEntry(entry.getKey(), valuesArray[i++]));
190       }
191 
192       return mapGenerator.create(entries.toArray()).values();
193     }
194 
195     @Override
196     public V[] createArray(int length) {
197       final V[] vs =
198           ((TestBiMapGenerator<K, V>) mapGenerator.getInnerGenerator()).createValueArray(length);
199       return vs;
200     }
201 
202     @Override
203     public Iterable<V> order(List<V> insertionOrder) {
204       return insertionOrder;
205     }
206 
207     @Override
208     public TestSubjectGenerator<?> getInnerGenerator() {
209       return mapGenerator;
210     }
211   }
212 
213   private DerivedGoogleCollectionGenerators() {}
214 }