| /* |
| * 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.collect.testing.google; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| |
| import com.google.common.annotations.GwtCompatible; |
| import com.google.common.collect.Multimap; |
| import com.google.common.collect.testing.AbstractContainerTester; |
| import com.google.common.collect.testing.Helpers; |
| import com.google.common.collect.testing.SampleElements; |
| |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| /** |
| * Superclass for all {@code Multimap} testers. |
| * |
| * @author Louis Wasserman |
| */ |
| @GwtCompatible |
| public abstract class AbstractMultimapTester<K, V, M extends Multimap<K, V>> |
| extends AbstractContainerTester<M, Map.Entry<K, V>> { |
| |
| private M multimap; |
| |
| protected M multimap() { |
| return multimap; |
| } |
| |
| /** |
| * @return an array of the proper size with {@code null} as the key of the |
| * middle element. |
| */ |
| protected Map.Entry<K, V>[] createArrayWithNullKey() { |
| Map.Entry<K, V>[] array = createSamplesArray(); |
| final int nullKeyLocation = getNullLocation(); |
| final Map.Entry<K, V> oldEntry = array[nullKeyLocation]; |
| array[nullKeyLocation] = Helpers.mapEntry(null, oldEntry.getValue()); |
| return array; |
| } |
| |
| /** |
| * @return an array of the proper size with {@code null} as the value of the |
| * middle element. |
| */ |
| protected Map.Entry<K, V>[] createArrayWithNullValue() { |
| Map.Entry<K, V>[] array = createSamplesArray(); |
| final int nullValueLocation = getNullLocation(); |
| final Map.Entry<K, V> oldEntry = array[nullValueLocation]; |
| array[nullValueLocation] = Helpers.mapEntry(oldEntry.getKey(), null); |
| return array; |
| } |
| |
| /** |
| * @return an array of the proper size with {@code null} as the key and value of the |
| * middle element. |
| */ |
| protected Map.Entry<K, V>[] createArrayWithNullKeyAndValue() { |
| Map.Entry<K, V>[] array = createSamplesArray(); |
| final int nullValueLocation = getNullLocation(); |
| array[nullValueLocation] = Helpers.mapEntry(null, null); |
| return array; |
| } |
| |
| protected V getValueForNullKey() { |
| return getEntryNullReplaces().getValue(); |
| } |
| |
| protected K getKeyForNullValue() { |
| return getEntryNullReplaces().getKey(); |
| } |
| |
| private Entry<K, V> getEntryNullReplaces() { |
| Iterator<Entry<K, V>> entries = getSampleElements().iterator(); |
| for (int i = 0; i < getNullLocation(); i++) { |
| entries.next(); |
| } |
| return entries.next(); |
| } |
| |
| protected void initMultimapWithNullKey() { |
| resetContainer(getSubjectGenerator().create(createArrayWithNullKey())); |
| } |
| |
| protected void initMultimapWithNullValue() { |
| resetContainer(getSubjectGenerator().create(createArrayWithNullValue())); |
| } |
| |
| protected void initMultimapWithNullKeyAndValue() { |
| resetContainer(getSubjectGenerator().create(createArrayWithNullKeyAndValue())); |
| } |
| |
| protected SampleElements<K> sampleKeys() { |
| return ((TestMultimapGenerator<K, V, ? extends Multimap<K, V>>) getSubjectGenerator() |
| .getInnerGenerator()).sampleKeys(); |
| } |
| |
| protected SampleElements<V> sampleValues() { |
| return ((TestMultimapGenerator<K, V, ? extends Multimap<K, V>>) getSubjectGenerator() |
| .getInnerGenerator()).sampleValues(); |
| } |
| |
| @Override |
| protected Collection<Entry<K, V>> actualContents() { |
| return multimap.entries(); |
| } |
| |
| // TODO: dispose of this once collection is encapsulated. |
| @Override |
| protected M resetContainer(M newContents) { |
| multimap = super.resetContainer(newContents); |
| return multimap; |
| } |
| |
| protected Multimap<K, V> resetContainer(Entry<K, V>... newContents) { |
| multimap = super.resetContainer(getSubjectGenerator().create(newContents)); |
| return multimap; |
| } |
| |
| /** @see AbstractContainerTester#resetContainer() */ |
| protected void resetCollection() { |
| resetContainer(); |
| } |
| |
| protected void assertGet(K key, V... values) { |
| assertGet(key, Arrays.asList(values)); |
| } |
| |
| protected void assertGet(K key, Collection<V> values) { |
| assertThat(multimap().get(key)).has().exactlyAs(values); |
| |
| if (!values.isEmpty()) { |
| assertThat(multimap().asMap().get(key)).has().exactlyAs(values); |
| assertFalse(multimap().isEmpty()); |
| } else { |
| assertThat(multimap().asMap().get(key)).isNull(); |
| } |
| |
| // TODO(user): Add proper overrides to prevent autoboxing. |
| // Truth+autoboxing == compile error. Cast int to long to fix: |
| assertThat(multimap().get(key).size()).isEqualTo((long) values.size()); |
| |
| assertEquals(values.size() > 0, multimap().containsKey(key)); |
| assertEquals(values.size() > 0, multimap().keySet().contains(key)); |
| assertEquals(values.size() > 0, multimap().keys().contains(key)); |
| } |
| } |