code stringlengths 1 2.01M | repo_name stringlengths 3 62 | path stringlengths 1 267 | language stringclasses 231
values | license stringclasses 13
values | size int64 1 2.01M |
|---|---|---|---|---|---|
/*
* Copyright (C) 2008 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.features;
import com.google.common.annotations.GwtCompatible;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Use this to meta-annotate XxxFeature.Require annotations, so that those
* annotations can be used to decide whether to apply a test to a given
* class-under-test.
* <br>
* This is needed because annotations can't implement interfaces, which is also
* why reflection is used to extract values from the properties of the various
* annotations.
*
* @see CollectionFeature.Require
*
* @author George van den Driessche
*/
@Target(value = {java.lang.annotation.ElementType.ANNOTATION_TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
@Documented
@GwtCompatible
public @interface TesterAnnotation {
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/features/TesterAnnotation.java | Java | asf20 | 1,482 |
/*
* Copyright (C) 2008 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.features;
import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.testing.Helpers;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
/**
* When describing the features of the collection produced by a given generator
* (i.e. in a call to {@link
* com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder#withFeatures(Feature...)}),
* this annotation specifies each of the different sizes for which a test suite
* should be built. (In a typical case, the features should include {@link
* CollectionSize#ANY}.) These semantics are thus a little different
* from those of other Collection-related features such as {@link
* CollectionFeature} or {@link SetFeature}.
* <p>
* However, when {@link CollectionSize.Require} is used to annotate a test it
* behaves normally (i.e. it requires the collection instance under test to be
* a certain size for the test to run). Note that this means a test should not
* require more than one CollectionSize, since a particular collection instance
* can only be one size at once.
*
* @author George van den Driessche
*/
// Enum values use constructors with generic varargs.
@SuppressWarnings("unchecked")
@GwtCompatible
public enum CollectionSize implements Feature<Collection>,
Comparable<CollectionSize> {
/** Test an empty collection. */
ZERO(0),
/** Test a one-element collection. */
ONE(1),
/** Test a three-element collection. */
SEVERAL(3),
/*
* TODO: add VERY_LARGE, noting that we currently assume that the fourth
* sample element is not in any collection
*/
ANY(
ZERO,
ONE,
SEVERAL
);
private final Set<Feature<? super Collection>> implied;
private final Integer numElements;
CollectionSize(int numElements) {
this.implied = Collections.emptySet();
this.numElements = numElements;
}
CollectionSize(Feature<? super Collection> ... implied) {
// Keep the order here, so that PerCollectionSizeTestSuiteBuilder
// gives a predictable order of test suites.
this.implied = Helpers.copyToSet(implied);
this.numElements = null;
}
@Override
public Set<Feature<? super Collection>> getImpliedFeatures() {
return implied;
}
public int getNumElements() {
if (numElements == null) {
throw new IllegalStateException(
"A compound CollectionSize doesn't specify a number of elements.");
}
return numElements;
}
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@TesterAnnotation
public @interface Require {
CollectionSize[] value() default {};
CollectionSize[] absent() default {};
}
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/features/CollectionSize.java | Java | asf20 | 3,416 |
/*
* Copyright (C) 2008 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;
import static com.google.common.collect.testing.Helpers.orderEntriesByKey;
import com.google.common.annotations.GwtCompatible;
import java.util.List;
import java.util.Map.Entry;
import java.util.SortedMap;
/**
* Implementation helper for {@link TestMapGenerator} for use with sorted maps of strings.
*
* @author Chris Povirk
*/
@GwtCompatible
public abstract class TestStringSortedMapGenerator extends TestStringMapGenerator
implements TestSortedMapGenerator<String, String> {
@Override
public Entry<String, String> belowSamplesLesser() {
return Helpers.mapEntry("!! a", "below view");
}
@Override
public Entry<String, String> belowSamplesGreater() {
return Helpers.mapEntry("!! b", "below view");
}
@Override
public Entry<String, String> aboveSamplesLesser() {
return Helpers.mapEntry("~~ a", "above view");
}
@Override
public Entry<String, String> aboveSamplesGreater() {
return Helpers.mapEntry("~~ b", "above view");
}
@Override
public Iterable<Entry<String, String>> order(List<Entry<String, String>> insertionOrder) {
return orderEntriesByKey(insertionOrder);
}
@Override
protected abstract SortedMap<String, String> create(Entry<String, String>[] entries);
@Override
public SortedMap<String, String> create(Object... entries) {
return (SortedMap<String, String>) super.create(entries);
}
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/TestStringSortedMapGenerator.java | Java | asf20 | 2,027 |
/*
* Copyright (C) 2007 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;
import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.testing.SampleElements.Strings;
import java.util.List;
import java.util.Set;
/**
* Create string sets for collection tests.
*
* @author Kevin Bourrillion
*/
@GwtCompatible
public abstract class TestStringSetGenerator implements TestSetGenerator<String>
{
@Override
public SampleElements<String> samples() {
return new Strings();
}
@Override
public Set<String> create(Object... elements) {
String[] array = new String[elements.length];
int i = 0;
for (Object e : elements) {
array[i++] = (String) e;
}
return create(array);
}
protected abstract Set<String> create(String[] elements);
@Override
public String[] createArray(int length) {
return new String[length];
}
/**
* {@inheritDoc}
*
* <p>By default, returns the supplied elements in their given order; however,
* generators for containers with a known order other than insertion order
* must override this method.
*
* <p>Note: This default implementation is overkill (but valid) for an
* unordered container. An equally valid implementation for an unordered
* container is to throw an exception. The chosen implementation, however, has
* the advantage of working for insertion-ordered containers, as well.
*/
@Override
public List<String> order(List<String> insertionOrder) {
return insertionOrder;
}
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/TestStringSetGenerator.java | Java | asf20 | 2,096 |
/*
* Copyright (C) 2009 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;
import com.google.common.annotations.GwtCompatible;
/**
* A non-empty tester for {@link java.util.Iterator}.
*
* @author George van den Driessche
*/
@GwtCompatible
public final class ExampleIteratorTester<E>
extends AbstractTester<TestIteratorGenerator<E>> {
public void testSomethingAboutIterators() {
assertTrue(true);
}
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/ExampleIteratorTester.java | Java | asf20 | 988 |
/*
* 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;
import com.google.common.annotations.GwtCompatible;
import java.util.Map;
import java.util.SortedMap;
/**
* Creates sorted maps, containing sample elements, to be tested.
*
* @author Louis Wasserman
*/
@GwtCompatible
public interface TestSortedMapGenerator<K, V> extends TestMapGenerator<K, V> {
@Override
SortedMap<K, V> create(Object... elements);
/**
* Returns an entry with a key less than the keys of the {@link #samples()}
* and less than the key of {@link #belowSamplesGreater()}.
*/
Map.Entry<K, V> belowSamplesLesser();
/**
* Returns an entry with a key less than the keys of the {@link #samples()}
* but greater than the key of {@link #belowSamplesLesser()}.
*/
Map.Entry<K, V> belowSamplesGreater();
/**
* Returns an entry with a key greater than the keys of the {@link #samples()}
* but less than the key of {@link #aboveSamplesGreater()}.
*/
Map.Entry<K, V> aboveSamplesLesser();
/**
* Returns an entry with a key greater than the keys of the {@link #samples()}
* and greater than the key of {@link #aboveSamplesLesser()}.
*/
Map.Entry<K, V> aboveSamplesGreater();
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/TestSortedMapGenerator.java | Java | asf20 | 1,800 |
/*
* Copyright (C) 2008 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;
import static com.google.common.collect.testing.Helpers.castOrCopyToList;
import static com.google.common.collect.testing.Helpers.equal;
import static com.google.common.collect.testing.Helpers.mapEntry;
import static java.util.Collections.sort;
import com.google.common.annotations.GwtCompatible;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
/**
* Derived suite generators, split out of the suite builders so that they are available to GWT.
*
* @author George van den Driessche
*/
@GwtCompatible
public final class DerivedCollectionGenerators {
public static class MapEntrySetGenerator<K, V>
implements TestSetGenerator<Map.Entry<K, V>>, DerivedGenerator {
private final OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
mapGenerator;
public MapEntrySetGenerator(
OneSizeTestContainerGenerator<
Map<K, V>, Map.Entry<K, V>> mapGenerator) {
this.mapGenerator = mapGenerator;
}
@Override
public SampleElements<Map.Entry<K, V>> samples() {
return mapGenerator.samples();
}
@Override
public Set<Map.Entry<K, V>> create(Object... elements) {
return mapGenerator.create(elements).entrySet();
}
@Override
public Map.Entry<K, V>[] createArray(int length) {
return mapGenerator.createArray(length);
}
@Override
public Iterable<Map.Entry<K, V>> order(
List<Map.Entry<K, V>> insertionOrder) {
return mapGenerator.order(insertionOrder);
}
@Override
public OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> getInnerGenerator() {
return mapGenerator;
}
}
// TODO: investigate some API changes to SampleElements that would tidy up
// parts of the following classes.
static <K, V> TestSetGenerator<K> keySetGenerator(
OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> mapGenerator) {
TestContainerGenerator<Map<K, V>, Entry<K, V>> generator = mapGenerator.getInnerGenerator();
if (generator instanceof TestSortedMapGenerator
&& ((TestSortedMapGenerator<K, V>) generator).create().keySet() instanceof SortedSet) {
return new MapSortedKeySetGenerator<K, V>(mapGenerator);
} else {
return new MapKeySetGenerator<K, V>(mapGenerator);
}
}
public static class MapKeySetGenerator<K, V>
implements TestSetGenerator<K>, DerivedGenerator {
private final OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
mapGenerator;
private final SampleElements<K> samples;
public MapKeySetGenerator(
OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
mapGenerator) {
this.mapGenerator = mapGenerator;
final SampleElements<Map.Entry<K, V>> mapSamples =
this.mapGenerator.samples();
this.samples = new SampleElements<K>(
mapSamples.e0.getKey(),
mapSamples.e1.getKey(),
mapSamples.e2.getKey(),
mapSamples.e3.getKey(),
mapSamples.e4.getKey());
}
@Override
public SampleElements<K> samples() {
return samples;
}
@Override
public Set<K> create(Object... elements) {
@SuppressWarnings("unchecked")
K[] keysArray = (K[]) elements;
// Start with a suitably shaped collection of entries
Collection<Map.Entry<K, V>> originalEntries =
mapGenerator.getSampleElements(elements.length);
// Create a copy of that, with the desired value for each key
Collection<Map.Entry<K, V>> entries =
new ArrayList<Entry<K, V>>(elements.length);
int i = 0;
for (Map.Entry<K, V> entry : originalEntries) {
entries.add(Helpers.mapEntry(keysArray[i++], entry.getValue()));
}
return mapGenerator.create(entries.toArray()).keySet();
}
@Override
public K[] createArray(int length) {
// TODO: with appropriate refactoring of OneSizeGenerator, we can perhaps
// tidy this up and get rid of the casts here and in
// MapValueCollectionGenerator.
return ((TestMapGenerator<K, V>) mapGenerator.getInnerGenerator())
.createKeyArray(length);
}
@Override
public Iterable<K> order(List<K> insertionOrder) {
V v = ((TestMapGenerator<K, V>) mapGenerator.getInnerGenerator()).samples().e0.getValue();
List<Entry<K, V>> entries = new ArrayList<Entry<K, V>>();
for (K element : insertionOrder) {
entries.add(mapEntry(element, v));
}
List<K> keys = new ArrayList<K>();
for (Entry<K, V> entry : mapGenerator.order(entries)) {
keys.add(entry.getKey());
}
return keys;
}
@Override
public OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> getInnerGenerator() {
return mapGenerator;
}
}
public static class MapSortedKeySetGenerator<K, V> extends MapKeySetGenerator<K, V>
implements TestSortedSetGenerator<K>, DerivedGenerator {
private final TestSortedMapGenerator<K, V> delegate;
public MapSortedKeySetGenerator(
OneSizeTestContainerGenerator<Map<K, V>, Entry<K, V>> mapGenerator) {
super(mapGenerator);
this.delegate = (TestSortedMapGenerator<K, V>) mapGenerator.getInnerGenerator();
}
@Override
public SortedSet<K> create(Object... elements) {
return (SortedSet<K>) super.create(elements);
}
@Override
public K belowSamplesLesser() {
return delegate.belowSamplesLesser().getKey();
}
@Override
public K belowSamplesGreater() {
return delegate.belowSamplesGreater().getKey();
}
@Override
public K aboveSamplesLesser() {
return delegate.aboveSamplesLesser().getKey();
}
@Override
public K aboveSamplesGreater() {
return delegate.aboveSamplesGreater().getKey();
}
}
public static class MapValueCollectionGenerator<K, V>
implements TestCollectionGenerator<V>, DerivedGenerator {
private final OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>>
mapGenerator;
private final SampleElements<V> samples;
public MapValueCollectionGenerator(
OneSizeTestContainerGenerator<
Map<K, V>, Map.Entry<K, V>> mapGenerator) {
this.mapGenerator = mapGenerator;
final SampleElements<Map.Entry<K, V>> mapSamples =
this.mapGenerator.samples();
this.samples = new SampleElements<V>(
mapSamples.e0.getValue(),
mapSamples.e1.getValue(),
mapSamples.e2.getValue(),
mapSamples.e3.getValue(),
mapSamples.e4.getValue());
}
@Override
public SampleElements<V> samples() {
return samples;
}
@Override
public Collection<V> create(Object... elements) {
@SuppressWarnings("unchecked")
V[] valuesArray = (V[]) elements;
// Start with a suitably shaped collection of entries
Collection<Map.Entry<K, V>> originalEntries =
mapGenerator.getSampleElements(elements.length);
// Create a copy of that, with the desired value for each value
Collection<Map.Entry<K, V>> entries =
new ArrayList<Entry<K, V>>(elements.length);
int i = 0;
for (Map.Entry<K, V> entry : originalEntries) {
entries.add(Helpers.mapEntry(entry.getKey(), valuesArray[i++]));
}
return mapGenerator.create(entries.toArray()).values();
}
@Override
public V[] createArray(int length) {
//noinspection UnnecessaryLocalVariable
final V[] vs = ((TestMapGenerator<K, V>) mapGenerator.getInnerGenerator())
.createValueArray(length);
return vs;
}
@Override
public Iterable<V> order(List<V> insertionOrder) {
final List<Entry<K, V>> orderedEntries =
castOrCopyToList(mapGenerator.order(castOrCopyToList(
mapGenerator.getSampleElements(5))));
sort(insertionOrder, new Comparator<V>() {
@Override public int compare(V left, V right) {
// The indexes are small enough for the subtraction trick to be safe.
return indexOfEntryWithValue(left) - indexOfEntryWithValue(right);
}
int indexOfEntryWithValue(V value) {
for (int i = 0; i < orderedEntries.size(); i++) {
if (equal(orderedEntries.get(i).getValue(), value)) {
return i;
}
}
throw new IllegalArgumentException("Map.values generator can order only sample values");
}
});
return insertionOrder;
}
@Override
public OneSizeTestContainerGenerator<Map<K, V>, Map.Entry<K, V>> getInnerGenerator() {
return mapGenerator;
}
}
// TODO(cpovirk): could something like this be used elsewhere, e.g., ReserializedListGenerator?
static class ForwardingTestMapGenerator<K, V> implements TestMapGenerator<K, V> {
TestMapGenerator<K, V> delegate;
ForwardingTestMapGenerator(TestMapGenerator<K, V> delegate) {
this.delegate = delegate;
}
@Override
public Iterable<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
return delegate.order(insertionOrder);
}
@Override
public K[] createKeyArray(int length) {
return delegate.createKeyArray(length);
}
@Override
public V[] createValueArray(int length) {
return delegate.createValueArray(length);
}
@Override
public SampleElements<Entry<K, V>> samples() {
return delegate.samples();
}
@Override
public Map<K, V> create(Object... elements) {
return delegate.create(elements);
}
@Override
public Entry<K, V>[] createArray(int length) {
return delegate.createArray(length);
}
}
/**
* Two bounds (from and to) define how to build a subMap.
*/
public enum Bound {
INCLUSIVE,
EXCLUSIVE,
NO_BOUND;
}
public static class SortedSetSubsetTestSetGenerator<E>
implements TestSortedSetGenerator<E> {
final Bound to;
final Bound from;
final E firstInclusive;
final E lastInclusive;
private final Comparator<? super E> comparator;
private final TestSortedSetGenerator<E> delegate;
public SortedSetSubsetTestSetGenerator(
TestSortedSetGenerator<E> delegate, Bound to, Bound from) {
this.to = to;
this.from = from;
this.delegate = delegate;
SortedSet<E> emptySet = delegate.create();
this.comparator = emptySet.comparator();
SampleElements<E> samples = delegate.samples();
List<E> samplesList = new ArrayList<E>(samples.asList());
Collections.sort(samplesList, comparator);
this.firstInclusive = samplesList.get(0);
this.lastInclusive = samplesList.get(samplesList.size() - 1);
}
public final TestSortedSetGenerator<E> getInnerGenerator() {
return delegate;
}
public final Bound getTo() {
return to;
}
public final Bound getFrom() {
return from;
}
@Override
public SampleElements<E> samples() {
return delegate.samples();
}
@Override
public E[] createArray(int length) {
return delegate.createArray(length);
}
@Override
public Iterable<E> order(List<E> insertionOrder) {
return delegate.order(insertionOrder);
}
@Override
public SortedSet<E> create(Object... elements) {
@SuppressWarnings("unchecked") // set generators must pass SampleElements values
List<E> normalValues = (List) Arrays.asList(elements);
List<E> extremeValues = new ArrayList<E>();
// nulls are usually out of bounds for a subset, so ban them altogether
for (Object o : elements) {
if (o == null) {
throw new NullPointerException();
}
}
// prepare extreme values to be filtered out of view
E firstExclusive = delegate.belowSamplesGreater();
E lastExclusive = delegate.aboveSamplesLesser();
if (from != Bound.NO_BOUND) {
extremeValues.add(delegate.belowSamplesLesser());
extremeValues.add(delegate.belowSamplesGreater());
}
if (to != Bound.NO_BOUND) {
extremeValues.add(delegate.aboveSamplesLesser());
extremeValues.add(delegate.aboveSamplesGreater());
}
// the regular values should be visible after filtering
List<E> allEntries = new ArrayList<E>();
allEntries.addAll(extremeValues);
allEntries.addAll(normalValues);
SortedSet<E> map = delegate.create(allEntries.toArray());
return createSubSet(map, firstExclusive, lastExclusive);
}
/**
* Calls the smallest subSet overload that filters out the extreme values.
*/
SortedSet<E> createSubSet(SortedSet<E> set, E firstExclusive, E lastExclusive) {
if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
return set.headSet(lastExclusive);
} else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) {
return set.tailSet(firstInclusive);
} else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) {
return set.subSet(firstInclusive, lastExclusive);
} else {
throw new IllegalArgumentException();
}
}
@Override
public E belowSamplesLesser() {
throw new UnsupportedOperationException();
}
@Override
public E belowSamplesGreater() {
throw new UnsupportedOperationException();
}
@Override
public E aboveSamplesLesser() {
throw new UnsupportedOperationException();
}
@Override
public E aboveSamplesGreater() {
throw new UnsupportedOperationException();
}
}
/*
* TODO(cpovirk): surely we can find a less ugly solution than a class that accepts 3 parameters,
* exposes as many getters, does work in the constructor, and has both a superclass and a subclass
*/
public static class SortedMapSubmapTestMapGenerator<K, V>
extends ForwardingTestMapGenerator<K, V> implements TestSortedMapGenerator<K, V> {
final Bound to;
final Bound from;
final K firstInclusive;
final K lastInclusive;
private final Comparator<Entry<K, V>> entryComparator;
public SortedMapSubmapTestMapGenerator(
TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
super(delegate);
this.to = to;
this.from = from;
SortedMap<K, V> emptyMap = delegate.create();
this.entryComparator = Helpers.entryComparator(emptyMap.comparator());
// derive values for inclusive filtering from the input samples
SampleElements<Entry<K, V>> samples = delegate.samples();
@SuppressWarnings("unchecked") // no elements are inserted into the array
List<Entry<K, V>> samplesList = Arrays.asList(
samples.e0, samples.e1, samples.e2, samples.e3, samples.e4);
Collections.sort(samplesList, entryComparator);
this.firstInclusive = samplesList.get(0).getKey();
this.lastInclusive = samplesList.get(samplesList.size() - 1).getKey();
}
@Override public SortedMap<K, V> create(Object... entries) {
@SuppressWarnings("unchecked") // map generators must past entry objects
List<Entry<K, V>> normalValues = (List) Arrays.asList(entries);
List<Entry<K, V>> extremeValues = new ArrayList<Entry<K, V>>();
// prepare extreme values to be filtered out of view
K firstExclusive = getInnerGenerator().belowSamplesGreater().getKey();
K lastExclusive = getInnerGenerator().aboveSamplesLesser().getKey();
if (from != Bound.NO_BOUND) {
extremeValues.add(getInnerGenerator().belowSamplesLesser());
extremeValues.add(getInnerGenerator().belowSamplesGreater());
}
if (to != Bound.NO_BOUND) {
extremeValues.add(getInnerGenerator().aboveSamplesLesser());
extremeValues.add(getInnerGenerator().aboveSamplesGreater());
}
// the regular values should be visible after filtering
List<Entry<K, V>> allEntries = new ArrayList<Entry<K, V>>();
allEntries.addAll(extremeValues);
allEntries.addAll(normalValues);
SortedMap<K, V> map = (SortedMap<K, V>)
delegate.create((Object[])
allEntries.toArray(new Entry<?, ?>[allEntries.size()]));
return createSubMap(map, firstExclusive, lastExclusive);
}
/**
* Calls the smallest subMap overload that filters out the extreme values. This method is
* overridden in NavigableMapTestSuiteBuilder.
*/
SortedMap<K, V> createSubMap(SortedMap<K, V> map, K firstExclusive, K lastExclusive) {
if (from == Bound.NO_BOUND && to == Bound.EXCLUSIVE) {
return map.headMap(lastExclusive);
} else if (from == Bound.INCLUSIVE && to == Bound.NO_BOUND) {
return map.tailMap(firstInclusive);
} else if (from == Bound.INCLUSIVE && to == Bound.EXCLUSIVE) {
return map.subMap(firstInclusive, lastExclusive);
} else {
throw new IllegalArgumentException();
}
}
public final Bound getTo() {
return to;
}
public final Bound getFrom() {
return from;
}
public final TestSortedMapGenerator<K, V> getInnerGenerator() {
return (TestSortedMapGenerator<K, V>) delegate;
}
@Override
public Entry<K, V> belowSamplesLesser() {
// should never reach here!
throw new UnsupportedOperationException();
}
@Override
public Entry<K, V> belowSamplesGreater() {
// should never reach here!
throw new UnsupportedOperationException();
}
@Override
public Entry<K, V> aboveSamplesLesser() {
// should never reach here!
throw new UnsupportedOperationException();
}
@Override
public Entry<K, V> aboveSamplesGreater() {
// should never reach here!
throw new UnsupportedOperationException();
}
}
private DerivedCollectionGenerators() {}
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/DerivedCollectionGenerators.java | Java | asf20 | 18,654 |
/*
* Copyright (C) 2008 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;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.Feature;
import com.google.common.testing.SerializableTester;
import junit.framework.TestSuite;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Concrete instantiation of {@link AbstractCollectionTestSuiteBuilder} for
* testing collections that do not have a more specific tester like
* {@link ListTestSuiteBuilder} or {@link SetTestSuiteBuilder}.
*
* @author Chris Povirk
* @author Louis Wasserman
*/
public class CollectionTestSuiteBuilder<E>
extends AbstractCollectionTestSuiteBuilder<
CollectionTestSuiteBuilder<E>, E> {
public static <E> CollectionTestSuiteBuilder<E> using(
TestCollectionGenerator<E> generator) {
return new CollectionTestSuiteBuilder<E>().usingGenerator(generator);
}
@Override
protected
List<TestSuite>
createDerivedSuites(
FeatureSpecificTestSuiteBuilder<
?, ? extends OneSizeTestContainerGenerator<Collection<E>, E>> parentBuilder) {
List<TestSuite> derivedSuites = new ArrayList<TestSuite>(
super.createDerivedSuites(parentBuilder));
if (parentBuilder.getFeatures().contains(CollectionFeature.SERIALIZABLE)) {
derivedSuites.add(CollectionTestSuiteBuilder
.using(new ReserializedCollectionGenerator<E>(parentBuilder.getSubjectGenerator()))
.named(getName() + " reserialized")
.withFeatures(computeReserializedCollectionFeatures(parentBuilder.getFeatures()))
.suppressing(parentBuilder.getSuppressedTests())
.createTestSuite());
}
return derivedSuites;
}
static class ReserializedCollectionGenerator<E> implements TestCollectionGenerator<E> {
final OneSizeTestContainerGenerator<Collection<E>, E> gen;
private ReserializedCollectionGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
this.gen = gen;
}
@Override
public SampleElements<E> samples() {
return gen.samples();
}
@Override
public Collection<E> create(Object... elements) {
return SerializableTester.reserialize(gen.create(elements));
}
@Override
public E[] createArray(int length) {
return gen.createArray(length);
}
@Override
public Iterable<E> order(List<E> insertionOrder) {
return gen.order(insertionOrder);
}
}
private static Set<Feature<?>> computeReserializedCollectionFeatures(Set<Feature<?>> features) {
Set<Feature<?>> derivedFeatures = new HashSet<Feature<?>>();
derivedFeatures.addAll(features);
derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS);
return derivedFeatures;
}
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/CollectionTestSuiteBuilder.java | Java | asf20 | 3,498 |
/*
* Copyright (C) 2009 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;
import static com.google.common.collect.testing.Helpers.orderEntriesByKey;
import com.google.common.annotations.GwtCompatible;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
/**
* Implementation helper for {@link TestMapGenerator} for use with enum maps.
*
* @author Kevin Bourrillion
*/
@GwtCompatible
public abstract class TestEnumMapGenerator
implements TestMapGenerator<AnEnum, String> {
@Override
public SampleElements<Entry<AnEnum, String>> samples() {
return new SampleElements<Entry<AnEnum, String>>(
Helpers.mapEntry(AnEnum.A, "January"),
Helpers.mapEntry(AnEnum.B, "February"),
Helpers.mapEntry(AnEnum.C, "March"),
Helpers.mapEntry(AnEnum.D, "April"),
Helpers.mapEntry(AnEnum.E, "May")
);
}
@Override
public final Map<AnEnum, String> create(Object... entries) {
@SuppressWarnings("unchecked")
Entry<AnEnum, String>[] array = new Entry[entries.length];
int i = 0;
for (Object o : entries) {
@SuppressWarnings("unchecked")
Entry<AnEnum, String> e = (Entry<AnEnum, String>) o;
array[i++] = e;
}
return create(array);
}
protected abstract Map<AnEnum, String> create(
Entry<AnEnum, String>[] entries);
@Override
@SuppressWarnings("unchecked")
public final Entry<AnEnum, String>[] createArray(int length) {
return new Entry[length];
}
@Override
public final AnEnum[] createKeyArray(int length) {
return new AnEnum[length];
}
@Override
public final String[] createValueArray(int length) {
return new String[length];
}
/** Returns the elements sorted in natural order. */
@Override
public Iterable<Entry<AnEnum, String>> order(
List<Entry<AnEnum, String>> insertionOrder) {
return orderEntriesByKey(insertionOrder);
}
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/TestEnumMapGenerator.java | Java | asf20 | 2,472 |
/*
* Copyright (C) 2008 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;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.Feature;
import com.google.common.collect.testing.testers.CollectionSerializationEqualTester;
import com.google.common.collect.testing.testers.ListAddAllAtIndexTester;
import com.google.common.collect.testing.testers.ListAddAllTester;
import com.google.common.collect.testing.testers.ListAddAtIndexTester;
import com.google.common.collect.testing.testers.ListAddTester;
import com.google.common.collect.testing.testers.ListCreationTester;
import com.google.common.collect.testing.testers.ListEqualsTester;
import com.google.common.collect.testing.testers.ListGetTester;
import com.google.common.collect.testing.testers.ListHashCodeTester;
import com.google.common.collect.testing.testers.ListIndexOfTester;
import com.google.common.collect.testing.testers.ListLastIndexOfTester;
import com.google.common.collect.testing.testers.ListListIteratorTester;
import com.google.common.collect.testing.testers.ListRemoveAllTester;
import com.google.common.collect.testing.testers.ListRemoveAtIndexTester;
import com.google.common.collect.testing.testers.ListRemoveTester;
import com.google.common.collect.testing.testers.ListRetainAllTester;
import com.google.common.collect.testing.testers.ListSetTester;
import com.google.common.collect.testing.testers.ListSubListTester;
import com.google.common.collect.testing.testers.ListToArrayTester;
import com.google.common.testing.SerializableTester;
import junit.framework.TestSuite;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
* Creates, based on your criteria, a JUnit test suite that exhaustively tests
* a List implementation.
*
* @author George van den Driessche
*/
public final class ListTestSuiteBuilder<E> extends
AbstractCollectionTestSuiteBuilder<ListTestSuiteBuilder<E>, E> {
public static <E> ListTestSuiteBuilder<E> using(
TestListGenerator<E> generator) {
return new ListTestSuiteBuilder<E>().usingGenerator(generator);
}
@Override protected List<Class<? extends AbstractTester>> getTesters() {
List<Class<? extends AbstractTester>> testers
= Helpers.copyToList(super.getTesters());
testers.add(CollectionSerializationEqualTester.class);
testers.add(ListAddAllAtIndexTester.class);
testers.add(ListAddAllTester.class);
testers.add(ListAddAtIndexTester.class);
testers.add(ListAddTester.class);
testers.add(ListCreationTester.class);
testers.add(ListEqualsTester.class);
testers.add(ListGetTester.class);
testers.add(ListHashCodeTester.class);
testers.add(ListIndexOfTester.class);
testers.add(ListLastIndexOfTester.class);
testers.add(ListListIteratorTester.class);
testers.add(ListRemoveAllTester.class);
testers.add(ListRemoveAtIndexTester.class);
testers.add(ListRemoveTester.class);
testers.add(ListRetainAllTester.class);
testers.add(ListSetTester.class);
testers.add(ListSubListTester.class);
testers.add(ListToArrayTester.class);
return testers;
}
/**
* Specifies {@link CollectionFeature#KNOWN_ORDER} for all list tests, since
* lists have an iteration ordering corresponding to the insertion order.
*/
@Override public TestSuite createTestSuite() {
withFeatures(CollectionFeature.KNOWN_ORDER);
return super.createTestSuite();
}
@Override
protected
List<TestSuite>
createDerivedSuites(
FeatureSpecificTestSuiteBuilder<
?, ? extends OneSizeTestContainerGenerator<Collection<E>, E>> parentBuilder) {
List<TestSuite> derivedSuites = new ArrayList<TestSuite>(
super.createDerivedSuites(parentBuilder));
if (parentBuilder.getFeatures().contains(CollectionFeature.SERIALIZABLE)) {
derivedSuites.add(ListTestSuiteBuilder
.using(new ReserializedListGenerator<E>(parentBuilder.getSubjectGenerator()))
.named(getName() + " reserialized")
.withFeatures(computeReserializedCollectionFeatures(parentBuilder.getFeatures()))
.suppressing(parentBuilder.getSuppressedTests())
.createTestSuite());
}
return derivedSuites;
}
static class ReserializedListGenerator<E> implements TestListGenerator<E>{
final OneSizeTestContainerGenerator<Collection<E>, E> gen;
private ReserializedListGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
this.gen = gen;
}
@Override
public SampleElements<E> samples() {
return gen.samples();
}
@Override
public List<E> create(Object... elements) {
return (List<E>) SerializableTester.reserialize(gen.create(elements));
}
@Override
public E[] createArray(int length) {
return gen.createArray(length);
}
@Override
public Iterable<E> order(List<E> insertionOrder) {
return gen.order(insertionOrder);
}
}
private static Set<Feature<?>> computeReserializedCollectionFeatures(
Set<Feature<?>> features) {
Set<Feature<?>> derivedFeatures = new HashSet<Feature<?>>();
derivedFeatures.addAll(features);
derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS);
return derivedFeatures;
}
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/ListTestSuiteBuilder.java | Java | asf20 | 5,988 |
/*
* Copyright (C) 2008 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;
import com.google.common.collect.testing.testers.QueueElementTester;
import com.google.common.collect.testing.testers.QueueOfferTester;
import com.google.common.collect.testing.testers.QueuePeekTester;
import com.google.common.collect.testing.testers.QueuePollTester;
import com.google.common.collect.testing.testers.QueueRemoveTester;
import java.util.ArrayList;
import java.util.List;
/**
* Creates, based on your criteria, a JUnit test suite that exhaustively tests
* a queue implementation.
*
* @author Jared Levy
*/
public final class QueueTestSuiteBuilder<E>
extends AbstractCollectionTestSuiteBuilder<QueueTestSuiteBuilder<E>, E> {
public static <E> QueueTestSuiteBuilder<E> using(
TestQueueGenerator<E> generator) {
return new QueueTestSuiteBuilder<E>().usingGenerator(generator);
}
private boolean runCollectionTests = true;
/**
* Specify whether to skip the general collection tests. Call this method when
* testing a collection that's both a queue and a list, to avoid running the
* common collection tests twice. By default, collection tests do run.
*/
public QueueTestSuiteBuilder<E> skipCollectionTests() {
runCollectionTests = false;
return this;
}
@Override protected List<Class<? extends AbstractTester>> getTesters() {
List<Class<? extends AbstractTester>> testers =
new ArrayList<Class<? extends AbstractTester>>();
if (runCollectionTests) {
testers.addAll(super.getTesters());
}
testers.add(QueueElementTester.class);
testers.add(QueueOfferTester.class);
testers.add(QueuePeekTester.class);
testers.add(QueuePollTester.class);
testers.add(QueueRemoveTester.class);
return testers;
}
}
| zzhhhhh-aw4rwer | guava-testlib/src/com/google/common/collect/testing/QueueTestSuiteBuilder.java | Java | asf20 | 2,362 |
/*
* Copyright (C) 2008 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.io;
public class BaseEncodingTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.io.testModule";
}
public void testAtMostOneSeparator() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testAtMostOneSeparator();
}
public void testBase16() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase16();
}
public void testBase16UpperCaseIsNoOp() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase16UpperCaseIsNoOp();
}
public void testBase32() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase32();
}
public void testBase32AlternatePadding() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase32AlternatePadding();
}
public void testBase32Hex() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase32Hex();
}
public void testBase32HexInvalidDecodings() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase32HexInvalidDecodings();
}
public void testBase32HexLenientPadding() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase32HexLenientPadding();
}
public void testBase32HexUpperCaseIsNoOp() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase32HexUpperCaseIsNoOp();
}
public void testBase32InvalidDecodings() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase32InvalidDecodings();
}
public void testBase32LenientPadding() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase32LenientPadding();
}
public void testBase32UpperCaseIsNoOp() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase32UpperCaseIsNoOp();
}
public void testBase64() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase64();
}
public void testBase64AlternatePadding() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase64AlternatePadding();
}
public void testBase64CannotLowerCase() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase64CannotLowerCase();
}
public void testBase64CannotUpperCase() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase64CannotUpperCase();
}
public void testBase64InvalidDecodings() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase64InvalidDecodings();
}
public void testBase64LenientPadding() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase64LenientPadding();
}
public void testBase64OmitPadding() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testBase64OmitPadding();
}
public void testSeparatorSameAsPadChar() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testSeparatorSameAsPadChar();
}
public void testSeparatorsExplicitly() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testSeparatorsExplicitly();
}
public void testToString() throws Exception {
com.google.common.io.BaseEncodingTest testCase = new com.google.common.io.BaseEncodingTest();
testCase.testToString();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/io/BaseEncodingTest_gwt.java | Java | asf20 | 5,028 |
/*
* Copyright (C) 2008 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.xml;
public class XmlEscapersTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.xml.testModule";
}
public void testXmlAttributeEscaper() throws Exception {
com.google.common.xml.XmlEscapersTest testCase = new com.google.common.xml.XmlEscapersTest();
testCase.testXmlAttributeEscaper();
}
public void testXmlContentEscaper() throws Exception {
com.google.common.xml.XmlEscapersTest testCase = new com.google.common.xml.XmlEscapersTest();
testCase.testXmlContentEscaper();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/xml/XmlEscapersTest_gwt.java | Java | asf20 | 1,189 |
/*
* Copyright (C) 2008 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.escape;
public class ArrayBasedEscaperMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.escape.testModule";
}
public void testEmptyMap() throws Exception {
com.google.common.escape.ArrayBasedEscaperMapTest testCase = new com.google.common.escape.ArrayBasedEscaperMapTest();
testCase.testEmptyMap();
}
public void testMapLength() throws Exception {
com.google.common.escape.ArrayBasedEscaperMapTest testCase = new com.google.common.escape.ArrayBasedEscaperMapTest();
testCase.testMapLength();
}
public void testMapping() throws Exception {
com.google.common.escape.ArrayBasedEscaperMapTest testCase = new com.google.common.escape.ArrayBasedEscaperMapTest();
testCase.testMapping();
}
public void testNullMap() throws Exception {
com.google.common.escape.ArrayBasedEscaperMapTest testCase = new com.google.common.escape.ArrayBasedEscaperMapTest();
testCase.testNullMap();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/escape/ArrayBasedEscaperMapTest_gwt.java | Java | asf20 | 1,602 |
/*
* Copyright (C) 2008 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.escape;
public class ArrayBasedUnicodeEscaperTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.escape.testModule";
}
public void testCodePointsFromSurrogatePairs() throws Exception {
com.google.common.escape.ArrayBasedUnicodeEscaperTest testCase = new com.google.common.escape.ArrayBasedUnicodeEscaperTest();
testCase.testCodePointsFromSurrogatePairs();
}
public void testDeleteUnsafeChars() throws Exception {
com.google.common.escape.ArrayBasedUnicodeEscaperTest testCase = new com.google.common.escape.ArrayBasedUnicodeEscaperTest();
testCase.testDeleteUnsafeChars();
}
public void testReplacementPriority() throws Exception {
com.google.common.escape.ArrayBasedUnicodeEscaperTest testCase = new com.google.common.escape.ArrayBasedUnicodeEscaperTest();
testCase.testReplacementPriority();
}
public void testReplacements() throws Exception {
com.google.common.escape.ArrayBasedUnicodeEscaperTest testCase = new com.google.common.escape.ArrayBasedUnicodeEscaperTest();
testCase.testReplacements();
}
public void testSafeRange() throws Exception {
com.google.common.escape.ArrayBasedUnicodeEscaperTest testCase = new com.google.common.escape.ArrayBasedUnicodeEscaperTest();
testCase.testSafeRange();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/escape/ArrayBasedUnicodeEscaperTest_gwt.java | Java | asf20 | 1,934 |
/*
* Copyright (C) 2008 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.escape;
public class EscapersTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.escape.testModule";
}
public void testAsUnicodeEscaper() throws Exception {
com.google.common.escape.EscapersTest testCase = new com.google.common.escape.EscapersTest();
testCase.testAsUnicodeEscaper();
}
public void testBuilderCreatesIndependentEscapers() throws Exception {
com.google.common.escape.EscapersTest testCase = new com.google.common.escape.EscapersTest();
testCase.testBuilderCreatesIndependentEscapers();
}
public void testBuilderInitialStateNoReplacement() throws Exception {
com.google.common.escape.EscapersTest testCase = new com.google.common.escape.EscapersTest();
testCase.testBuilderInitialStateNoReplacement();
}
public void testBuilderInitialStateNoneUnsafe() throws Exception {
com.google.common.escape.EscapersTest testCase = new com.google.common.escape.EscapersTest();
testCase.testBuilderInitialStateNoneUnsafe();
}
public void testBuilderRetainsState() throws Exception {
com.google.common.escape.EscapersTest testCase = new com.google.common.escape.EscapersTest();
testCase.testBuilderRetainsState();
}
public void testNullEscaper() throws Exception {
com.google.common.escape.EscapersTest testCase = new com.google.common.escape.EscapersTest();
testCase.testNullEscaper();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/escape/EscapersTest_gwt.java | Java | asf20 | 2,024 |
/*
* Copyright (C) 2008 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.escape;
public class UnicodeEscaperTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.escape.testModule";
}
public void testBadStrings() throws Exception {
com.google.common.escape.UnicodeEscaperTest testCase = new com.google.common.escape.UnicodeEscaperTest();
testCase.testBadStrings();
}
public void testCodePointAt_IndexOutOfBoundsException() throws Exception {
com.google.common.escape.UnicodeEscaperTest testCase = new com.google.common.escape.UnicodeEscaperTest();
testCase.testCodePointAt_IndexOutOfBoundsException();
}
public void testFalsePositivesForNextEscapedIndex() throws Exception {
com.google.common.escape.UnicodeEscaperTest testCase = new com.google.common.escape.UnicodeEscaperTest();
testCase.testFalsePositivesForNextEscapedIndex();
}
public void testGrowBuffer() throws Exception {
com.google.common.escape.UnicodeEscaperTest testCase = new com.google.common.escape.UnicodeEscaperTest();
testCase.testGrowBuffer();
}
public void testNopEscaper() throws Exception {
com.google.common.escape.UnicodeEscaperTest testCase = new com.google.common.escape.UnicodeEscaperTest();
testCase.testNopEscaper();
}
public void testNullInput() throws Exception {
com.google.common.escape.UnicodeEscaperTest testCase = new com.google.common.escape.UnicodeEscaperTest();
testCase.testNullInput();
}
public void testSimpleEscaper() throws Exception {
com.google.common.escape.UnicodeEscaperTest testCase = new com.google.common.escape.UnicodeEscaperTest();
testCase.testSimpleEscaper();
}
public void testSurrogatePairs() throws Exception {
com.google.common.escape.UnicodeEscaperTest testCase = new com.google.common.escape.UnicodeEscaperTest();
testCase.testSurrogatePairs();
}
public void testTrailingHighSurrogate() throws Exception {
com.google.common.escape.UnicodeEscaperTest testCase = new com.google.common.escape.UnicodeEscaperTest();
testCase.testTrailingHighSurrogate();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/escape/UnicodeEscaperTest_gwt.java | Java | asf20 | 2,640 |
/*
* Copyright (C) 2008 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.escape;
public class ArrayBasedCharEscaperTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.escape.testModule";
}
public void testDeleteUnsafeChars() throws Exception {
com.google.common.escape.ArrayBasedCharEscaperTest testCase = new com.google.common.escape.ArrayBasedCharEscaperTest();
testCase.testDeleteUnsafeChars();
}
public void testReplacementPriority() throws Exception {
com.google.common.escape.ArrayBasedCharEscaperTest testCase = new com.google.common.escape.ArrayBasedCharEscaperTest();
testCase.testReplacementPriority();
}
public void testSafeRange() throws Exception {
com.google.common.escape.ArrayBasedCharEscaperTest testCase = new com.google.common.escape.ArrayBasedCharEscaperTest();
testCase.testSafeRange();
}
public void testSafeRange_maxLessThanMin() throws Exception {
com.google.common.escape.ArrayBasedCharEscaperTest testCase = new com.google.common.escape.ArrayBasedCharEscaperTest();
testCase.testSafeRange_maxLessThanMin();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/escape/ArrayBasedCharEscaperTest_gwt.java | Java | asf20 | 1,687 |
/*
* Copyright (C) 2013 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;
import com.google.common.reflect.ClassPath;
import com.google.common.reflect.ClassPath.ClassInfo;
import com.google.gwt.junit.client.GWTTestCase;
import com.google.gwt.junit.tools.GWTTestSuite;
import junit.framework.Test;
import junit.framework.TestCase;
import java.io.IOException;
/**
* Runs all _gwt tests. Grouping them into a suite is much faster than running each as a one-test
* "suite," as the per-suite setup is expensive.
*/
public class GwtTestSuite extends TestCase {
public static Test suite() throws IOException {
GWTTestSuite suite = new GWTTestSuite();
for (ClassInfo info
: ClassPath.from(GwtTestSuite.class.getClassLoader()).getTopLevelClasses()) {
if (info.getName().endsWith("_gwt")) {
Class<?> clazz = info.load();
// TODO(cpovirk): why does asSubclass() throw? Is it something about ClassLoaders?
@SuppressWarnings("unchecked")
Class<? extends GWTTestCase> cast = (Class<? extends GWTTestCase>) clazz;
suite.addTestSuite(cast);
}
}
return suite;
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/GwtTestSuite.java | Java | asf20 | 1,690 |
/*
* Copyright (C) 2008 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.util.concurrent;
public class AtomicLongMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.util.concurrent.testModule";
}
public void testAddAndGet() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testAddAndGet();
}
public void testAddAndGet_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testAddAndGet_zero();
}
public void testClear() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testClear();
}
public void testCreate_map() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testCreate_map();
}
public void testDecrementAndGet() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testDecrementAndGet();
}
public void testDecrementAndGet_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testDecrementAndGet_zero();
}
public void testEmpty() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testEmpty();
}
public void testGetAndAdd() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testGetAndAdd();
}
public void testGetAndAdd_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testGetAndAdd_zero();
}
public void testGetAndDecrement() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testGetAndDecrement();
}
public void testGetAndDecrement_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testGetAndDecrement_zero();
}
public void testGetAndIncrement() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testGetAndIncrement();
}
public void testGetAndIncrement_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testGetAndIncrement_zero();
}
public void testIncrementAndGet() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testIncrementAndGet();
}
public void testIncrementAndGet_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testIncrementAndGet_zero();
}
public void testPut() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testPut();
}
public void testPutAll() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testPutAll();
}
public void testPutIfAbsent() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testPutIfAbsent();
}
public void testPutIfAbsent_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testPutIfAbsent_zero();
}
public void testPut_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testPut_zero();
}
public void testRemove() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testRemove();
}
public void testRemoveValue() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testRemoveValue();
}
public void testRemoveValue_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testRemoveValue_zero();
}
public void testRemoveZeros() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testRemoveZeros();
}
public void testRemove_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testRemove_zero();
}
public void testReplace() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testReplace();
}
public void testReplace_zero() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testReplace_zero();
}
public void testSum() throws Exception {
com.google.common.util.concurrent.AtomicLongMapTest testCase = new com.google.common.util.concurrent.AtomicLongMapTest();
testCase.testSum();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/util/concurrent/AtomicLongMapTest_gwt.java | Java | asf20 | 6,637 |
/*
* Copyright (C) 2008 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.util.concurrent;
public class RunnablesTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.util.concurrent.testModule";
}
public void testDoNothingRunnableIsSingleton() throws Exception {
com.google.common.util.concurrent.RunnablesTest testCase = new com.google.common.util.concurrent.RunnablesTest();
testCase.testDoNothingRunnableIsSingleton();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/util/concurrent/RunnablesTest_gwt.java | Java | asf20 | 1,059 |
/*
* Copyright (C) 2008 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.math;
public class IntMathTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.math.testModule";
}
public void testCheckedAdd() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testCheckedAdd();
}
public void testCheckedMultiply() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testCheckedMultiply();
}
public void testCheckedPow() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testCheckedPow();
}
public void testCheckedSubtract() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testCheckedSubtract();
}
public void testDivByZeroAlwaysFails() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testDivByZeroAlwaysFails();
}
public void testDivNonZero() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testDivNonZero();
}
public void testDivNonZeroExact() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testDivNonZeroExact();
}
public void testFactorial() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testFactorial();
}
public void testFactorialNegative() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testFactorialNegative();
}
public void testGCD() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testGCD();
}
public void testGCDNegativePositiveThrows() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testGCDNegativePositiveThrows();
}
public void testGCDNegativeZeroThrows() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testGCDNegativeZeroThrows();
}
public void testGCDZero() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testGCDZero();
}
public void testLessThanBranchFree() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testLessThanBranchFree();
}
public void testLog2Exact() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testLog2Exact();
}
public void testLog2MatchesBigInteger() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testLog2MatchesBigInteger();
}
public void testLog2NegativeAlwaysThrows() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testLog2NegativeAlwaysThrows();
}
public void testLog2ZeroAlwaysThrows() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testLog2ZeroAlwaysThrows();
}
public void testMod() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testMod();
}
public void testModNegativeModulusFails() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testModNegativeModulusFails();
}
public void testModZeroModulusFails() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testModZeroModulusFails();
}
public void testZeroDivIsAlwaysZero() throws Exception {
com.google.common.math.IntMathTest testCase = new com.google.common.math.IntMathTest();
testCase.testZeroDivIsAlwaysZero();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/math/IntMathTest_gwt.java | Java | asf20 | 4,769 |
/*
* Copyright (C) 2008 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.math;
public class LongMathTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.math.testModule";
}
public void testBinomial() throws Exception {
com.google.common.math.LongMathTest testCase = new com.google.common.math.LongMathTest();
testCase.testBinomial();
}
public void testBinomialNegative() throws Exception {
com.google.common.math.LongMathTest testCase = new com.google.common.math.LongMathTest();
testCase.testBinomialNegative();
}
public void testBinomialOutside() throws Exception {
com.google.common.math.LongMathTest testCase = new com.google.common.math.LongMathTest();
testCase.testBinomialOutside();
}
public void testGCDExhaustive() throws Exception {
com.google.common.math.LongMathTest testCase = new com.google.common.math.LongMathTest();
testCase.testGCDExhaustive();
}
public void testLessThanBranchFree() throws Exception {
com.google.common.math.LongMathTest testCase = new com.google.common.math.LongMathTest();
testCase.testLessThanBranchFree();
}
public void testLog2Exact() throws Exception {
com.google.common.math.LongMathTest testCase = new com.google.common.math.LongMathTest();
testCase.testLog2Exact();
}
public void testLog2MatchesBigInteger() throws Exception {
com.google.common.math.LongMathTest testCase = new com.google.common.math.LongMathTest();
testCase.testLog2MatchesBigInteger();
}
public void testLog2NegativeAlwaysThrows() throws Exception {
com.google.common.math.LongMathTest testCase = new com.google.common.math.LongMathTest();
testCase.testLog2NegativeAlwaysThrows();
}
public void testLog2ZeroAlwaysThrows() throws Exception {
com.google.common.math.LongMathTest testCase = new com.google.common.math.LongMathTest();
testCase.testLog2ZeroAlwaysThrows();
}
public void testSqrtOfLongIsAtMostFloorSqrtMaxLong() throws Exception {
com.google.common.math.LongMathTest testCase = new com.google.common.math.LongMathTest();
testCase.testSqrtOfLongIsAtMostFloorSqrtMaxLong();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/math/LongMathTest_gwt.java | Java | asf20 | 2,680 |
/*
* Copyright (C) 2008 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.math;
public class BigIntegerMathTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.math.testModule";
}
public void testBinomialOutside() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testBinomialOutside();
}
public void testBinomialSmall() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testBinomialSmall();
}
public void testFactorial() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testFactorial();
}
public void testFactorial0() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testFactorial0();
}
public void testFactorialNegative() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testFactorialNegative();
}
public void testIsPowerOfTwo() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testIsPowerOfTwo();
}
public void testLog2Ceiling() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testLog2Ceiling();
}
public void testLog2Exact() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testLog2Exact();
}
public void testLog2Floor() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testLog2Floor();
}
public void testLog2HalfDown() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testLog2HalfDown();
}
public void testLog2HalfEven() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testLog2HalfEven();
}
public void testLog2HalfUp() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testLog2HalfUp();
}
public void testLog2NegativeAlwaysThrows() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testLog2NegativeAlwaysThrows();
}
public void testLog2ZeroAlwaysThrows() throws Exception {
com.google.common.math.BigIntegerMathTest testCase = new com.google.common.math.BigIntegerMathTest();
testCase.testLog2ZeroAlwaysThrows();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/math/BigIntegerMathTest_gwt.java | Java | asf20 | 3,472 |
/*
* Copyright (C) 2010 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;
import com.google.gwt.core.client.EntryPoint;
/**
* A dummy entry point for our tests.
*
* @author Chris Povirk
*/
public class GuavaTestsEntryPoint implements EntryPoint {
@Override public void onModuleLoad() {
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/GuavaTestsEntryPoint.java | Java | asf20 | 855 |
/*
* Copyright (C) 2008 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.primitives;
public class SignedBytesTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testCheckedCast() throws Exception {
com.google.common.primitives.SignedBytesTest testCase = new com.google.common.primitives.SignedBytesTest();
testCase.testCheckedCast();
}
public void testCompare() throws Exception {
com.google.common.primitives.SignedBytesTest testCase = new com.google.common.primitives.SignedBytesTest();
testCase.testCompare();
}
public void testJoin() throws Exception {
com.google.common.primitives.SignedBytesTest testCase = new com.google.common.primitives.SignedBytesTest();
testCase.testJoin();
}
public void testLexicographicalComparator() throws Exception {
com.google.common.primitives.SignedBytesTest testCase = new com.google.common.primitives.SignedBytesTest();
testCase.testLexicographicalComparator();
}
public void testMax() throws Exception {
com.google.common.primitives.SignedBytesTest testCase = new com.google.common.primitives.SignedBytesTest();
testCase.testMax();
}
public void testMax_noArgs() throws Exception {
com.google.common.primitives.SignedBytesTest testCase = new com.google.common.primitives.SignedBytesTest();
testCase.testMax_noArgs();
}
public void testMin() throws Exception {
com.google.common.primitives.SignedBytesTest testCase = new com.google.common.primitives.SignedBytesTest();
testCase.testMin();
}
public void testMin_noArgs() throws Exception {
com.google.common.primitives.SignedBytesTest testCase = new com.google.common.primitives.SignedBytesTest();
testCase.testMin_noArgs();
}
public void testSaturatedCast() throws Exception {
com.google.common.primitives.SignedBytesTest testCase = new com.google.common.primitives.SignedBytesTest();
testCase.testSaturatedCast();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/SignedBytesTest_gwt.java | Java | asf20 | 2,521 |
/*
* Copyright (C) 2008 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.primitives;
public class BooleansTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testAsListContains() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testAsListContains();
}
public void testAsListEquals() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testAsListEquals();
}
public void testAsListHashcode() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testAsListHashcode();
}
public void testAsListIndexOf() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testAsListIndexOf();
}
public void testAsListIsEmpty() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testAsListIsEmpty();
}
public void testAsListLastIndexOf() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testAsListLastIndexOf();
}
public void testAsListSet() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testAsListSet();
}
public void testAsListSize() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testAsListSize();
}
public void testAsListToString() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testAsListToString();
}
public void testCompare() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testCompare();
}
public void testConcat() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testConcat();
}
public void testContains() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testContains();
}
public void testCountTrue() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testCountTrue();
}
public void testEnsureCapacity() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testEnsureCapacity();
}
public void testEnsureCapacity_fail() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testEnsureCapacity_fail();
}
public void testHashCode() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testHashCode();
}
public void testIndexOf() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testIndexOf();
}
public void testIndexOf_arrays() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testIndexOf_arrays();
}
public void testJoin() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testJoin();
}
public void testLastIndexOf() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testLastIndexOf();
}
public void testLexicographicalComparator() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testLexicographicalComparator();
}
public void testToArray() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testToArray();
}
public void testToArray_threadSafe() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testToArray_threadSafe();
}
public void testToArray_withNull() throws Exception {
com.google.common.primitives.BooleansTest testCase = new com.google.common.primitives.BooleansTest();
testCase.testToArray_withNull();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/BooleansTest_gwt.java | Java | asf20 | 5,330 |
/*
* Copyright (C) 2008 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.primitives;
public class UnsignedLongsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testCompare() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testCompare();
}
public void testDecodeLong() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testDecodeLong();
}
public void testDecodeLongFails() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testDecodeLongFails();
}
public void testDivide() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testDivide();
}
public void testJoin() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testJoin();
}
public void testLexicographicalComparator() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testLexicographicalComparator();
}
public void testMax() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testMax();
}
public void testMax_noArgs() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testMax_noArgs();
}
public void testMin() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testMin();
}
public void testMin_noArgs() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testMin_noArgs();
}
public void testParseLong() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testParseLong();
}
public void testParseLongThrowsExceptionForInvalidRadix() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testParseLongThrowsExceptionForInvalidRadix();
}
public void testParseLongWithRadix() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testParseLongWithRadix();
}
public void testRemainder() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testRemainder();
}
public void testToString() throws Exception {
com.google.common.primitives.UnsignedLongsTest testCase = new com.google.common.primitives.UnsignedLongsTest();
testCase.testToString();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/UnsignedLongsTest_gwt.java | Java | asf20 | 3,783 |
/*
* Copyright (C) 2008 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.primitives;
public class CharsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testAsListEmpty() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testAsListEmpty();
}
public void testAsList_isAView() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testAsList_isAView();
}
public void testAsList_subList_toArray_roundTrip() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testAsList_subList_toArray_roundTrip();
}
public void testAsList_toArray_roundTrip() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testAsList_toArray_roundTrip();
}
public void testCheckedCast() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testCheckedCast();
}
public void testCompare() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testCompare();
}
public void testConcat() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testConcat();
}
public void testContains() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testContains();
}
public void testEnsureCapacity() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testEnsureCapacity();
}
public void testEnsureCapacity_fail() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testEnsureCapacity_fail();
}
public void testHashCode() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testHashCode();
}
public void testIndexOf() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testIndexOf();
}
public void testIndexOf_arrayTarget() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testIndexOf_arrayTarget();
}
public void testJoin() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testJoin();
}
public void testLastIndexOf() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testLastIndexOf();
}
public void testLexicographicalComparator() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testLexicographicalComparator();
}
public void testMax() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testMax();
}
public void testMax_noArgs() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testMax_noArgs();
}
public void testMin() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testMin();
}
public void testMin_noArgs() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testMin_noArgs();
}
public void testSaturatedCast() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testSaturatedCast();
}
public void testToArray() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testToArray();
}
public void testToArray_threadSafe() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testToArray_threadSafe();
}
public void testToArray_withNull() throws Exception {
com.google.common.primitives.CharsTest testCase = new com.google.common.primitives.CharsTest();
testCase.testToArray_withNull();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/CharsTest_gwt.java | Java | asf20 | 5,205 |
/*
* Copyright (C) 2008 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.primitives;
public class ShortsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testAsListEmpty() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testAsListEmpty();
}
public void testAsList_isAView() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testAsList_isAView();
}
public void testAsList_subList_toArray_roundTrip() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testAsList_subList_toArray_roundTrip();
}
public void testAsList_toArray_roundTrip() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testAsList_toArray_roundTrip();
}
public void testCheckedCast() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testCheckedCast();
}
public void testCompare() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testCompare();
}
public void testConcat() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testConcat();
}
public void testContains() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testContains();
}
public void testEnsureCapacity() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testEnsureCapacity();
}
public void testEnsureCapacity_fail() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testEnsureCapacity_fail();
}
public void testHashCode() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testHashCode();
}
public void testIndexOf() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testIndexOf();
}
public void testIndexOf_arrayTarget() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testIndexOf_arrayTarget();
}
public void testJoin() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testJoin();
}
public void testLastIndexOf() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testLastIndexOf();
}
public void testLexicographicalComparator() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testLexicographicalComparator();
}
public void testMax() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testMax();
}
public void testMax_noArgs() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testMax_noArgs();
}
public void testMin() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testMin();
}
public void testMin_noArgs() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testMin_noArgs();
}
public void testSaturatedCast() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testSaturatedCast();
}
public void testStringConverter_convert() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testStringConverter_convert();
}
public void testStringConverter_convertError() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testStringConverter_convertError();
}
public void testStringConverter_nullConversions() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testStringConverter_nullConversions();
}
public void testStringConverter_reverse() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testStringConverter_reverse();
}
public void testToArray() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testToArray();
}
public void testToArray_threadSafe() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testToArray_threadSafe();
}
public void testToArray_withConversion() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testToArray_withConversion();
}
public void testToArray_withNull() throws Exception {
com.google.common.primitives.ShortsTest testCase = new com.google.common.primitives.ShortsTest();
testCase.testToArray_withNull();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/ShortsTest_gwt.java | Java | asf20 | 6,308 |
/*
* Copyright (C) 2008 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.primitives;
public class BytesTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testAsListEmpty() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testAsListEmpty();
}
public void testAsList_isAView() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testAsList_isAView();
}
public void testAsList_subList_toArray_roundTrip() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testAsList_subList_toArray_roundTrip();
}
public void testAsList_toArray_roundTrip() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testAsList_toArray_roundTrip();
}
public void testConcat() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testConcat();
}
public void testContains() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testContains();
}
public void testEnsureCapacity() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testEnsureCapacity();
}
public void testEnsureCapacity_fail() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testEnsureCapacity_fail();
}
public void testHashCode() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testHashCode();
}
public void testIndexOf() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testIndexOf();
}
public void testIndexOf_arrayTarget() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testIndexOf_arrayTarget();
}
public void testLastIndexOf() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testLastIndexOf();
}
public void testToArray() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testToArray();
}
public void testToArray_threadSafe() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testToArray_threadSafe();
}
public void testToArray_withConversion() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testToArray_withConversion();
}
public void testToArray_withNull() throws Exception {
com.google.common.primitives.BytesTest testCase = new com.google.common.primitives.BytesTest();
testCase.testToArray_withNull();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/BytesTest_gwt.java | Java | asf20 | 3,813 |
/*
* Copyright (C) 2008 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.primitives;
public class UnsignedLongTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testAsUnsignedAndLongValueAreInverses() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testAsUnsignedAndLongValueAreInverses();
}
public void testAsUnsignedBigIntegerValue() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testAsUnsignedBigIntegerValue();
}
public void testCompare() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testCompare();
}
public void testDivideByZeroThrows() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testDivideByZeroThrows();
}
public void testDividedBy() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testDividedBy();
}
public void testDoubleValue() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testDoubleValue();
}
public void testFloatValue() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testFloatValue();
}
public void testIntValue() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testIntValue();
}
public void testMinus() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testMinus();
}
public void testMod() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testMod();
}
public void testModByZero() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testModByZero();
}
public void testPlus() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testPlus();
}
public void testTimes() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testTimes();
}
public void testToString() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testToString();
}
public void testToStringRadixQuick() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testToStringRadixQuick();
}
public void testValueOfBigInteger() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testValueOfBigInteger();
}
public void testValueOfLong() throws Exception {
com.google.common.primitives.UnsignedLongTest testCase = new com.google.common.primitives.UnsignedLongTest();
testCase.testValueOfLong();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/UnsignedLongTest_gwt.java | Java | asf20 | 4,146 |
/*
* Copyright (C) 2008 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.primitives;
public class IntsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testAsListEmpty() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testAsListEmpty();
}
public void testAsList_isAView() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testAsList_isAView();
}
public void testAsList_subList_toArray_roundTrip() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testAsList_subList_toArray_roundTrip();
}
public void testAsList_toArray_roundTrip() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testAsList_toArray_roundTrip();
}
public void testCheckedCast() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testCheckedCast();
}
public void testCompare() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testCompare();
}
public void testConcat() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testConcat();
}
public void testContains() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testContains();
}
public void testEnsureCapacity() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testEnsureCapacity();
}
public void testEnsureCapacity_fail() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testEnsureCapacity_fail();
}
public void testHashCode() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testHashCode();
}
public void testIndexOf() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testIndexOf();
}
public void testIndexOf_arrayTarget() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testIndexOf_arrayTarget();
}
public void testJoin() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testJoin();
}
public void testLastIndexOf() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testLastIndexOf();
}
public void testLexicographicalComparator() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testLexicographicalComparator();
}
public void testMax() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testMax();
}
public void testMax_noArgs() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testMax_noArgs();
}
public void testMin() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testMin();
}
public void testMin_noArgs() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testMin_noArgs();
}
public void testSaturatedCast() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testSaturatedCast();
}
public void testStringConverter_convert() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testStringConverter_convert();
}
public void testStringConverter_convertError() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testStringConverter_convertError();
}
public void testStringConverter_nullConversions() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testStringConverter_nullConversions();
}
public void testStringConverter_reverse() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testStringConverter_reverse();
}
public void testToArray() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testToArray();
}
public void testToArray_threadSafe() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testToArray_threadSafe();
}
public void testToArray_withConversion() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testToArray_withConversion();
}
public void testToArray_withNull() throws Exception {
com.google.common.primitives.IntsTest testCase = new com.google.common.primitives.IntsTest();
testCase.testToArray_withNull();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/IntsTest_gwt.java | Java | asf20 | 6,190 |
/*
* Copyright (C) 2008 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.primitives;
public class DoublesTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testAsListEmpty() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testAsListEmpty();
}
public void testAsList_isAView() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testAsList_isAView();
}
public void testAsList_subList_toArray_roundTrip() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testAsList_subList_toArray_roundTrip();
}
public void testAsList_toArray_roundTrip() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testAsList_toArray_roundTrip();
}
public void testCompare() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testCompare();
}
public void testConcat() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testConcat();
}
public void testContains() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testContains();
}
public void testEnsureCapacity() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testEnsureCapacity();
}
public void testEnsureCapacity_fail() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testEnsureCapacity_fail();
}
public void testHashCode() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testHashCode();
}
public void testIndexOf() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testIndexOf();
}
public void testIndexOf_arrayTarget() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testIndexOf_arrayTarget();
}
public void testIsFinite() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testIsFinite();
}
public void testJoinNonTrivialDoubles() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testJoinNonTrivialDoubles();
}
public void testLastIndexOf() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testLastIndexOf();
}
public void testLexicographicalComparator() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testLexicographicalComparator();
}
public void testMax() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testMax();
}
public void testMax_noArgs() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testMax_noArgs();
}
public void testMin() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testMin();
}
public void testMin_noArgs() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testMin_noArgs();
}
public void testStringConverter_convert() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testStringConverter_convert();
}
public void testStringConverter_convertError() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testStringConverter_convertError();
}
public void testStringConverter_nullConversions() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testStringConverter_nullConversions();
}
public void testToArray() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testToArray();
}
public void testToArray_threadSafe() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testToArray_threadSafe();
}
public void testToArray_withConversion() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testToArray_withConversion();
}
public void testToArray_withNull() throws Exception {
com.google.common.primitives.DoublesTest testCase = new com.google.common.primitives.DoublesTest();
testCase.testToArray_withNull();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/DoublesTest_gwt.java | Java | asf20 | 5,999 |
/*
* Copyright (C) 2008 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.primitives;
public class LongsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testAsListEmpty() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testAsListEmpty();
}
public void testAsList_isAView() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testAsList_isAView();
}
public void testAsList_subList_toArray_roundTrip() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testAsList_subList_toArray_roundTrip();
}
public void testAsList_toArray_roundTrip() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testAsList_toArray_roundTrip();
}
public void testByteArrayRoundTrips() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testByteArrayRoundTrips();
}
public void testCompare() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testCompare();
}
public void testConcat() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testConcat();
}
public void testContains() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testContains();
}
public void testEnsureCapacity() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testEnsureCapacity();
}
public void testEnsureCapacity_fail() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testEnsureCapacity_fail();
}
public void testFromByteArray() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testFromByteArray();
}
public void testFromBytes() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testFromBytes();
}
public void testIndexOf() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testIndexOf();
}
public void testIndexOf_arrayTarget() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testIndexOf_arrayTarget();
}
public void testJoin() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testJoin();
}
public void testLastIndexOf() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testLastIndexOf();
}
public void testLexicographicalComparator() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testLexicographicalComparator();
}
public void testMax() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testMax();
}
public void testMax_noArgs() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testMax_noArgs();
}
public void testMin() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testMin();
}
public void testMin_noArgs() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testMin_noArgs();
}
public void testStringConverter_convert() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testStringConverter_convert();
}
public void testStringConverter_convertError() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testStringConverter_convertError();
}
public void testStringConverter_nullConversions() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testStringConverter_nullConversions();
}
public void testStringConverter_reverse() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testStringConverter_reverse();
}
public void testToArray() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testToArray();
}
public void testToArray_threadSafe() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testToArray_threadSafe();
}
public void testToArray_withConversion() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testToArray_withConversion();
}
public void testToArray_withNull() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testToArray_withNull();
}
public void testToByteArray() throws Exception {
com.google.common.primitives.LongsTest testCase = new com.google.common.primitives.LongsTest();
testCase.testToByteArray();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/LongsTest_gwt.java | Java | asf20 | 6,447 |
/*
* Copyright (C) 2008 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.primitives;
public class UnsignedIntsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testCompare() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testCompare();
}
public void testDecodeInt() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testDecodeInt();
}
public void testDecodeIntFails() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testDecodeIntFails();
}
public void testDivide() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testDivide();
}
public void testJoin() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testJoin();
}
public void testLexicographicalComparator() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testLexicographicalComparator();
}
public void testMax() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testMax();
}
public void testMax_noArgs() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testMax_noArgs();
}
public void testMin() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testMin();
}
public void testMin_noArgs() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testMin_noArgs();
}
public void testParseInt() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testParseInt();
}
public void testParseIntThrowsExceptionForInvalidRadix() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testParseIntThrowsExceptionForInvalidRadix();
}
public void testParseIntWithRadix() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testParseIntWithRadix();
}
public void testRemainder() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testRemainder();
}
public void testToLong() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testToLong();
}
public void testToString() throws Exception {
com.google.common.primitives.UnsignedIntsTest testCase = new com.google.common.primitives.UnsignedIntsTest();
testCase.testToString();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/UnsignedIntsTest_gwt.java | Java | asf20 | 3,926 |
/*
* Copyright (C) 2008 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.primitives;
public class FloatsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.primitives.testModule";
}
public void testAsListEmpty() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testAsListEmpty();
}
public void testAsList_isAView() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testAsList_isAView();
}
public void testAsList_subList_toArray_roundTrip() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testAsList_subList_toArray_roundTrip();
}
public void testAsList_toArray_roundTrip() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testAsList_toArray_roundTrip();
}
public void testCompare() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testCompare();
}
public void testConcat() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testConcat();
}
public void testContains() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testContains();
}
public void testEnsureCapacity() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testEnsureCapacity();
}
public void testEnsureCapacity_fail() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testEnsureCapacity_fail();
}
public void testHashCode() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testHashCode();
}
public void testIndexOf() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testIndexOf();
}
public void testIndexOf_arrayTarget() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testIndexOf_arrayTarget();
}
public void testIsFinite() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testIsFinite();
}
public void testLastIndexOf() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testLastIndexOf();
}
public void testLexicographicalComparator() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testLexicographicalComparator();
}
public void testMax() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testMax();
}
public void testMax_noArgs() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testMax_noArgs();
}
public void testMin() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testMin();
}
public void testMin_noArgs() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testMin_noArgs();
}
public void testStringConverter_convertError() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testStringConverter_convertError();
}
public void testStringConverter_nullConversions() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testStringConverter_nullConversions();
}
public void testToArray() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testToArray();
}
public void testToArray_threadSafe() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testToArray_threadSafe();
}
public void testToArray_withConversion() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testToArray_withConversion();
}
public void testToArray_withNull() throws Exception {
com.google.common.primitives.FloatsTest testCase = new com.google.common.primitives.FloatsTest();
testCase.testToArray_withNull();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/primitives/FloatsTest_gwt.java | Java | asf20 | 5,536 |
/*
* Copyright (C) 2008 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;
public class FakeTickerTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.testing.testModule";
}
public void testAdvance() throws Exception {
com.google.common.testing.FakeTickerTest testCase = new com.google.common.testing.FakeTickerTest();
testCase.testAdvance();
}
public void testAutoIncrementStep_millis() throws Exception {
com.google.common.testing.FakeTickerTest testCase = new com.google.common.testing.FakeTickerTest();
testCase.testAutoIncrementStep_millis();
}
public void testAutoIncrementStep_nanos() throws Exception {
com.google.common.testing.FakeTickerTest testCase = new com.google.common.testing.FakeTickerTest();
testCase.testAutoIncrementStep_nanos();
}
public void testAutoIncrementStep_resetToZero() throws Exception {
com.google.common.testing.FakeTickerTest testCase = new com.google.common.testing.FakeTickerTest();
testCase.testAutoIncrementStep_resetToZero();
}
public void testAutoIncrementStep_returnsSameInstance() throws Exception {
com.google.common.testing.FakeTickerTest testCase = new com.google.common.testing.FakeTickerTest();
testCase.testAutoIncrementStep_returnsSameInstance();
}
public void testAutoIncrementStep_seconds() throws Exception {
com.google.common.testing.FakeTickerTest testCase = new com.google.common.testing.FakeTickerTest();
testCase.testAutoIncrementStep_seconds();
}
public void testAutoIncrement_negative() throws Exception {
com.google.common.testing.FakeTickerTest testCase = new com.google.common.testing.FakeTickerTest();
testCase.testAutoIncrement_negative();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/testing/FakeTickerTest_gwt.java | Java | asf20 | 2,280 |
/*
* Copyright (C) 2008 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;
public class EqualsTesterTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.testing.testModule";
}
public void testAddEqualObjectWithOArgConstructor() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testAddEqualObjectWithOArgConstructor();
}
public void testAddNullEqualObject() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testAddNullEqualObject();
}
public void testAddNullReference() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testAddNullReference();
}
public void testAddTwoEqualObjectsAtOnceWithNull() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testAddTwoEqualObjectsAtOnceWithNull();
}
public void testEqualityGroups() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testEqualityGroups();
}
public void testInvalidEqualsIncompatibleClass() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testInvalidEqualsIncompatibleClass();
}
public void testInvalidEqualsNull() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testInvalidEqualsNull();
}
public void testInvalidHashCode() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testInvalidHashCode();
}
public void testInvalidNotEqualsEqualObject() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testInvalidNotEqualsEqualObject();
}
public void testNonreflexiveEquals() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testNonreflexiveEquals();
}
public void testNullEqualityGroup() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testNullEqualityGroup();
}
public void testNullObjectInEqualityGroup() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testNullObjectInEqualityGroup();
}
public void testSymmetryBroken() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testSymmetryBroken();
}
public void testTestEqualsEmptyLists() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testTestEqualsEmptyLists();
}
public void testTestEqualsEqualsObjects() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testTestEqualsEqualsObjects();
}
public void testTransitivityBrokenAcrossEqualityGroups() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testTransitivityBrokenAcrossEqualityGroups();
}
public void testTransitivityBrokenInEqualityGroup() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testTransitivityBrokenInEqualityGroup();
}
public void testUnequalObjectsInEqualityGroup() throws Exception {
com.google.common.testing.EqualsTesterTest testCase = new com.google.common.testing.EqualsTesterTest();
testCase.setUp();
testCase.testUnequalObjectsInEqualityGroup();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/testing/EqualsTesterTest_gwt.java | Java | asf20 | 5,000 |
/*
* Copyright (C) 2008 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;
public class TearDownStackTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.testing.testModule";
}
public void testMultipleTearDownsHappenInOrder() throws Exception {
com.google.common.testing.TearDownStackTest testCase = new com.google.common.testing.TearDownStackTest();
Throwable failure = null;
try {
testCase.testMultipleTearDownsHappenInOrder();
} catch (Throwable t) {
failure = t;
}
try {
testCase.tearDown();
} catch (Throwable t) {
if (failure == null) {
failure = t;
}
}
if (failure instanceof Exception) {
throw (Exception) failure;
}
if (failure instanceof Error) {
throw (Error) failure;
}
if (failure != null) {
throw new RuntimeException(failure);
}
}
public void testSingleTearDown() throws Exception {
com.google.common.testing.TearDownStackTest testCase = new com.google.common.testing.TearDownStackTest();
Throwable failure = null;
try {
testCase.testSingleTearDown();
} catch (Throwable t) {
failure = t;
}
try {
testCase.tearDown();
} catch (Throwable t) {
if (failure == null) {
failure = t;
}
}
if (failure instanceof Exception) {
throw (Exception) failure;
}
if (failure instanceof Error) {
throw (Error) failure;
}
if (failure != null) {
throw new RuntimeException(failure);
}
}
public void testThrowingTearDown() throws Exception {
com.google.common.testing.TearDownStackTest testCase = new com.google.common.testing.TearDownStackTest();
Throwable failure = null;
try {
testCase.testThrowingTearDown();
} catch (Throwable t) {
failure = t;
}
try {
testCase.tearDown();
} catch (Throwable t) {
if (failure == null) {
failure = t;
}
}
if (failure instanceof Exception) {
throw (Exception) failure;
}
if (failure instanceof Error) {
throw (Error) failure;
}
if (failure != null) {
throw new RuntimeException(failure);
}
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/testing/TearDownStackTest_gwt.java | Java | asf20 | 2,663 |
/*
* Copyright (C) 2008 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;
public class EquivalenceTesterTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.testing.testModule";
}
public void testOf_NullPointerException() throws Exception {
com.google.common.testing.EquivalenceTesterTest testCase = new com.google.common.testing.EquivalenceTesterTest();
testCase.setUp();
testCase.testOf_NullPointerException();
}
public void testTest() throws Exception {
com.google.common.testing.EquivalenceTesterTest testCase = new com.google.common.testing.EquivalenceTesterTest();
testCase.setUp();
testCase.testTest();
}
public void testTest_NoData() throws Exception {
com.google.common.testing.EquivalenceTesterTest testCase = new com.google.common.testing.EquivalenceTesterTest();
testCase.setUp();
testCase.testTest_NoData();
}
public void testTest_hash() throws Exception {
com.google.common.testing.EquivalenceTesterTest testCase = new com.google.common.testing.EquivalenceTesterTest();
testCase.setUp();
testCase.testTest_hash();
}
public void testTest_inequivalence() throws Exception {
com.google.common.testing.EquivalenceTesterTest testCase = new com.google.common.testing.EquivalenceTesterTest();
testCase.setUp();
testCase.testTest_inequivalence();
}
public void testTest_symmetric() throws Exception {
com.google.common.testing.EquivalenceTesterTest testCase = new com.google.common.testing.EquivalenceTesterTest();
testCase.setUp();
testCase.testTest_symmetric();
}
public void testTest_trasitive() throws Exception {
com.google.common.testing.EquivalenceTesterTest testCase = new com.google.common.testing.EquivalenceTesterTest();
testCase.setUp();
testCase.testTest_trasitive();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/testing/EquivalenceTesterTest_gwt.java | Java | asf20 | 2,377 |
/*
* Copyright (C) 2008 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.base;
public class ConverterTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testAndThen() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testAndThen();
}
public void testApply() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testApply();
}
public void testConvertAllIsView() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testConvertAllIsView();
}
public void testConverter() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testConverter();
}
public void testFrom() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testFrom();
}
public void testIdentityConverter() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testIdentityConverter();
}
public void testNullIsNotPassedThrough() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testNullIsNotPassedThrough();
}
public void testNullIsPassedThrough() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testNullIsPassedThrough();
}
public void testReverse() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testReverse();
}
public void testReverseReverse() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testReverseReverse();
}
public void testSerialization_andThen() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testSerialization_andThen();
}
public void testSerialization_from() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testSerialization_from();
}
public void testSerialization_identity() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testSerialization_identity();
}
public void testSerialization_reverse() throws Exception {
com.google.common.base.ConverterTest testCase = new com.google.common.base.ConverterTest();
testCase.testSerialization_reverse();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/ConverterTest_gwt.java | Java | asf20 | 3,365 |
/*
* Copyright (C) 2008 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.base;
public class OptionalTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testAbsent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testAbsent();
}
public void testAsSet_absent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testAsSet_absent();
}
public void testAsSet_absentIsImmutable() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testAsSet_absentIsImmutable();
}
public void testAsSet_present() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testAsSet_present();
}
public void testAsSet_presentIsImmutable() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testAsSet_presentIsImmutable();
}
public void testEqualsAndHashCode_absent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testEqualsAndHashCode_absent();
}
public void testEqualsAndHashCode_present() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testEqualsAndHashCode_present();
}
public void testFromNullable() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testFromNullable();
}
public void testFromNullable_null() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testFromNullable_null();
}
public void testGet_absent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testGet_absent();
}
public void testGet_present() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testGet_present();
}
public void testIsPresent_no() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testIsPresent_no();
}
public void testIsPresent_yes() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testIsPresent_yes();
}
public void testOf() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOf();
}
public void testOf_null() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOf_null();
}
public void testOrNull_absent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOrNull_absent();
}
public void testOrNull_present() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOrNull_present();
}
public void testOr_Optional_absent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOr_Optional_absent();
}
public void testOr_Optional_present() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOr_Optional_present();
}
public void testOr_T_absent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOr_T_absent();
}
public void testOr_T_present() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOr_T_present();
}
public void testOr_nullSupplier_absent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOr_nullSupplier_absent();
}
public void testOr_nullSupplier_present() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOr_nullSupplier_present();
}
public void testOr_supplier_absent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOr_supplier_absent();
}
public void testOr_supplier_present() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testOr_supplier_present();
}
public void testPresentInstances_allAbsent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testPresentInstances_allAbsent();
}
public void testPresentInstances_allPresent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testPresentInstances_allPresent();
}
public void testPresentInstances_callingIteratorTwice() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testPresentInstances_callingIteratorTwice();
}
public void testPresentInstances_somePresent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testPresentInstances_somePresent();
}
public void testPresentInstances_wildcards() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testPresentInstances_wildcards();
}
public void testSampleCodeError1() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testSampleCodeError1();
}
public void testSampleCodeError2() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testSampleCodeError2();
}
public void testSampleCodeFine1() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testSampleCodeFine1();
}
public void testSampleCodeFine2() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testSampleCodeFine2();
}
public void testToString_absent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testToString_absent();
}
public void testToString_present() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testToString_present();
}
public void testTransform_absent() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testTransform_absent();
}
public void testTransform_abssent_functionReturnsNull() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testTransform_abssent_functionReturnsNull();
}
public void testTransform_presentIdentity() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testTransform_presentIdentity();
}
public void testTransform_presentToString() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testTransform_presentToString();
}
public void testTransform_present_functionReturnsNull() throws Exception {
com.google.common.base.OptionalTest testCase = new com.google.common.base.OptionalTest();
testCase.testTransform_present_functionReturnsNull();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/OptionalTest_gwt.java | Java | asf20 | 8,550 |
/*
* Copyright (C) 2008 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.base;
public class StringsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testCommonPrefix() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testCommonPrefix();
}
public void testCommonSuffix() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testCommonSuffix();
}
public void testEmptyToNull() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testEmptyToNull();
}
public void testIsNullOrEmpty() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testIsNullOrEmpty();
}
public void testNullToEmpty() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testNullToEmpty();
}
public void testPadEnd_negativeMinLength() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testPadEnd_negativeMinLength();
}
public void testPadEnd_noPadding() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testPadEnd_noPadding();
}
public void testPadEnd_null() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testPadEnd_null();
}
public void testPadEnd_somePadding() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testPadEnd_somePadding();
}
public void testPadStart_negativeMinLength() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testPadStart_negativeMinLength();
}
public void testPadStart_noPadding() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testPadStart_noPadding();
}
public void testPadStart_null() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testPadStart_null();
}
public void testPadStart_somePadding() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testPadStart_somePadding();
}
public void testRepeat() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testRepeat();
}
public void testRepeat_null() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testRepeat_null();
}
public void testValidSurrogatePairAt() throws Exception {
com.google.common.base.StringsTest testCase = new com.google.common.base.StringsTest();
testCase.testValidSurrogatePairAt();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/StringsTest_gwt.java | Java | asf20 | 3,687 |
/*
* Copyright (C) 2008 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.base;
public class ObjectsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testEqual() throws Exception {
com.google.common.base.ObjectsTest testCase = new com.google.common.base.ObjectsTest();
testCase.testEqual();
}
public void testFirstNonNull_throwsNullPointerException() throws Exception {
com.google.common.base.ObjectsTest testCase = new com.google.common.base.ObjectsTest();
testCase.testFirstNonNull_throwsNullPointerException();
}
public void testFirstNonNull_withNonNull() throws Exception {
com.google.common.base.ObjectsTest testCase = new com.google.common.base.ObjectsTest();
testCase.testFirstNonNull_withNonNull();
}
public void testHashCode() throws Exception {
com.google.common.base.ObjectsTest testCase = new com.google.common.base.ObjectsTest();
testCase.testHashCode();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/ObjectsTest_gwt.java | Java | asf20 | 1,555 |
/*
* Copyright (C) 2008 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.base;
public class CharsetsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testUtf8() throws Exception {
com.google.common.base.CharsetsTest testCase = new com.google.common.base.CharsetsTest();
testCase.testUtf8();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/CharsetsTest_gwt.java | Java | asf20 | 964 |
/*
* Copyright (C) 2008 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.base;
public class VerifyTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testVerifyNotNull_complexMessage_success() throws Exception {
com.google.common.base.VerifyTest testCase = new com.google.common.base.VerifyTest();
testCase.testVerifyNotNull_complexMessage_success();
}
public void testVerifyNotNull_simpleMessage_failure() throws Exception {
com.google.common.base.VerifyTest testCase = new com.google.common.base.VerifyTest();
testCase.testVerifyNotNull_simpleMessage_failure();
}
public void testVerifyNotNull_simple_failure() throws Exception {
com.google.common.base.VerifyTest testCase = new com.google.common.base.VerifyTest();
testCase.testVerifyNotNull_simple_failure();
}
public void testVerifyNotNull_simple_success() throws Exception {
com.google.common.base.VerifyTest testCase = new com.google.common.base.VerifyTest();
testCase.testVerifyNotNull_simple_success();
}
public void testVerify_complexMessage_failure() throws Exception {
com.google.common.base.VerifyTest testCase = new com.google.common.base.VerifyTest();
testCase.testVerify_complexMessage_failure();
}
public void testVerify_complexMessage_success() throws Exception {
com.google.common.base.VerifyTest testCase = new com.google.common.base.VerifyTest();
testCase.testVerify_complexMessage_success();
}
public void testVerify_simpleMessage_failure() throws Exception {
com.google.common.base.VerifyTest testCase = new com.google.common.base.VerifyTest();
testCase.testVerify_simpleMessage_failure();
}
public void testVerify_simpleMessage_success() throws Exception {
com.google.common.base.VerifyTest testCase = new com.google.common.base.VerifyTest();
testCase.testVerify_simpleMessage_success();
}
public void testVerify_simple_failure() throws Exception {
com.google.common.base.VerifyTest testCase = new com.google.common.base.VerifyTest();
testCase.testVerify_simple_failure();
}
public void testVerify_simple_success() throws Exception {
com.google.common.base.VerifyTest testCase = new com.google.common.base.VerifyTest();
testCase.testVerify_simple_success();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/VerifyTest_gwt.java | Java | asf20 | 2,848 |
/*
* Copyright (C) 2008 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.base;
public class AbstractIteratorTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testCantRemove() throws Exception {
com.google.common.base.AbstractIteratorTest testCase = new com.google.common.base.AbstractIteratorTest();
testCase.testCantRemove();
}
public void testDefaultBehaviorOfNextAndHasNext() throws Exception {
com.google.common.base.AbstractIteratorTest testCase = new com.google.common.base.AbstractIteratorTest();
testCase.testDefaultBehaviorOfNextAndHasNext();
}
public void testException() throws Exception {
com.google.common.base.AbstractIteratorTest testCase = new com.google.common.base.AbstractIteratorTest();
testCase.testException();
}
public void testExceptionAfterEndOfData() throws Exception {
com.google.common.base.AbstractIteratorTest testCase = new com.google.common.base.AbstractIteratorTest();
testCase.testExceptionAfterEndOfData();
}
public void testReentrantHasNext() throws Exception {
com.google.common.base.AbstractIteratorTest testCase = new com.google.common.base.AbstractIteratorTest();
testCase.testReentrantHasNext();
}
public void testSneakyThrow() throws Exception {
com.google.common.base.AbstractIteratorTest testCase = new com.google.common.base.AbstractIteratorTest();
testCase.testSneakyThrow();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/AbstractIteratorTest_gwt.java | Java | asf20 | 2,020 |
/*
* Copyright (C) 2008 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.base;
public class Utf8Test_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testEncodedLength_invalidStrings() throws Exception {
com.google.common.base.Utf8Test testCase = new com.google.common.base.Utf8Test();
testCase.testEncodedLength_invalidStrings();
}
public void testEncodedLength_validStrings() throws Exception {
com.google.common.base.Utf8Test testCase = new com.google.common.base.Utf8Test();
testCase.testEncodedLength_validStrings();
}
public void testIsWellFormed_4BytesSamples() throws Exception {
com.google.common.base.Utf8Test testCase = new com.google.common.base.Utf8Test();
testCase.testIsWellFormed_4BytesSamples();
}
public void testShardsHaveExpectedRoundTrippables() throws Exception {
com.google.common.base.Utf8Test testCase = new com.google.common.base.Utf8Test();
testCase.testShardsHaveExpectedRoundTrippables();
}
public void testSomeSequences() throws Exception {
com.google.common.base.Utf8Test testCase = new com.google.common.base.Utf8Test();
testCase.testSomeSequences();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/Utf8Test_gwt.java | Java | asf20 | 1,772 |
/*
* Copyright (C) 2008 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.base;
public class PreconditionsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testCheckArgument_complexMessage_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckArgument_complexMessage_failure();
}
public void testCheckArgument_complexMessage_success() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckArgument_complexMessage_success();
}
public void testCheckArgument_nullMessage_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckArgument_nullMessage_failure();
}
public void testCheckArgument_simpleMessage_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckArgument_simpleMessage_failure();
}
public void testCheckArgument_simpleMessage_success() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckArgument_simpleMessage_success();
}
public void testCheckArgument_simple_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckArgument_simple_failure();
}
public void testCheckArgument_simple_success() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckArgument_simple_success();
}
public void testCheckElementIndex_badSize() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckElementIndex_badSize();
}
public void testCheckElementIndex_negative() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckElementIndex_negative();
}
public void testCheckElementIndex_ok() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckElementIndex_ok();
}
public void testCheckElementIndex_tooHigh() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckElementIndex_tooHigh();
}
public void testCheckElementIndex_withDesc_negative() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckElementIndex_withDesc_negative();
}
public void testCheckElementIndex_withDesc_tooHigh() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckElementIndex_withDesc_tooHigh();
}
public void testCheckNotNull_complexMessage_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckNotNull_complexMessage_failure();
}
public void testCheckNotNull_complexMessage_success() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckNotNull_complexMessage_success();
}
public void testCheckNotNull_simpleMessage_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckNotNull_simpleMessage_failure();
}
public void testCheckNotNull_simpleMessage_success() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckNotNull_simpleMessage_success();
}
public void testCheckNotNull_simple_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckNotNull_simple_failure();
}
public void testCheckNotNull_simple_success() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckNotNull_simple_success();
}
public void testCheckPositionIndex_badSize() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndex_badSize();
}
public void testCheckPositionIndex_negative() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndex_negative();
}
public void testCheckPositionIndex_ok() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndex_ok();
}
public void testCheckPositionIndex_startNegative() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndex_startNegative();
}
public void testCheckPositionIndex_tooHigh() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndex_tooHigh();
}
public void testCheckPositionIndex_withDesc_negative() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndex_withDesc_negative();
}
public void testCheckPositionIndex_withDesc_tooHigh() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndex_withDesc_tooHigh();
}
public void testCheckPositionIndexes_badSize() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndexes_badSize();
}
public void testCheckPositionIndexes_endTooHigh() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndexes_endTooHigh();
}
public void testCheckPositionIndexes_ok() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndexes_ok();
}
public void testCheckPositionIndexes_reversed() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckPositionIndexes_reversed();
}
public void testCheckState_complexMessage_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckState_complexMessage_failure();
}
public void testCheckState_complexMessage_success() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckState_complexMessage_success();
}
public void testCheckState_nullMessage_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckState_nullMessage_failure();
}
public void testCheckState_simpleMessage_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckState_simpleMessage_failure();
}
public void testCheckState_simpleMessage_success() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckState_simpleMessage_success();
}
public void testCheckState_simple_failure() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckState_simple_failure();
}
public void testCheckState_simple_success() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testCheckState_simple_success();
}
public void testFormat() throws Exception {
com.google.common.base.PreconditionsTest testCase = new com.google.common.base.PreconditionsTest();
testCase.testFormat();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/PreconditionsTest_gwt.java | Java | asf20 | 9,201 |
/*
* Copyright (C) 2008 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.base;
public class CaseFormatTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testConverterToBackward() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testConverterToBackward();
}
public void testConverterToForward() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testConverterToForward();
}
public void testConverter_nullConversions() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testConverter_nullConversions();
}
public void testConverter_serialization() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testConverter_serialization();
}
public void testConverter_toString() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testConverter_toString();
}
public void testIdentity() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testIdentity();
}
public void testLowerCamelToLowerCamel() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerCamelToLowerCamel();
}
public void testLowerCamelToLowerHyphen() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerCamelToLowerHyphen();
}
public void testLowerCamelToLowerUnderscore() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerCamelToLowerUnderscore();
}
public void testLowerCamelToUpperCamel() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerCamelToUpperCamel();
}
public void testLowerCamelToUpperUnderscore() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerCamelToUpperUnderscore();
}
public void testLowerHyphenToLowerCamel() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerHyphenToLowerCamel();
}
public void testLowerHyphenToLowerHyphen() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerHyphenToLowerHyphen();
}
public void testLowerHyphenToLowerUnderscore() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerHyphenToLowerUnderscore();
}
public void testLowerHyphenToUpperCamel() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerHyphenToUpperCamel();
}
public void testLowerHyphenToUpperUnderscore() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerHyphenToUpperUnderscore();
}
public void testLowerUnderscoreToLowerCamel() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerUnderscoreToLowerCamel();
}
public void testLowerUnderscoreToLowerHyphen() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerUnderscoreToLowerHyphen();
}
public void testLowerUnderscoreToLowerUnderscore() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerUnderscoreToLowerUnderscore();
}
public void testLowerUnderscoreToUpperCamel() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerUnderscoreToUpperCamel();
}
public void testLowerUnderscoreToUpperUnderscore() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testLowerUnderscoreToUpperUnderscore();
}
public void testUpperCamelToLowerCamel() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testUpperCamelToLowerCamel();
}
public void testUpperCamelToLowerHyphen() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testUpperCamelToLowerHyphen();
}
public void testUpperCamelToLowerUnderscore() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testUpperCamelToLowerUnderscore();
}
public void testUpperCamelToUpperCamel() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testUpperCamelToUpperCamel();
}
public void testUpperCamelToUpperUnderscore() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testUpperCamelToUpperUnderscore();
}
public void testUpperUnderscoreToLowerCamel() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testUpperUnderscoreToLowerCamel();
}
public void testUpperUnderscoreToLowerHyphen() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testUpperUnderscoreToLowerHyphen();
}
public void testUpperUnderscoreToLowerUnderscore() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testUpperUnderscoreToLowerUnderscore();
}
public void testUpperUnderscoreToUpperCamel() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testUpperUnderscoreToUpperCamel();
}
public void testUpperUnderscoreToUpperUnderscore() throws Exception {
com.google.common.base.CaseFormatTest testCase = new com.google.common.base.CaseFormatTest();
testCase.testUpperUnderscoreToUpperUnderscore();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/CaseFormatTest_gwt.java | Java | asf20 | 7,184 |
/*
* Copyright (C) 2008 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.base;
public class ToStringHelperTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testConstructorLenient_anonymousClass() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testConstructorLenient_anonymousClass();
}
public void testConstructorLenient_classObject() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testConstructorLenient_classObject();
}
public void testConstructorLenient_innerClass() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testConstructorLenient_innerClass();
}
public void testConstructorLenient_instance() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testConstructorLenient_instance();
}
public void testConstructor_stringObject() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testConstructor_stringObject();
}
public void testToStringHelperLenient_localInnerClass() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToStringHelperLenient_localInnerClass();
}
public void testToStringHelperLenient_localInnerNestedClass() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToStringHelperLenient_localInnerNestedClass();
}
public void testToStringHelperLenient_moreThanNineAnonymousClasses() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToStringHelperLenient_moreThanNineAnonymousClasses();
}
public void testToStringLenient_addValue() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToStringLenient_addValue();
}
public void testToStringLenient_addValueWithNullValue() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToStringLenient_addValueWithNullValue();
}
public void testToStringLenient_addWithNullValue() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToStringLenient_addWithNullValue();
}
public void testToStringLenient_complexFields() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToStringLenient_complexFields();
}
public void testToStringLenient_nullInteger() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToStringLenient_nullInteger();
}
public void testToStringLenient_oneField() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToStringLenient_oneField();
}
public void testToStringLenient_oneIntegerField() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToStringLenient_oneIntegerField();
}
public void testToString_addWithNullName() throws Exception {
com.google.common.base.ToStringHelperTest testCase = new com.google.common.base.ToStringHelperTest();
testCase.testToString_addWithNullName();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/ToStringHelperTest_gwt.java | Java | asf20 | 4,436 |
/*
* Copyright (C) 2008 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.base;
public class SuppliersTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testCompose() throws Exception {
com.google.common.base.SuppliersTest testCase = new com.google.common.base.SuppliersTest();
testCase.testCompose();
}
public void testComposeWithLists() throws Exception {
com.google.common.base.SuppliersTest testCase = new com.google.common.base.SuppliersTest();
testCase.testComposeWithLists();
}
public void testCompose_equals() throws Exception {
com.google.common.base.SuppliersTest testCase = new com.google.common.base.SuppliersTest();
testCase.testCompose_equals();
}
public void testMemoize() throws Exception {
com.google.common.base.SuppliersTest testCase = new com.google.common.base.SuppliersTest();
testCase.testMemoize();
}
public void testMemoizeExceptionThrown() throws Exception {
com.google.common.base.SuppliersTest testCase = new com.google.common.base.SuppliersTest();
testCase.testMemoizeExceptionThrown();
}
public void testMemoize_redudantly() throws Exception {
com.google.common.base.SuppliersTest testCase = new com.google.common.base.SuppliersTest();
testCase.testMemoize_redudantly();
}
public void testOfInstanceSuppliesNull() throws Exception {
com.google.common.base.SuppliersTest testCase = new com.google.common.base.SuppliersTest();
testCase.testOfInstanceSuppliesNull();
}
public void testOfInstanceSuppliesSameInstance() throws Exception {
com.google.common.base.SuppliersTest testCase = new com.google.common.base.SuppliersTest();
testCase.testOfInstanceSuppliesSameInstance();
}
public void testOfInstance_equals() throws Exception {
com.google.common.base.SuppliersTest testCase = new com.google.common.base.SuppliersTest();
testCase.testOfInstance_equals();
}
public void testSupplierFunction() throws Exception {
com.google.common.base.SuppliersTest testCase = new com.google.common.base.SuppliersTest();
testCase.testSupplierFunction();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/SuppliersTest_gwt.java | Java | asf20 | 2,683 |
/*
* Copyright (C) 2008 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.base;
public class AsciiTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testCharsIgnored() throws Exception {
com.google.common.base.AsciiTest testCase = new com.google.common.base.AsciiTest();
testCase.testCharsIgnored();
}
public void testCharsLower() throws Exception {
com.google.common.base.AsciiTest testCase = new com.google.common.base.AsciiTest();
testCase.testCharsLower();
}
public void testCharsUpper() throws Exception {
com.google.common.base.AsciiTest testCase = new com.google.common.base.AsciiTest();
testCase.testCharsUpper();
}
public void testEqualsIgnoreCase() throws Exception {
com.google.common.base.AsciiTest testCase = new com.google.common.base.AsciiTest();
testCase.testEqualsIgnoreCase();
}
public void testEqualsIgnoreCaseUnicodeEquivalence() throws Exception {
com.google.common.base.AsciiTest testCase = new com.google.common.base.AsciiTest();
testCase.testEqualsIgnoreCaseUnicodeEquivalence();
}
public void testToLowerCase() throws Exception {
com.google.common.base.AsciiTest testCase = new com.google.common.base.AsciiTest();
testCase.testToLowerCase();
}
public void testToUpperCase() throws Exception {
com.google.common.base.AsciiTest testCase = new com.google.common.base.AsciiTest();
testCase.testToUpperCase();
}
public void testTruncate() throws Exception {
com.google.common.base.AsciiTest testCase = new com.google.common.base.AsciiTest();
testCase.testTruncate();
}
public void testTruncateIllegalArguments() throws Exception {
com.google.common.base.AsciiTest testCase = new com.google.common.base.AsciiTest();
testCase.testTruncateIllegalArguments();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/AsciiTest_gwt.java | Java | asf20 | 2,387 |
/*
* Copyright (C) 2008 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.base;
public class EnumsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testGetIfPresent() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testGetIfPresent();
}
public void testGetIfPresent_caseSensitive() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testGetIfPresent_caseSensitive();
}
public void testGetIfPresent_whenNoMatchingConstant() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testGetIfPresent_whenNoMatchingConstant();
}
public void testStringConverter_convert() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testStringConverter_convert();
}
public void testStringConverter_convertError() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testStringConverter_convertError();
}
public void testStringConverter_nullConversions() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testStringConverter_nullConversions();
}
public void testStringConverter_reverse() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testStringConverter_reverse();
}
public void testStringConverter_serialization() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testStringConverter_serialization();
}
public void testValueOfFunction() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testValueOfFunction();
}
public void testValueOfFunction_caseSensitive() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testValueOfFunction_caseSensitive();
}
public void testValueOfFunction_equals() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testValueOfFunction_equals();
}
public void testValueOfFunction_nullWhenNoMatchingConstant() throws Exception {
com.google.common.base.EnumsTest testCase = new com.google.common.base.EnumsTest();
testCase.testValueOfFunction_nullWhenNoMatchingConstant();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/EnumsTest_gwt.java | Java | asf20 | 3,183 |
/*
* Copyright (C) 2008 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.base;
public class CharMatcherTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testAllMatches() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testAllMatches();
}
public void testAnyAndNone_logicalOps() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testAnyAndNone_logicalOps();
}
public void testCollapse() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testCollapse();
}
public void testCollapse_any() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testCollapse_any();
}
public void testEmpty() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testEmpty();
}
public void testGeneral() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testGeneral();
}
public void testNoMatches() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testNoMatches();
}
public void testPrecomputedOptimizations() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testPrecomputedOptimizations();
}
public void testReplaceFrom() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testReplaceFrom();
}
public void testToString() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testToString();
}
public void testTrimAndCollapse() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testTrimAndCollapse();
}
public void testTrimFrom() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testTrimFrom();
}
public void testTrimLeadingFrom() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testTrimLeadingFrom();
}
public void testTrimTrailingFrom() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testTrimTrailingFrom();
}
public void testWhitespaceBreakingWhitespaceSubset() throws Exception {
com.google.common.base.CharMatcherTest testCase = new com.google.common.base.CharMatcherTest();
testCase.testWhitespaceBreakingWhitespaceSubset();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/CharMatcherTest_gwt.java | Java | asf20 | 3,583 |
/*
* Copyright (C) 2008 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.base;
public class EquivalenceTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testEquals() throws Exception {
com.google.common.base.EquivalenceTest testCase = new com.google.common.base.EquivalenceTest();
testCase.testEquals();
}
public void testEqualsEquivalent() throws Exception {
com.google.common.base.EquivalenceTest testCase = new com.google.common.base.EquivalenceTest();
testCase.testEqualsEquivalent();
}
public void testEquivalentTo() throws Exception {
com.google.common.base.EquivalenceTest testCase = new com.google.common.base.EquivalenceTest();
testCase.testEquivalentTo();
}
public void testIdentityEquivalent() throws Exception {
com.google.common.base.EquivalenceTest testCase = new com.google.common.base.EquivalenceTest();
testCase.testIdentityEquivalent();
}
public void testOnResultOf() throws Exception {
com.google.common.base.EquivalenceTest testCase = new com.google.common.base.EquivalenceTest();
testCase.testOnResultOf();
}
public void testOnResultOf_equals() throws Exception {
com.google.common.base.EquivalenceTest testCase = new com.google.common.base.EquivalenceTest();
testCase.testOnResultOf_equals();
}
public void testPairwiseEquivalent() throws Exception {
com.google.common.base.EquivalenceTest testCase = new com.google.common.base.EquivalenceTest();
testCase.testPairwiseEquivalent();
}
public void testPairwiseEquivalent_equals() throws Exception {
com.google.common.base.EquivalenceTest testCase = new com.google.common.base.EquivalenceTest();
testCase.testPairwiseEquivalent_equals();
}
public void testWrap() throws Exception {
com.google.common.base.EquivalenceTest testCase = new com.google.common.base.EquivalenceTest();
testCase.testWrap();
}
public void testWrap_get() throws Exception {
com.google.common.base.EquivalenceTest testCase = new com.google.common.base.EquivalenceTest();
testCase.testWrap_get();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/EquivalenceTest_gwt.java | Java | asf20 | 2,655 |
/*
* Copyright (C) 2008 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.base;
public class PredicatesTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testAlwaysFalse_apply() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAlwaysFalse_apply();
}
public void testAlwaysFalse_equality() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAlwaysFalse_equality();
}
public void testAlwaysTrue_apply() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAlwaysTrue_apply();
}
public void testAlwaysTrue_equality() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAlwaysTrue_equality();
}
public void testAnd_applyBinary() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_applyBinary();
}
public void testAnd_applyIterable() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_applyIterable();
}
public void testAnd_applyNoArgs() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_applyNoArgs();
}
public void testAnd_applyOneArg() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_applyOneArg();
}
public void testAnd_applyTernary() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_applyTernary();
}
public void testAnd_arrayDefensivelyCopied() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_arrayDefensivelyCopied();
}
public void testAnd_equalityBinary() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_equalityBinary();
}
public void testAnd_equalityIterable() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_equalityIterable();
}
public void testAnd_equalityNoArgs() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_equalityNoArgs();
}
public void testAnd_equalityOneArg() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_equalityOneArg();
}
public void testAnd_equalityTernary() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_equalityTernary();
}
public void testAnd_iterableDefensivelyCopied() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_iterableDefensivelyCopied();
}
public void testAnd_listDefensivelyCopied() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testAnd_listDefensivelyCopied();
}
public void testCompose() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testCompose();
}
public void testHashCodeForBooleanOperations() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testHashCodeForBooleanOperations();
}
public void testIn_apply() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIn_apply();
}
public void testIn_compilesWithExplicitSupertype() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIn_compilesWithExplicitSupertype();
}
public void testIn_equality() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIn_equality();
}
public void testIn_handlesClassCastException() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIn_handlesClassCastException();
}
public void testIn_handlesNullPointerException() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIn_handlesNullPointerException();
}
public void testIsEqualToNull_apply() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIsEqualToNull_apply();
}
public void testIsEqualToNull_equality() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIsEqualToNull_equality();
}
public void testIsEqualTo_apply() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIsEqualTo_apply();
}
public void testIsEqualTo_equality() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIsEqualTo_equality();
}
public void testIsNull_apply() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIsNull_apply();
}
public void testIsNull_equality() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testIsNull_equality();
}
public void testNotNull_apply() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testNotNull_apply();
}
public void testNotNull_equality() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testNotNull_equality();
}
public void testNot_apply() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testNot_apply();
}
public void testNot_equality() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testNot_equality();
}
public void testNot_equalityForNotOfKnownValues() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testNot_equalityForNotOfKnownValues();
}
public void testOr_applyBinary() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_applyBinary();
}
public void testOr_applyIterable() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_applyIterable();
}
public void testOr_applyNoArgs() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_applyNoArgs();
}
public void testOr_applyOneArg() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_applyOneArg();
}
public void testOr_applyTernary() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_applyTernary();
}
public void testOr_arrayDefensivelyCopied() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_arrayDefensivelyCopied();
}
public void testOr_equalityBinary() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_equalityBinary();
}
public void testOr_equalityIterable() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_equalityIterable();
}
public void testOr_equalityNoArgs() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_equalityNoArgs();
}
public void testOr_equalityOneArg() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_equalityOneArg();
}
public void testOr_equalityTernary() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_equalityTernary();
}
public void testOr_iterableDefensivelyCopied() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_iterableDefensivelyCopied();
}
public void testOr_listDefensivelyCopied() throws Exception {
com.google.common.base.PredicatesTest testCase = new com.google.common.base.PredicatesTest();
testCase.testOr_listDefensivelyCopied();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/PredicatesTest_gwt.java | Java | asf20 | 10,068 |
/*
* Copyright (C) 2008 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.base;
public class FunctionsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testComposeOfFunctionsIsAssociative() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testComposeOfFunctionsIsAssociative();
}
public void testComposeOfPredicateAndFunctionIsAssociative() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testComposeOfPredicateAndFunctionIsAssociative();
}
public void testComposition() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testComposition();
}
public void testCompositionWildcard() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testCompositionWildcard();
}
public void testConstant() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testConstant();
}
public void testForMapWildCardWithDefault() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testForMapWildCardWithDefault();
}
public void testForMapWithDefault() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testForMapWithDefault();
}
public void testForMapWithDefault_null() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testForMapWithDefault_null();
}
public void testForMapWithoutDefault() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testForMapWithoutDefault();
}
public void testForPredicate() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testForPredicate();
}
public void testForSupplier() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testForSupplier();
}
public void testIdentity_notSame() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testIdentity_notSame();
}
public void testIdentity_same() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testIdentity_same();
}
public void testToStringFunction_apply() throws Exception {
com.google.common.base.FunctionsTest testCase = new com.google.common.base.FunctionsTest();
testCase.testToStringFunction_apply();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/FunctionsTest_gwt.java | Java | asf20 | 3,499 |
/*
* Copyright (C) 2008 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.base;
public class StopwatchTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testCreateStarted() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testCreateStarted();
}
public void testCreateUnstarted() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testCreateUnstarted();
}
public void testElapsedMillis() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testElapsedMillis();
}
public void testElapsedMillis_multipleSegments() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testElapsedMillis_multipleSegments();
}
public void testElapsedMillis_notRunning() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testElapsedMillis_notRunning();
}
public void testElapsedMillis_whileRunning() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testElapsedMillis_whileRunning();
}
public void testElapsed_micros() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testElapsed_micros();
}
public void testElapsed_millis() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testElapsed_millis();
}
public void testElapsed_multipleSegments() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testElapsed_multipleSegments();
}
public void testElapsed_notRunning() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testElapsed_notRunning();
}
public void testElapsed_whileRunning() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testElapsed_whileRunning();
}
public void testInitialState() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testInitialState();
}
public void testReset_new() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testReset_new();
}
public void testReset_whileRunning() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testReset_whileRunning();
}
public void testStart() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testStart();
}
public void testStart_whileRunning() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testStart_whileRunning();
}
public void testStop() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testStop();
}
public void testStop_alreadyStopped() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testStop_alreadyStopped();
}
public void testStop_new() throws Exception {
com.google.common.base.StopwatchTest testCase = new com.google.common.base.StopwatchTest();
testCase.testStop_new();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/StopwatchTest_gwt.java | Java | asf20 | 4,339 |
/*
* Copyright (C) 2008 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.base;
public class SplitterTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testCharacterSimpleSplit() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSimpleSplit();
}
public void testCharacterSimpleSplitToList() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSimpleSplitToList();
}
public void testCharacterSimpleSplitWithNoDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSimpleSplitWithNoDelimiter();
}
public void testCharacterSplitEmptyToken() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitEmptyToken();
}
public void testCharacterSplitEmptyTokenOmitEmptyStrings() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitEmptyTokenOmitEmptyStrings();
}
public void testCharacterSplitOnEmptyString() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitOnEmptyString();
}
public void testCharacterSplitOnEmptyStringOmitEmptyStrings() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitOnEmptyStringOmitEmptyStrings();
}
public void testCharacterSplitOnOnlyDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitOnOnlyDelimiter();
}
public void testCharacterSplitOnOnlyDelimitersOmitEmptyStrings() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitOnOnlyDelimitersOmitEmptyStrings();
}
public void testCharacterSplitWithDoubleDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitWithDoubleDelimiter();
}
public void testCharacterSplitWithDoubleDelimiterAndSpace() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitWithDoubleDelimiterAndSpace();
}
public void testCharacterSplitWithDoubleDelimiterOmitEmptyStrings() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitWithDoubleDelimiterOmitEmptyStrings();
}
public void testCharacterSplitWithLeadingDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitWithLeadingDelimiter();
}
public void testCharacterSplitWithMatcherDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitWithMatcherDelimiter();
}
public void testCharacterSplitWithMulitpleLetters() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitWithMulitpleLetters();
}
public void testCharacterSplitWithTrailingDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitWithTrailingDelimiter();
}
public void testCharacterSplitWithTrim() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testCharacterSplitWithTrim();
}
public void testFixedLengthSimpleSplit() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testFixedLengthSimpleSplit();
}
public void testFixedLengthSplitEmptyString() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testFixedLengthSplitEmptyString();
}
public void testFixedLengthSplitEmptyStringWithOmitEmptyStrings() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testFixedLengthSplitEmptyStringWithOmitEmptyStrings();
}
public void testFixedLengthSplitEqualChunkLength() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testFixedLengthSplitEqualChunkLength();
}
public void testFixedLengthSplitIntoChars() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testFixedLengthSplitIntoChars();
}
public void testFixedLengthSplitNegativeChunkLen() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testFixedLengthSplitNegativeChunkLen();
}
public void testFixedLengthSplitOnlyOneChunk() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testFixedLengthSplitOnlyOneChunk();
}
public void testFixedLengthSplitSmallerString() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testFixedLengthSplitSmallerString();
}
public void testFixedLengthSplitZeroChunkLen() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testFixedLengthSplitZeroChunkLen();
}
public void testInvalidZeroLimit() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testInvalidZeroLimit();
}
public void testLimitExtraSeparators() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitExtraSeparators();
}
public void testLimitExtraSeparatorsOmitEmpty() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitExtraSeparatorsOmitEmpty();
}
public void testLimitExtraSeparatorsOmitEmpty3() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitExtraSeparatorsOmitEmpty3();
}
public void testLimitExtraSeparatorsTrim() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitExtraSeparatorsTrim();
}
public void testLimitExtraSeparatorsTrim1() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitExtraSeparatorsTrim1();
}
public void testLimitExtraSeparatorsTrim1Empty() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitExtraSeparatorsTrim1Empty();
}
public void testLimitExtraSeparatorsTrim1EmptyOmit() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitExtraSeparatorsTrim1EmptyOmit();
}
public void testLimitExtraSeparatorsTrim1NoOmit() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitExtraSeparatorsTrim1NoOmit();
}
public void testLimitExtraSeparatorsTrim3() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitExtraSeparatorsTrim3();
}
public void testLimitFixedLength() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitFixedLength();
}
public void testLimitLarge() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitLarge();
}
public void testLimitOne() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitOne();
}
public void testLimitSeparator() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testLimitSeparator();
}
public void testMapSplitter_CharacterSeparator() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testMapSplitter_CharacterSeparator();
}
public void testMapSplitter_duplicateKeys() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testMapSplitter_duplicateKeys();
}
public void testMapSplitter_emptySeparator() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testMapSplitter_emptySeparator();
}
public void testMapSplitter_malformedEntry() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testMapSplitter_malformedEntry();
}
public void testMapSplitter_multiCharacterSeparator() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testMapSplitter_multiCharacterSeparator();
}
public void testMapSplitter_notTrimmed() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testMapSplitter_notTrimmed();
}
public void testMapSplitter_orderedResults() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testMapSplitter_orderedResults();
}
public void testMapSplitter_trimmedBoth() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testMapSplitter_trimmedBoth();
}
public void testMapSplitter_trimmedEntries() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testMapSplitter_trimmedEntries();
}
public void testMapSplitter_trimmedKeyValue() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testMapSplitter_trimmedKeyValue();
}
public void testSplitNullString() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testSplitNullString();
}
public void testSplitterIterableIsLazy_char() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testSplitterIterableIsLazy_char();
}
public void testSplitterIterableIsLazy_string() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testSplitterIterableIsLazy_string();
}
public void testSplitterIterableIsUnmodifiable_char() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testSplitterIterableIsUnmodifiable_char();
}
public void testSplitterIterableIsUnmodifiable_string() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testSplitterIterableIsUnmodifiable_string();
}
public void testStringSimpleSplit() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSimpleSplit();
}
public void testStringSimpleSplitWithNoDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSimpleSplitWithNoDelimiter();
}
public void testStringSplitEmptyToken() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitEmptyToken();
}
public void testStringSplitEmptyTokenOmitEmptyStrings() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitEmptyTokenOmitEmptyStrings();
}
public void testStringSplitOnEmptyString() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitOnEmptyString();
}
public void testStringSplitOnEmptyStringOmitEmptyString() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitOnEmptyStringOmitEmptyString();
}
public void testStringSplitOnOnlyDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitOnOnlyDelimiter();
}
public void testStringSplitOnOnlyDelimitersOmitEmptyStrings() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitOnOnlyDelimitersOmitEmptyStrings();
}
public void testStringSplitWithDelimiterSubstringInValue() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithDelimiterSubstringInValue();
}
public void testStringSplitWithDoubleDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithDoubleDelimiter();
}
public void testStringSplitWithDoubleDelimiterAndSpace() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithDoubleDelimiterAndSpace();
}
public void testStringSplitWithDoubleDelimiterOmitEmptyStrings() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithDoubleDelimiterOmitEmptyStrings();
}
public void testStringSplitWithEmptyString() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithEmptyString();
}
public void testStringSplitWithLeadingDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithLeadingDelimiter();
}
public void testStringSplitWithLongDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithLongDelimiter();
}
public void testStringSplitWithLongLeadingDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithLongLeadingDelimiter();
}
public void testStringSplitWithLongTrailingDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithLongTrailingDelimiter();
}
public void testStringSplitWithMultipleLetters() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithMultipleLetters();
}
public void testStringSplitWithTrailingDelimiter() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithTrailingDelimiter();
}
public void testStringSplitWithTrim() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testStringSplitWithTrim();
}
public void testToString() throws Exception {
com.google.common.base.SplitterTest testCase = new com.google.common.base.SplitterTest();
testCase.testToString();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/SplitterTest_gwt.java | Java | asf20 | 16,756 |
/*
* Copyright (C) 2008 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.base;
public class JoinerTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.base.testModule";
}
public void testEntries() throws Exception {
com.google.common.base.JoinerTest testCase = new com.google.common.base.JoinerTest();
testCase.testEntries();
}
public void testMap() throws Exception {
com.google.common.base.JoinerTest testCase = new com.google.common.base.JoinerTest();
testCase.testMap();
}
public void testNoSpecialNullBehavior() throws Exception {
com.google.common.base.JoinerTest testCase = new com.google.common.base.JoinerTest();
testCase.testNoSpecialNullBehavior();
}
public void testOnCharOverride() throws Exception {
com.google.common.base.JoinerTest testCase = new com.google.common.base.JoinerTest();
testCase.testOnCharOverride();
}
public void testSkipNulls() throws Exception {
com.google.common.base.JoinerTest testCase = new com.google.common.base.JoinerTest();
testCase.testSkipNulls();
}
public void testUseForNull() throws Exception {
com.google.common.base.JoinerTest testCase = new com.google.common.base.JoinerTest();
testCase.testUseForNull();
}
public void test_skipNulls_onMap() throws Exception {
com.google.common.base.JoinerTest testCase = new com.google.common.base.JoinerTest();
testCase.test_skipNulls_onMap();
}
public void test_skipNulls_useForNull() throws Exception {
com.google.common.base.JoinerTest testCase = new com.google.common.base.JoinerTest();
testCase.test_skipNulls_useForNull();
}
public void test_useForNull_skipNulls() throws Exception {
com.google.common.base.JoinerTest testCase = new com.google.common.base.JoinerTest();
testCase.test_useForNull_skipNulls();
}
public void test_useForNull_twice() throws Exception {
com.google.common.base.JoinerTest testCase = new com.google.common.base.JoinerTest();
testCase.test_useForNull_twice();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/base/JoinerTest_gwt.java | Java | asf20 | 2,560 |
/*
* Copyright (C) 2008 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;
public class ForMapMultimapAsMapImplementsMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testClear() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testClear();
}
public void testContainsKey() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testContainsKey();
}
public void testContainsValue() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testContainsValue();
}
public void testEntrySet() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testEqualsForSmallerMap();
}
public void testGet() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testGet();
}
public void testGetForEmptyMap() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testGetForEmptyMap();
}
public void testGetNull() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testGetNull();
}
public void testHashCode() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testKeySetClear();
}
public void testKeySetRemove() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testPutAllNewKey();
}
public void testPutExistingKey() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testPutExistingKey();
}
public void testPutNewKey() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testPutNewKey();
}
public void testPutNullKey() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testPutNullKey();
}
public void testPutNullValue() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testPutNullValueForExistingKey();
}
public void testRemove() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testRemove();
}
public void testRemoveMissingKey() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testRemoveMissingKey();
}
public void testSize() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testSize();
}
public void testValues() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testValues();
}
public void testValuesClear() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testValuesClear();
}
public void testValuesIteratorRemove() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testValuesRemove();
}
public void testValuesRemoveAll() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ForMapMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ForMapMultimapAsMapImplementsMapTest();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ForMapMultimapAsMapImplementsMapTest_gwt.java | Java | asf20 | 14,340 |
/*
* Copyright (C) 2008 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;
public class SetsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testCartesianProductTooBig() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProductTooBig();
}
public void testCartesianProduct_2x2x2() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_2x2x2();
}
public void testCartesianProduct_binary0x0() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_binary0x0();
}
public void testCartesianProduct_binary0x1() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_binary0x1();
}
public void testCartesianProduct_binary1x0() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_binary1x0();
}
public void testCartesianProduct_binary1x1() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_binary1x1();
}
public void testCartesianProduct_binary1x2() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_binary1x2();
}
public void testCartesianProduct_binary2x2() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_binary2x2();
}
public void testCartesianProduct_contains() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_contains();
}
public void testCartesianProduct_hashCode() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_hashCode();
}
public void testCartesianProduct_unary() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_unary();
}
public void testCartesianProduct_unrelatedTypes() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_unrelatedTypes();
}
public void testCartesianProduct_zeroary() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testCartesianProduct_zeroary();
}
public void testComplementOfEmptyEnumSetWithoutType() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testComplementOfEmptyEnumSetWithoutType();
}
public void testComplementOfEmptySet() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testComplementOfEmptySet();
}
public void testComplementOfEmptySetWithoutTypeDoesntWork() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testComplementOfEmptySetWithoutTypeDoesntWork();
}
public void testComplementOfEnumSet() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testComplementOfEnumSet();
}
public void testComplementOfEnumSetWithType() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testComplementOfEnumSetWithType();
}
public void testComplementOfFullSet() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testComplementOfFullSet();
}
public void testComplementOfRegularSet() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testComplementOfRegularSet();
}
public void testComplementOfRegularSetWithType() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testComplementOfRegularSetWithType();
}
public void testImmutableEnumSet() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testImmutableEnumSet();
}
public void testImmutableEnumSet_fromIterable() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testImmutableEnumSet_fromIterable();
}
public void testNewConcurrentHashSetEmpty() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewConcurrentHashSetEmpty();
}
public void testNewConcurrentHashSetFromCollection() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewConcurrentHashSetFromCollection();
}
public void testNewEnumSet_collection() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewEnumSet_collection();
}
public void testNewEnumSet_empty() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewEnumSet_empty();
}
public void testNewEnumSet_enumSet() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewEnumSet_enumSet();
}
public void testNewEnumSet_iterable() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewEnumSet_iterable();
}
public void testNewHashSetEmpty() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewHashSetEmpty();
}
public void testNewHashSetFromCollection() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewHashSetFromCollection();
}
public void testNewHashSetFromIterable() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewHashSetFromIterable();
}
public void testNewHashSetFromIterator() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewHashSetFromIterator();
}
public void testNewHashSetVarArgs() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewHashSetVarArgs();
}
public void testNewHashSetWithExpectedSizeLarge() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewHashSetWithExpectedSizeLarge();
}
public void testNewHashSetWithExpectedSizeSmall() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewHashSetWithExpectedSizeSmall();
}
public void testNewIdentityHashSet() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewIdentityHashSet();
}
public void testNewLinkedHashSetEmpty() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewLinkedHashSetEmpty();
}
public void testNewLinkedHashSetFromCollection() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewLinkedHashSetFromCollection();
}
public void testNewLinkedHashSetFromIterable() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewLinkedHashSetFromIterable();
}
public void testNewLinkedHashSetWithExpectedSizeLarge() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewLinkedHashSetWithExpectedSizeLarge();
}
public void testNewLinkedHashSetWithExpectedSizeSmall() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewLinkedHashSetWithExpectedSizeSmall();
}
public void testNewSetFromMap() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewSetFromMap();
}
public void testNewSetFromMapIllegal() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewSetFromMapIllegal();
}
public void testNewTreeSetEmpty() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewTreeSetEmpty();
}
public void testNewTreeSetEmptyDerived() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewTreeSetEmptyDerived();
}
public void testNewTreeSetEmptyNonGeneric() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewTreeSetEmptyNonGeneric();
}
public void testNewTreeSetEmptyWithComparator() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewTreeSetEmptyWithComparator();
}
public void testNewTreeSetFromCollection() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewTreeSetFromCollection();
}
public void testNewTreeSetFromIterable() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewTreeSetFromIterable();
}
public void testNewTreeSetFromIterableDerived() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewTreeSetFromIterableDerived();
}
public void testNewTreeSetFromIterableNonGeneric() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testNewTreeSetFromIterableNonGeneric();
}
public void testPowerSetContents() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testPowerSetContents();
}
public void testPowerSetCreationErrors() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testPowerSetCreationErrors();
}
public void testPowerSetEmpty() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testPowerSetEmpty();
}
public void testPowerSetEqualsAndHashCode_verifyAgainstHashSet() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testPowerSetEqualsAndHashCode_verifyAgainstHashSet();
}
public void testPowerSetHashCode_inputHashCodeTimesTooFarValueIsZero() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testPowerSetHashCode_inputHashCodeTimesTooFarValueIsZero();
}
public void testPowerSetIteration_iteratorTester_fast() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testPowerSetIteration_iteratorTester_fast();
}
public void testPowerSetIteration_manual() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testPowerSetIteration_manual();
}
public void testPowerSetShowOff() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testPowerSetShowOff();
}
public void testPowerSetSize() throws Exception {
com.google.common.collect.SetsTest testCase = new com.google.common.collect.SetsTest();
testCase.testPowerSetSize();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/SetsTest_gwt.java | Java | asf20 | 12,995 |
/*
* Copyright (C) 2008 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;
public class TablesTransformValuesTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testClear() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testClear();
}
public void testColumn() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testColumn();
}
public void testColumnNull() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testColumnNull();
}
public void testColumnSetPartialOverlap() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testColumnSetPartialOverlap();
}
public void testContains() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testContains();
}
public void testContainsColumn() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testContainsColumn();
}
public void testContainsRow() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testContainsRow();
}
public void testContainsValue() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testContainsValue();
}
public void testEquals() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testEquals();
}
public void testGet() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testGet();
}
public void testHashCode() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testHashCode();
}
public void testIsEmpty() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testIsEmpty();
}
public void testPut() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testPut();
}
public void testPutAllTable() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testPutAllTable();
}
public void testPutNull() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testPutNull();
}
public void testPutNullReplace() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testPutNullReplace();
}
public void testRemove() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testRemove();
}
public void testRow() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testRow();
}
public void testRowClearAndPut() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testRowClearAndPut();
}
public void testRowNull() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testRowNull();
}
public void testSize() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testSize();
}
public void testToStringSize1() throws Exception {
com.google.common.collect.TablesTransformValuesTest testCase = new com.google.common.collect.TablesTransformValuesTest();
testCase.setUp();
testCase.testToStringSize1();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/TablesTransformValuesTest_gwt.java | Java | asf20 | 5,703 |
/*
* Copyright (C) 2008 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;
public class ImmutableSetMultimapAsMapImplementsMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testClear() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testClear();
}
public void testContainsKey() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testContainsKey();
}
public void testContainsValue() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testContainsValue();
}
public void testEntrySet() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testEqualsForSmallerMap();
}
public void testGet() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testGet();
}
public void testGetForEmptyMap() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testGetForEmptyMap();
}
public void testGetNull() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testGetNull();
}
public void testHashCode() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testKeySetClear();
}
public void testKeySetRemove() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testPutAllNewKey();
}
public void testPutExistingKey() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testPutExistingKey();
}
public void testPutNewKey() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testPutNewKey();
}
public void testPutNullKey() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testPutNullKey();
}
public void testPutNullValue() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testPutNullValueForExistingKey();
}
public void testRemove() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testRemove();
}
public void testRemoveMissingKey() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testRemoveMissingKey();
}
public void testSize() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testSize();
}
public void testValues() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testValues();
}
public void testValuesClear() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testValuesClear();
}
public void testValuesIteratorRemove() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testValuesRemove();
}
public void testValuesRemoveAll() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableSetMultimapAsMapImplementsMapTest();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ImmutableSetMultimapAsMapImplementsMapTest_gwt.java | Java | asf20 | 15,018 |
/*
* Copyright (C) 2008 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;
public class TreeBasedTableTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testCellSetToString_ordered() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testCellSetToString_ordered();
}
public void testClear() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testClear();
}
public void testColumn() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testColumn();
}
public void testColumnComparator() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testColumnComparator();
}
public void testColumnKeySet_empty() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testColumnKeySet_empty();
}
public void testColumnKeySet_isSorted() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testColumnKeySet_isSorted();
}
public void testColumnKeySet_isSortedWithRealComparator() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testColumnKeySet_isSortedWithRealComparator();
}
public void testColumnKeySet_oneColumn() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testColumnKeySet_oneColumn();
}
public void testColumnKeySet_oneEntry() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testColumnKeySet_oneEntry();
}
public void testColumnKeySet_oneRow() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testColumnKeySet_oneRow();
}
public void testColumnNull() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testColumnNull();
}
public void testColumnSetPartialOverlap() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testColumnSetPartialOverlap();
}
public void testContains() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testContains();
}
public void testContainsColumn() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testContainsColumn();
}
public void testContainsRow() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testContainsRow();
}
public void testContainsValue() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testContainsValue();
}
public void testCreateCopy() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testCreateCopy();
}
public void testCreateExplicitComparators() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testCreateExplicitComparators();
}
public void testEquals() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testEquals();
}
public void testGet() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testGet();
}
public void testHashCode() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testHashCode();
}
public void testIsEmpty() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testIsEmpty();
}
public void testPut() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testPut();
}
public void testPutAllTable() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testPutAllTable();
}
public void testPutNull() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testPutNull();
}
public void testPutNullReplace() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testPutNullReplace();
}
public void testRemove() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRemove();
}
public void testRow() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRow();
}
public void testRowClearAndPut() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowClearAndPut();
}
public void testRowComparator() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowComparator();
}
public void testRowEntrySetContains() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowEntrySetContains();
}
public void testRowEntrySetRemove() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowEntrySetRemove();
}
public void testRowKeyMapHeadMap() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowKeyMapHeadMap();
}
public void testRowKeyMapSubMap() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowKeyMapSubMap();
}
public void testRowKeyMapTailMap() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowKeyMapTailMap();
}
public void testRowKeySetComparator() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowKeySetComparator();
}
public void testRowKeySetFirst() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowKeySetFirst();
}
public void testRowKeySetHeadSet() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowKeySetHeadSet();
}
public void testRowKeySetLast() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowKeySetLast();
}
public void testRowKeySetSubSet() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowKeySetSubSet();
}
public void testRowKeySetTailSet() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowKeySetTailSet();
}
public void testRowKeySetToString_ordered() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowKeySetToString_ordered();
}
public void testRowMapComparator() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowMapComparator();
}
public void testRowMapFirstKey() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowMapFirstKey();
}
public void testRowMapLastKey() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowMapLastKey();
}
public void testRowMapValuesAreSorted() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowMapValuesAreSorted();
}
public void testRowNull() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowNull();
}
public void testRowSize() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testRowSize();
}
public void testSize() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testSize();
}
public void testSubRowClearAndPut() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testSubRowClearAndPut();
}
public void testToStringSize1() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testToStringSize1();
}
public void testToString_ordered() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testToString_ordered();
}
public void testValuesToString_ordered() throws Exception {
com.google.common.collect.TreeBasedTableTest testCase = new com.google.common.collect.TreeBasedTableTest();
testCase.setUp();
testCase.testValuesToString_ordered();
}
public void testClear__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testClear();
}
public void testClearSubMapOfRowMap__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testClearSubMapOfRowMap();
}
public void testContainsKey__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testContainsKey();
}
public void testContainsValue__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testContainsValue();
}
public void testEntrySet__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testEqualsForSmallerMap();
}
public void testGet__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testGet();
}
public void testGetForEmptyMap__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testGetForEmptyMap();
}
public void testGetNull__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testGetNull();
}
public void testHashCode__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testKeySetClear();
}
public void testKeySetRemove__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testPutExistingKey();
}
public void testPutNewKey__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testPutNewKey();
}
public void testPutNullKey__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testPutNullKey();
}
public void testPutNullValue__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testRemove();
}
public void testRemoveMissingKey__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testRemoveMissingKey();
}
public void testSize__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testSize();
}
public void testTailMapClearThrough__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testTailMapClearThrough();
}
public void testTailMapRemoveThrough__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testTailMapRemoveThrough();
}
public void testTailMapWriteThrough__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testTailMapWriteThrough();
}
public void testValues__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testValues();
}
public void testValuesClear__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TreeRowTest() throws Exception {
com.google.common.collect.TreeBasedTableTest.TreeRowTest testCase = new com.google.common.collect.TreeBasedTableTest.TreeRowTest();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/TreeBasedTableTest_gwt.java | Java | asf20 | 26,930 |
/*
* Copyright (C) 2008 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;
public class ListsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testArraysAsList() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testArraysAsList();
}
public void testAsList1Small() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testAsList1Small();
}
public void testAsList2() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testAsList2();
}
public void testCartesianProductTooBig() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testCartesianProductTooBig();
}
public void testCartesianProduct_2x2x2() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testCartesianProduct_2x2x2();
}
public void testCartesianProduct_binary1x1() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testCartesianProduct_binary1x1();
}
public void testCartesianProduct_binary1x2() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testCartesianProduct_binary1x2();
}
public void testCartesianProduct_binary2x2() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testCartesianProduct_binary2x2();
}
public void testCartesianProduct_contains() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testCartesianProduct_contains();
}
public void testCartesianProduct_unrelatedTypes() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testCartesianProduct_unrelatedTypes();
}
public void testCharactersOfIsView() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testCharactersOfIsView();
}
public void testComputeArrayListCapacity() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testComputeArrayListCapacity();
}
public void testNewArrayListEmpty() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewArrayListEmpty();
}
public void testNewArrayListFromCollection() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewArrayListFromCollection();
}
public void testNewArrayListFromIterable() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewArrayListFromIterable();
}
public void testNewArrayListFromIterator() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewArrayListFromIterator();
}
public void testNewArrayListVarArgs() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewArrayListVarArgs();
}
public void testNewArrayListWithCapacity() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewArrayListWithCapacity();
}
public void testNewArrayListWithCapacity_negative() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewArrayListWithCapacity_negative();
}
public void testNewArrayListWithExpectedSize() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewArrayListWithExpectedSize();
}
public void testNewArrayListWithExpectedSize_negative() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewArrayListWithExpectedSize_negative();
}
public void testNewLinkedListEmpty() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewLinkedListEmpty();
}
public void testNewLinkedListFromCollection() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewLinkedListFromCollection();
}
public void testNewLinkedListFromIterable() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testNewLinkedListFromIterable();
}
public void testPartitionRandomAccessFalse() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testPartitionRandomAccessFalse();
}
public void testPartitionSize_1() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testPartitionSize_1();
}
public void testPartition_1_1() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testPartition_1_1();
}
public void testPartition_1_2() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testPartition_1_2();
}
public void testPartition_2_1() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testPartition_2_1();
}
public void testPartition_3_2() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testPartition_3_2();
}
public void testPartition_badSize() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testPartition_badSize();
}
public void testPartition_empty() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testPartition_empty();
}
public void testPartition_view() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testPartition_view();
}
public void testReverseViewRandomAccess() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testReverseViewRandomAccess();
}
public void testReverseViewSequential() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testReverseViewSequential();
}
public void testTransformHashCodeRandomAccess() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformHashCodeRandomAccess();
}
public void testTransformHashCodeSequential() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformHashCodeSequential();
}
public void testTransformIteratorRandomAccess() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformIteratorRandomAccess();
}
public void testTransformIteratorSequential() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformIteratorSequential();
}
public void testTransformListIteratorRandomAccess() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformListIteratorRandomAccess();
}
public void testTransformListIteratorSequential() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformListIteratorSequential();
}
public void testTransformModifiableRandomAccess() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformModifiableRandomAccess();
}
public void testTransformModifiableSequential() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformModifiableSequential();
}
public void testTransformPreservesIOOBEsThrownByFunction() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformPreservesIOOBEsThrownByFunction();
}
public void testTransformRandomAccess() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformRandomAccess();
}
public void testTransformSequential() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformSequential();
}
public void testTransformViewRandomAccess() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformViewRandomAccess();
}
public void testTransformViewSequential() throws Exception {
com.google.common.collect.ListsTest testCase = new com.google.common.collect.ListsTest();
testCase.testTransformViewSequential();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ListsTest_gwt.java | Java | asf20 | 10,303 |
/*
* Copyright (C) 2008 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;
public class OrderingTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testAllEqual() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testAllEqual();
}
public void testArbitrary_withCollisions() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testArbitrary_withCollisions();
}
public void testArbitrary_withoutCollisions() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testArbitrary_withoutCollisions();
}
public void testBinarySearch() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testBinarySearch();
}
public void testCombinationsExhaustively_startingFromNatural() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testCombinationsExhaustively_startingFromNatural();
}
public void testCompound_instance() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testCompound_instance();
}
public void testCompound_instance_generics() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testCompound_instance_generics();
}
public void testCompound_static() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testCompound_static();
}
public void testExplicit_none() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testExplicit_none();
}
public void testExplicit_one() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testExplicit_one();
}
public void testExplicit_sortingExample() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testExplicit_sortingExample();
}
public void testExplicit_two() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testExplicit_two();
}
public void testExplicit_withDuplicates() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testExplicit_withDuplicates();
}
public void testFrom() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testFrom();
}
public void testGreatestOfIterable_simple() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testGreatestOfIterable_simple();
}
public void testGreatestOfIterator_simple() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testGreatestOfIterator_simple();
}
public void testImmutableSortedCopy() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testImmutableSortedCopy();
}
public void testIsOrdered() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testIsOrdered();
}
public void testIsStrictlyOrdered() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testIsStrictlyOrdered();
}
public void testIterableMinAndMax() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testIterableMinAndMax();
}
public void testIteratorMaxExhaustsIterator() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testIteratorMaxExhaustsIterator();
}
public void testIteratorMinAndMax() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testIteratorMinAndMax();
}
public void testIteratorMinExhaustsIterator() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testIteratorMinExhaustsIterator();
}
public void testLeastOfIterableLargeK() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterableLargeK();
}
public void testLeastOfIterable_empty_0() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_empty_0();
}
public void testLeastOfIterable_empty_1() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_empty_1();
}
public void testLeastOfIterable_simple_0() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_simple_0();
}
public void testLeastOfIterable_simple_1() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_simple_1();
}
public void testLeastOfIterable_simple_n() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_simple_n();
}
public void testLeastOfIterable_simple_nMinusOne() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_simple_nMinusOne();
}
public void testLeastOfIterable_simple_nMinusOne_withNullElement() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_simple_nMinusOne_withNullElement();
}
public void testLeastOfIterable_simple_nPlusOne() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_simple_nPlusOne();
}
public void testLeastOfIterable_simple_n_withNullElement() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_simple_n_withNullElement();
}
public void testLeastOfIterable_simple_negativeOne() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_simple_negativeOne();
}
public void testLeastOfIterable_singleton_0() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_singleton_0();
}
public void testLeastOfIterable_ties() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterable_ties();
}
public void testLeastOfIteratorLargeK() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIteratorLargeK();
}
public void testLeastOfIterator_empty_0() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_empty_0();
}
public void testLeastOfIterator_empty_1() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_empty_1();
}
public void testLeastOfIterator_simple_0() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_simple_0();
}
public void testLeastOfIterator_simple_1() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_simple_1();
}
public void testLeastOfIterator_simple_n() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_simple_n();
}
public void testLeastOfIterator_simple_nMinusOne() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_simple_nMinusOne();
}
public void testLeastOfIterator_simple_nMinusOne_withNullElement() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_simple_nMinusOne_withNullElement();
}
public void testLeastOfIterator_simple_nPlusOne() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_simple_nPlusOne();
}
public void testLeastOfIterator_simple_n_withNullElement() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_simple_n_withNullElement();
}
public void testLeastOfIterator_simple_negativeOne() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_simple_negativeOne();
}
public void testLeastOfIterator_singleton_0() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_singleton_0();
}
public void testLeastOfIterator_ties() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOfIterator_ties();
}
public void testLeastOf_reconcileAgainstSortAndSublistSmall() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLeastOf_reconcileAgainstSortAndSublistSmall();
}
public void testLexicographical() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testLexicographical();
}
public void testNatural() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testNatural();
}
public void testNullsFirst() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testNullsFirst();
}
public void testNullsLast() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testNullsLast();
}
public void testOnResultOf_chained() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testOnResultOf_chained();
}
public void testOnResultOf_natural() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testOnResultOf_natural();
}
public void testParameterMinAndMax() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testParameterMinAndMax();
}
public void testReverse() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testReverse();
}
public void testReverseOfReverseSameAsForward() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testReverseOfReverseSameAsForward();
}
public void testSortedCopy() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testSortedCopy();
}
public void testUsingToString() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testUsingToString();
}
public void testVarargsMinAndMax() throws Exception {
com.google.common.collect.OrderingTest testCase = new com.google.common.collect.OrderingTest();
testCase.testVarargsMinAndMax();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/OrderingTest_gwt.java | Java | asf20 | 13,402 |
/*
* Copyright (C) 2008 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;
public class ArrayListMultimapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testCreate() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testCreate();
}
public void testCreateFromArrayListMultimap() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testCreateFromArrayListMultimap();
}
public void testCreateFromHashMultimap() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testCreateFromHashMultimap();
}
public void testCreateFromIllegalSizes() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testCreateFromIllegalSizes();
}
public void testCreateFromMultimap() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testCreateFromMultimap();
}
public void testCreateFromSizes() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testCreateFromSizes();
}
public void testGetRandomAccess() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testGetRandomAccess();
}
public void testRemoveAllRandomAccess() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testRemoveAllRandomAccess();
}
public void testReplaceValuesRandomAccess() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testReplaceValuesRandomAccess();
}
public void testSublistConcurrentModificationException() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testSublistConcurrentModificationException();
}
public void testTrimToSize() throws Exception {
com.google.common.collect.ArrayListMultimapTest testCase = new com.google.common.collect.ArrayListMultimapTest();
testCase.testTrimToSize();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ArrayListMultimapTest_gwt.java | Java | asf20 | 3,193 |
/*
* Copyright (C) 2008 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;
public class ImmutableBiMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testDoubleInverse__BiMapSpecificTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.BiMapSpecificTests testCase = new com.google.common.collect.ImmutableBiMapTest.BiMapSpecificTests();
testCase.testDoubleInverse();
}
public void testForcePut__BiMapSpecificTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.BiMapSpecificTests testCase = new com.google.common.collect.ImmutableBiMapTest.BiMapSpecificTests();
testCase.testForcePut();
}
public void testKeySet__BiMapSpecificTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.BiMapSpecificTests testCase = new com.google.common.collect.ImmutableBiMapTest.BiMapSpecificTests();
testCase.testKeySet();
}
public void testValues__BiMapSpecificTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.BiMapSpecificTests testCase = new com.google.common.collect.ImmutableBiMapTest.BiMapSpecificTests();
testCase.testValues();
}
public void testBuilder__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testBuilder();
}
public void testBuilderPutAll__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testBuilderPutAll();
}
public void testBuilderPutAllWithEmptyMap__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testBuilderPutAllWithEmptyMap();
}
public void testBuilderPutNullKey__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testBuilderPutNullKey();
}
public void testBuilderPutNullKeyViaPutAll__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testBuilderPutNullKeyViaPutAll();
}
public void testBuilderPutNullValue__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testBuilderPutNullValue();
}
public void testBuilderPutNullValueViaPutAll__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testBuilderPutNullValueViaPutAll();
}
public void testBuilderReuse__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testBuilderReuse();
}
public void testCopyOf__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testCopyOf();
}
public void testCopyOfEmptyMap__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testCopyOfEmptyMap();
}
public void testCopyOfSingletonMap__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testCopyOfSingletonMap();
}
public void testDuplicateValues__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testDuplicateValues();
}
public void testEmpty__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testEmpty();
}
public void testEmptyBuilder__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testEmptyBuilder();
}
public void testFromHashMap__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testFromHashMap();
}
public void testFromImmutableMap__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testFromImmutableMap();
}
public void testOf__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testOf();
}
public void testOfNullKey__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testOfNullKey();
}
public void testOfNullValue__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testOfNullValue();
}
public void testOfWithDuplicateKey__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testOfWithDuplicateKey();
}
public void testPuttingTheSameKeyTwiceThrowsOnBuild__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testPuttingTheSameKeyTwiceThrowsOnBuild();
}
public void testSingletonBuilder__CreationTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.CreationTests testCase = new com.google.common.collect.ImmutableBiMapTest.CreationTests();
testCase.testSingletonBuilder();
}
public void testClear__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testClear();
}
public void testContainsKey__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testContainsKey();
}
public void testContainsValue__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testContainsValue();
}
public void testEntrySet__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testGetNull();
}
public void testHashCode__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testSize();
}
public void testValues__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testValues();
}
public void testValuesClear__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__InverseMapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.InverseMapTests testCase = new com.google.common.collect.ImmutableBiMapTest.InverseMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testClear();
}
public void testContainsKey__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testContainsKey();
}
public void testContainsValue__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testContainsValue();
}
public void testEntrySet__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testGet();
}
public void testGetForEmptyMap__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testGetNull();
}
public void testHashCode__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testRemoveMissingKey();
}
public void testSize__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testSize();
}
public void testValues__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testValues();
}
public void testValuesClear__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableBiMapTest.MapTests testCase = new com.google.common.collect.ImmutableBiMapTest.MapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ImmutableBiMapTest_gwt.java | Java | asf20 | 34,442 |
/*
* Copyright (C) 2008 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;
public class UnmodifiableMultimapAsMapImplementsMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testClear() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testClear();
}
public void testContainsKey() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testContainsKey();
}
public void testContainsValue() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testContainsValue();
}
public void testEntrySet() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testEqualsForSmallerMap();
}
public void testGet() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testGet();
}
public void testGetForEmptyMap() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testGetForEmptyMap();
}
public void testGetNull() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testGetNull();
}
public void testHashCode() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testKeySetClear();
}
public void testKeySetRemove() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testPutAllNewKey();
}
public void testPutExistingKey() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testPutExistingKey();
}
public void testPutNewKey() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testPutNewKey();
}
public void testPutNullKey() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testPutNullKey();
}
public void testPutNullValue() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testPutNullValueForExistingKey();
}
public void testRemove() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testRemove();
}
public void testRemoveMissingKey() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testRemoveMissingKey();
}
public void testSize() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testSize();
}
public void testValues() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testValues();
}
public void testValuesClear() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testValuesClear();
}
public void testValuesIteratorRemove() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testValuesRemove();
}
public void testValuesRemoveAll() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.UnmodifiableMultimapAsMapImplementsMapTest();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/UnmodifiableMultimapAsMapImplementsMapTest_gwt.java | Java | asf20 | 15,018 |
/*
* Copyright (C) 2008 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;
public class ImmutableSetTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testBuilderAddAll() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testBuilderAddAll();
}
public void testBuilderAddAllHandlesNullsCorrectly() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testBuilderAddAllHandlesNullsCorrectly();
}
public void testBuilderAddHandlesNullsCorrectly() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testBuilderAddHandlesNullsCorrectly();
}
public void testBuilderWithDuplicateElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testBuilderWithDuplicateElements();
}
public void testBuilderWithNonDuplicateElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testBuilderWithNonDuplicateElements();
}
public void testComplexBuilder() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testComplexBuilder();
}
public void testContainsAll_sameType() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testContainsAll_sameType();
}
public void testCopyOf_arrayContainingOnlyNull() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_arrayContainingOnlyNull();
}
public void testCopyOf_arrayOfOneElement() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_arrayOfOneElement();
}
public void testCopyOf_collectionContainingNull() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_collectionContainingNull();
}
public void testCopyOf_collection_empty() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_collection_empty();
}
public void testCopyOf_collection_general() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_collection_general();
}
public void testCopyOf_collection_oneElement() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_collection_oneElement();
}
public void testCopyOf_collection_oneElementRepeated() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_collection_oneElementRepeated();
}
public void testCopyOf_copiesImmutableSortedSet() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_copiesImmutableSortedSet();
}
public void testCopyOf_emptyArray() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_emptyArray();
}
public void testCopyOf_iteratorContainingNull() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_iteratorContainingNull();
}
public void testCopyOf_iterator_empty() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_iterator_empty();
}
public void testCopyOf_iterator_general() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_iterator_general();
}
public void testCopyOf_iterator_oneElement() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_iterator_oneElement();
}
public void testCopyOf_iterator_oneElementRepeated() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_iterator_oneElementRepeated();
}
public void testCopyOf_nullArray() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_nullArray();
}
public void testCopyOf_plainIterable() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_plainIterable();
}
public void testCopyOf_plainIterable_iteratesOnce() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_plainIterable_iteratesOnce();
}
public void testCopyOf_shortcut_empty() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_shortcut_empty();
}
public void testCopyOf_shortcut_sameType() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_shortcut_sameType();
}
public void testCopyOf_shortcut_singleton() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCopyOf_shortcut_singleton();
}
public void testCreation_allDuplicates() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_allDuplicates();
}
public void testCreation_arrayOfArray() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_arrayOfArray();
}
public void testCreation_eightElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_eightElements();
}
public void testCreation_fiveElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_fiveElements();
}
public void testCreation_fourElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_fourElements();
}
public void testCreation_manyDuplicates() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_manyDuplicates();
}
public void testCreation_noArgs() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_noArgs();
}
public void testCreation_oneDuplicate() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_oneDuplicate();
}
public void testCreation_oneElement() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_oneElement();
}
public void testCreation_sevenElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_sevenElements();
}
public void testCreation_sixElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_sixElements();
}
public void testCreation_threeElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_threeElements();
}
public void testCreation_twoElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testCreation_twoElements();
}
public void testEquals() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testEquals();
}
public void testEquals_sameType() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testEquals_sameType();
}
public void testReuseBuilderWithDuplicateElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testReuseBuilderWithDuplicateElements();
}
public void testReuseBuilderWithNonDuplicateElements() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testReuseBuilderWithNonDuplicateElements();
}
public void testToString() throws Exception {
com.google.common.collect.ImmutableSetTest testCase = new com.google.common.collect.ImmutableSetTest();
testCase.testToString();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ImmutableSetTest_gwt.java | Java | asf20 | 10,394 |
/*
* Copyright (C) 2008 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;
public class MapsTransformValuesTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testClear() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testClear();
}
public void testContainsKey() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testContainsKey();
}
public void testContainsValue() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testContainsValue();
}
public void testEntrySet() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testEqualsForSmallerMap();
}
public void testGet() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testGet();
}
public void testGetForEmptyMap() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testGetForEmptyMap();
}
public void testGetNull() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testGetNull();
}
public void testHashCode() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testKeySetClear();
}
public void testKeySetRemove() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testPutAllNewKey();
}
public void testPutExistingKey() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testPutExistingKey();
}
public void testPutNewKey() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testPutNewKey();
}
public void testPutNullKey() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testPutNullKey();
}
public void testPutNullValue() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testPutNullValueForExistingKey();
}
public void testRemove() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testRemove();
}
public void testRemoveMissingKey() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testRemoveMissingKey();
}
public void testSize() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testSize();
}
public void testTransformChangesAreReflectedInUnderlyingMap() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testTransformChangesAreReflectedInUnderlyingMap();
}
public void testTransformEmptyMapEquality() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testTransformEmptyMapEquality();
}
public void testTransformEntrySetContains() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testTransformEntrySetContains();
}
public void testTransformEqualityOfMapsWithNullValues() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testTransformEqualityOfMapsWithNullValues();
}
public void testTransformEquals() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testTransformEquals();
}
public void testTransformIdentityFunctionEquality() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testTransformIdentityFunctionEquality();
}
public void testTransformPutEntryIsUnsupported() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testTransformPutEntryIsUnsupported();
}
public void testTransformReflectsUnderlyingMap() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testTransformReflectsUnderlyingMap();
}
public void testTransformRemoveEntry() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testTransformRemoveEntry();
}
public void testTransformSingletonMapEquality() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testTransformSingletonMapEquality();
}
public void testValues() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testValues();
}
public void testValuesClear() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testValuesClear();
}
public void testValuesIteratorRemove() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testValuesRemove();
}
public void testValuesRemoveAll() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsTransformValuesTest testCase = new com.google.common.collect.MapsTransformValuesTest();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/MapsTransformValuesTest_gwt.java | Java | asf20 | 15,245 |
/*
* Copyright (C) 2008 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;
public class MultimapsTransformValuesAsMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testClear() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testClear();
}
public void testContainsKey() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testContainsKey();
}
public void testContainsValue() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testContainsValue();
}
public void testEntrySet() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testEqualsForSmallerMap();
}
public void testGet() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testGet();
}
public void testGetForEmptyMap() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testGetForEmptyMap();
}
public void testGetNull() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testGetNull();
}
public void testHashCode() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testKeySetClear();
}
public void testKeySetRemove() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testPutAllNewKey();
}
public void testPutExistingKey() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testPutExistingKey();
}
public void testPutNewKey() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testPutNewKey();
}
public void testPutNullKey() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testPutNullKey();
}
public void testPutNullValue() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testPutNullValueForExistingKey();
}
public void testRemove() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testRemove();
}
public void testRemoveMissingKey() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testRemoveMissingKey();
}
public void testSize() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testSize();
}
public void testValues() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testValues();
}
public void testValuesClear() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testValuesClear();
}
public void testValuesIteratorRemove() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testValuesRemove();
}
public void testValuesRemoveAll() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.MultimapsTransformValuesAsMapTest testCase = new com.google.common.collect.MultimapsTransformValuesAsMapTest();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/MultimapsTransformValuesAsMapTest_gwt.java | Java | asf20 | 14,001 |
/*
* Copyright (C) 2008 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;
public class MapMakerTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testComputerThatReturnsNull__ComputingTest() throws Exception {
com.google.common.collect.MapMakerTest.ComputingTest testCase = new com.google.common.collect.MapMakerTest.ComputingTest();
testCase.testComputerThatReturnsNull();
}
public void testRuntimeException__ComputingTest() throws Exception {
com.google.common.collect.MapMakerTest.ComputingTest testCase = new com.google.common.collect.MapMakerTest.ComputingTest();
testCase.testRuntimeException();
}
public void testRecursiveComputation__RecursiveComputationTest() throws Exception {
com.google.common.collect.MapMakerTest.RecursiveComputationTest testCase = new com.google.common.collect.MapMakerTest.RecursiveComputationTest();
testCase.testRecursiveComputation();
}
public void testPut_sizeIsZero__MaximumSizeTest() throws Exception {
com.google.common.collect.MapMakerTest.MaximumSizeTest testCase = new com.google.common.collect.MapMakerTest.MaximumSizeTest();
testCase.testPut_sizeIsZero();
}
public void testSizeBasedEviction__MaximumSizeTest() throws Exception {
com.google.common.collect.MapMakerTest.MaximumSizeTest testCase = new com.google.common.collect.MapMakerTest.MaximumSizeTest();
testCase.testSizeBasedEviction();
}
public void testExpiration_setTwice__MakerTest() throws Exception {
com.google.common.collect.MapMakerTest.MakerTest testCase = new com.google.common.collect.MapMakerTest.MakerTest();
testCase.testExpiration_setTwice();
}
public void testInitialCapacity_negative__MakerTest() throws Exception {
com.google.common.collect.MapMakerTest.MakerTest testCase = new com.google.common.collect.MapMakerTest.MakerTest();
testCase.testInitialCapacity_negative();
}
public void testMaximumSize_setTwice__MakerTest() throws Exception {
com.google.common.collect.MapMakerTest.MakerTest testCase = new com.google.common.collect.MapMakerTest.MakerTest();
testCase.testMaximumSize_setTwice();
}
public void testReturnsPlainConcurrentHashMapWhenPossible__MakerTest() throws Exception {
com.google.common.collect.MapMakerTest.MakerTest testCase = new com.google.common.collect.MapMakerTest.MakerTest();
testCase.testReturnsPlainConcurrentHashMapWhenPossible();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/MapMakerTest_gwt.java | Java | asf20 | 3,004 |
/*
* Copyright (C) 2008 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;
public class ImmutableSortedSetTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testAsList() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testAsList();
}
public void testAsListInconsistentComprator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testAsListInconsistentComprator();
}
public void testBuilderAddAll() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testBuilderAddAll();
}
public void testBuilderAddAllHandlesNullsCorrectly() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testBuilderAddAllHandlesNullsCorrectly();
}
public void testBuilderAddHandlesNullsCorrectly() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testBuilderAddHandlesNullsCorrectly();
}
public void testBuilderGenerics_SelfComparable() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testBuilderGenerics_SelfComparable();
}
public void testBuilderGenerics_SuperComparable() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testBuilderGenerics_SuperComparable();
}
public void testBuilderMethod() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testBuilderMethod();
}
public void testBuilderWithDuplicateElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testBuilderWithDuplicateElements();
}
public void testBuilderWithNonDuplicateElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testBuilderWithNonDuplicateElements();
}
public void testComplexBuilder() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testComplexBuilder();
}
public void testContainsAll_differentComparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testContainsAll_differentComparator();
}
public void testContainsAll_notSortedSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testContainsAll_notSortedSet();
}
public void testContainsAll_sameComparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testContainsAll_sameComparator();
}
public void testContainsAll_sameComparator_StringVsInt() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testContainsAll_sameComparator_StringVsInt();
}
public void testContainsAll_sameType() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testContainsAll_sameType();
}
public void testCopyOfExplicit_comparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOfExplicit_comparator();
}
public void testCopyOfExplicit_iterator_comparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOfExplicit_iterator_comparator();
}
public void testCopyOfExplicit_iterator_ordering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOfExplicit_iterator_ordering();
}
public void testCopyOfExplicit_iterator_ordering_dupes() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOfExplicit_iterator_ordering_dupes();
}
public void testCopyOfExplicit_ordering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOfExplicit_ordering();
}
public void testCopyOfExplicit_ordering_dupes() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOfExplicit_ordering_dupes();
}
public void testCopyOfSorted_explicit_ordering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOfSorted_explicit_ordering();
}
public void testCopyOfSorted_natural_comparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOfSorted_natural_comparator();
}
public void testCopyOfSorted_natural_ordering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOfSorted_natural_ordering();
}
public void testCopyOf_arrayContainingOnlyNull() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_arrayContainingOnlyNull();
}
public void testCopyOf_arrayOfOneElement() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_arrayOfOneElement();
}
public void testCopyOf_collectionContainingNull() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_collectionContainingNull();
}
public void testCopyOf_collection_empty() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_collection_empty();
}
public void testCopyOf_collection_general() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_collection_general();
}
public void testCopyOf_collection_oneElement() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_collection_oneElement();
}
public void testCopyOf_collection_oneElementRepeated() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_collection_oneElementRepeated();
}
public void testCopyOf_comparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_comparator();
}
public void testCopyOf_emptyArray() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_emptyArray();
}
public void testCopyOf_headSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_headSet();
}
public void testCopyOf_iteratorContainingNull() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_iteratorContainingNull();
}
public void testCopyOf_iterator_comparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_iterator_comparator();
}
public void testCopyOf_iterator_empty() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_iterator_empty();
}
public void testCopyOf_iterator_general() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_iterator_general();
}
public void testCopyOf_iterator_oneElement() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_iterator_oneElement();
}
public void testCopyOf_iterator_oneElementRepeated() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_iterator_oneElementRepeated();
}
public void testCopyOf_iterator_ordering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_iterator_ordering();
}
public void testCopyOf_iterator_ordering_dupes() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_iterator_ordering_dupes();
}
public void testCopyOf_nullArray() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_nullArray();
}
public void testCopyOf_ordering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_ordering();
}
public void testCopyOf_ordering_dupes() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_ordering_dupes();
}
public void testCopyOf_plainIterable() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_plainIterable();
}
public void testCopyOf_plainIterable_iteratesOnce() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_plainIterable_iteratesOnce();
}
public void testCopyOf_shortcut_empty() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_shortcut_empty();
}
public void testCopyOf_shortcut_sameType() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_shortcut_sameType();
}
public void testCopyOf_shortcut_singleton() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_shortcut_singleton();
}
public void testCopyOf_sortedSetIterable() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_sortedSetIterable();
}
public void testCopyOf_sortedSet_comparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_sortedSet_comparator();
}
public void testCopyOf_sortedSet_ordering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_sortedSet_ordering();
}
public void testCopyOf_subSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_subSet();
}
public void testCopyOf_tailSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCopyOf_tailSet();
}
public void testCreation_eightElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCreation_eightElements();
}
public void testCreation_fiveElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCreation_fiveElements();
}
public void testCreation_fourElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCreation_fourElements();
}
public void testCreation_noArgs() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCreation_noArgs();
}
public void testCreation_oneElement() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCreation_oneElement();
}
public void testCreation_sevenElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCreation_sevenElements();
}
public void testCreation_sixElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCreation_sixElements();
}
public void testCreation_threeElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCreation_threeElements();
}
public void testCreation_twoElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testCreation_twoElements();
}
public void testEmpty_comparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEmpty_comparator();
}
public void testEmpty_first() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEmpty_first();
}
public void testEmpty_headSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEmpty_headSet();
}
public void testEmpty_last() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEmpty_last();
}
public void testEmpty_subSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEmpty_subSet();
}
public void testEmpty_tailSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEmpty_tailSet();
}
public void testEquals_bothDefaultOrdering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEquals_bothDefaultOrdering();
}
public void testEquals_bothDefaultOrdering_StringVsInt() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEquals_bothDefaultOrdering_StringVsInt();
}
public void testEquals_bothExplicitOrdering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEquals_bothExplicitOrdering();
}
public void testEquals_bothExplicitOrdering_StringVsInt() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEquals_bothExplicitOrdering_StringVsInt();
}
public void testEquals_sameType() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testEquals_sameType();
}
public void testExplicit_comparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testExplicit_comparator();
}
public void testExplicit_contains() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testExplicit_contains();
}
public void testExplicit_containsMismatchedTypes() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testExplicit_containsMismatchedTypes();
}
public void testExplicit_first() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testExplicit_first();
}
public void testExplicit_headSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testExplicit_headSet();
}
public void testExplicit_last() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testExplicit_last();
}
public void testExplicit_ordering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testExplicit_ordering();
}
public void testExplicit_ordering_dupes() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testExplicit_ordering_dupes();
}
public void testExplicit_subSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testExplicit_subSet();
}
public void testExplicit_tailSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testExplicit_tailSet();
}
public void testHeadSetExclusive() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testHeadSetExclusive();
}
public void testHeadSetInclusive() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testHeadSetInclusive();
}
public void testLegacyComparable_builder_natural() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testLegacyComparable_builder_natural();
}
public void testLegacyComparable_builder_reverse() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testLegacyComparable_builder_reverse();
}
public void testLegacyComparable_copyOf_collection() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testLegacyComparable_copyOf_collection();
}
public void testLegacyComparable_copyOf_iterator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testLegacyComparable_copyOf_iterator();
}
public void testLegacyComparable_of() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testLegacyComparable_of();
}
public void testOf_comparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testOf_comparator();
}
public void testOf_first() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testOf_first();
}
public void testOf_gwtArraycopyBug() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testOf_gwtArraycopyBug();
}
public void testOf_headSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testOf_headSet();
}
public void testOf_last() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testOf_last();
}
public void testOf_ordering() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testOf_ordering();
}
public void testOf_ordering_dupes() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testOf_ordering_dupes();
}
public void testOf_subSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testOf_subSet();
}
public void testOf_tailSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testOf_tailSet();
}
public void testReuseBuilderWithDuplicateElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testReuseBuilderWithDuplicateElements();
}
public void testReuseBuilderWithNonDuplicateElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testReuseBuilderWithNonDuplicateElements();
}
public void testReverseOrder() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testReverseOrder();
}
public void testSingle_comparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSingle_comparator();
}
public void testSingle_first() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSingle_first();
}
public void testSingle_headSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSingle_headSet();
}
public void testSingle_last() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSingle_last();
}
public void testSingle_subSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSingle_subSet();
}
public void testSingle_tailSet() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSingle_tailSet();
}
public void testSubSetExclusiveExclusive() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSubSetExclusiveExclusive();
}
public void testSubSetExclusiveInclusive() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSubSetExclusiveInclusive();
}
public void testSubSetInclusiveExclusive() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSubSetInclusiveExclusive();
}
public void testSubSetInclusiveInclusive() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSubSetInclusiveInclusive();
}
public void testSubsetAsList() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSubsetAsList();
}
public void testSupertypeComparator() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSupertypeComparator();
}
public void testSupertypeComparatorSubtypeElements() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testSupertypeComparatorSubtypeElements();
}
public void testTailSetExclusive() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testTailSetExclusive();
}
public void testTailSetInclusive() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testTailSetInclusive();
}
public void testToString() throws Exception {
com.google.common.collect.ImmutableSortedSetTest testCase = new com.google.common.collect.ImmutableSortedSetTest();
testCase.testToString();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ImmutableSortedSetTest_gwt.java | Java | asf20 | 27,628 |
/*
* Copyright (C) 2008 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;
public class ImmutableSortedMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testBuilderGenerics_SelfComparable() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testBuilderGenerics_SelfComparable();
}
public void testBuilderGenerics_SuperComparable() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testBuilderGenerics_SuperComparable();
}
public void testHeadMapExclusive() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testHeadMapExclusive();
}
public void testHeadMapInclusive() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testHeadMapInclusive();
}
public void testMutableValues() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testMutableValues();
}
public void testNullGet() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testNullGet();
}
public void testSubMapExclusiveExclusive() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testSubMapExclusiveExclusive();
}
public void testSubMapExclusiveInclusive() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testSubMapExclusiveInclusive();
}
public void testSubMapInclusiveExclusive() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testSubMapInclusiveExclusive();
}
public void testSubMapInclusiveInclusive() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testSubMapInclusiveInclusive();
}
public void testTailMapExclusive() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testTailMapExclusive();
}
public void testTailMapInclusive() throws Exception {
com.google.common.collect.ImmutableSortedMapTest testCase = new com.google.common.collect.ImmutableSortedMapTest();
testCase.testTailMapInclusive();
}
public void testBuilder__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilder();
}
public void testBuilderComparator__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilderComparator();
}
public void testBuilderPutAll__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilderPutAll();
}
public void testBuilderPutAllWithEmptyMap__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilderPutAllWithEmptyMap();
}
public void testBuilderPutNullKey__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilderPutNullKey();
}
public void testBuilderPutNullKeyViaPutAll__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilderPutNullKeyViaPutAll();
}
public void testBuilderPutNullValue__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilderPutNullValue();
}
public void testBuilderPutNullValueViaPutAll__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilderPutNullValueViaPutAll();
}
public void testBuilderReuse__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilderReuse();
}
public void testBuilderReverseOrder__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilderReverseOrder();
}
public void testBuilder_withImmutableEntry__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilder_withImmutableEntry();
}
public void testBuilder_withImmutableEntryAndNullContents__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilder_withImmutableEntryAndNullContents();
}
public void testBuilder_withMutableEntry__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testBuilder_withMutableEntry();
}
public void testCopyOf__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testCopyOf();
}
public void testCopyOfDuplicateKey__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testCopyOfDuplicateKey();
}
public void testCopyOfEmptyMap__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testCopyOfEmptyMap();
}
public void testCopyOfExplicitComparator__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testCopyOfExplicitComparator();
}
public void testCopyOfImmutableSortedSetDifferentComparator__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testCopyOfImmutableSortedSetDifferentComparator();
}
public void testCopyOfSingletonMap__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testCopyOfSingletonMap();
}
public void testCopyOfSortedExplicit__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testCopyOfSortedExplicit();
}
public void testCopyOfSortedNatural__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testCopyOfSortedNatural();
}
public void testEmptyBuilder__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testEmptyBuilder();
}
public void testImmutableMapCopyOfImmutableSortedMap__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testImmutableMapCopyOfImmutableSortedMap();
}
public void testOf__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testOf();
}
public void testOfNullKey__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testOfNullKey();
}
public void testOfNullValue__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testOfNullValue();
}
public void testOfWithDuplicateKey__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testOfWithDuplicateKey();
}
public void testPuttingTheSameKeyTwiceThrowsOnBuild__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testPuttingTheSameKeyTwiceThrowsOnBuild();
}
public void testSingletonBuilder__CreationTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.CreationTests testCase = new com.google.common.collect.ImmutableSortedMapTest.CreationTests();
testCase.testSingletonBuilder();
}
public void testClear__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testClear();
}
public void testContainsKey__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testContainsKey();
}
public void testContainsValue__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testContainsValue();
}
public void testEntrySet__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testGetNull();
}
public void testHashCode__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testSize();
}
public void testTailMapClearThrough__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testTailMapClearThrough();
}
public void testTailMapRemoveThrough__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testTailMapRemoveThrough();
}
public void testTailMapWriteThrough__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testTailMapWriteThrough();
}
public void testValues__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testValues();
}
public void testValuesClear__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__SubMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SubMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SubMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testClear();
}
public void testContainsKey__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testContainsKey();
}
public void testContainsValue__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testContainsValue();
}
public void testEntrySet__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testGetNull();
}
public void testHashCode__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testSize();
}
public void testTailMapClearThrough__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testTailMapClearThrough();
}
public void testTailMapRemoveThrough__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testTailMapRemoveThrough();
}
public void testTailMapWriteThrough__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testTailMapWriteThrough();
}
public void testValues__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testValues();
}
public void testValuesClear__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TailExclusiveMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailExclusiveMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testClear();
}
public void testContainsKey__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testContainsKey();
}
public void testContainsValue__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testContainsValue();
}
public void testEntrySet__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testGetNull();
}
public void testHashCode__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testSize();
}
public void testTailMapClearThrough__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testTailMapClearThrough();
}
public void testTailMapRemoveThrough__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testTailMapRemoveThrough();
}
public void testTailMapWriteThrough__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testTailMapWriteThrough();
}
public void testValues__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testValues();
}
public void testValuesClear__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TailMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.TailMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.TailMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testClear();
}
public void testContainsKey__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testContainsKey();
}
public void testContainsValue__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testContainsValue();
}
public void testEntrySet__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testGet();
}
public void testGetForEmptyMap__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testGetNull();
}
public void testHashCode__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testPutNewKey();
}
public void testPutNullKey__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testPutNullKey();
}
public void testPutNullValue__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testRemove();
}
public void testRemoveMissingKey__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testRemoveMissingKey();
}
public void testSize__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testSize();
}
public void testTailMapClearThrough__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testTailMapClearThrough();
}
public void testTailMapRemoveThrough__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testTailMapRemoveThrough();
}
public void testTailMapWriteThrough__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testTailMapWriteThrough();
}
public void testValues__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testValues();
}
public void testValuesClear__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__HeadMapInclusiveTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapInclusiveTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testClear();
}
public void testContainsKey__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testContainsKey();
}
public void testContainsValue__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testContainsValue();
}
public void testEntrySet__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testGetNull();
}
public void testHashCode__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testSize();
}
public void testTailMapClearThrough__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testTailMapClearThrough();
}
public void testTailMapRemoveThrough__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testTailMapRemoveThrough();
}
public void testTailMapWriteThrough__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testTailMapWriteThrough();
}
public void testValues__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testValues();
}
public void testValuesClear__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__HeadMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.HeadMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.HeadMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testClear();
}
public void testContainsKey__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testContainsKey();
}
public void testContainsValue__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testContainsValue();
}
public void testEntrySet__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testGetNull();
}
public void testHashCode__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testSize();
}
public void testTailMapClearThrough__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testTailMapClearThrough();
}
public void testTailMapRemoveThrough__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testTailMapRemoveThrough();
}
public void testTailMapWriteThrough__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testTailMapWriteThrough();
}
public void testValues__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testValues();
}
public void testValuesClear__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__SingletonMapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.SingletonMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testClear();
}
public void testContainsKey__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testContainsKey();
}
public void testContainsValue__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testContainsValue();
}
public void testEntrySet__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testGet();
}
public void testGetForEmptyMap__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testGetNull();
}
public void testHashCode__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testRemoveMissingKey();
}
public void testSize__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testSize();
}
public void testTailMapClearThrough__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testTailMapClearThrough();
}
public void testTailMapRemoveThrough__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testTailMapRemoveThrough();
}
public void testTailMapWriteThrough__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testTailMapWriteThrough();
}
public void testValues__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testValues();
}
public void testValuesClear__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__MapTests() throws Exception {
com.google.common.collect.ImmutableSortedMapTest.MapTests testCase = new com.google.common.collect.ImmutableSortedMapTest.MapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ImmutableSortedMapTest_gwt.java | Java | asf20 | 118,819 |
/*
* Copyright (C) 2008 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;
public class UnmodifiableListIteratorTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testAdd() throws Exception {
com.google.common.collect.UnmodifiableListIteratorTest testCase = new com.google.common.collect.UnmodifiableListIteratorTest();
testCase.testAdd();
}
public void testRemove() throws Exception {
com.google.common.collect.UnmodifiableListIteratorTest testCase = new com.google.common.collect.UnmodifiableListIteratorTest();
testCase.testRemove();
}
public void testSet() throws Exception {
com.google.common.collect.UnmodifiableListIteratorTest testCase = new com.google.common.collect.UnmodifiableListIteratorTest();
testCase.testSet();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/UnmodifiableListIteratorTest_gwt.java | Java | asf20 | 1,420 |
/*
* Copyright (C) 2008 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;
public class ConstraintsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testConstrainedCollectionIllegal() throws Exception {
com.google.common.collect.ConstraintsTest testCase = new com.google.common.collect.ConstraintsTest();
testCase.testConstrainedCollectionIllegal();
}
public void testConstrainedCollectionLegal() throws Exception {
com.google.common.collect.ConstraintsTest testCase = new com.google.common.collect.ConstraintsTest();
testCase.testConstrainedCollectionLegal();
}
public void testConstrainedListIllegal() throws Exception {
com.google.common.collect.ConstraintsTest testCase = new com.google.common.collect.ConstraintsTest();
testCase.testConstrainedListIllegal();
}
public void testConstrainedListLegal() throws Exception {
com.google.common.collect.ConstraintsTest testCase = new com.google.common.collect.ConstraintsTest();
testCase.testConstrainedListLegal();
}
public void testConstrainedListRandomAccessFalse() throws Exception {
com.google.common.collect.ConstraintsTest testCase = new com.google.common.collect.ConstraintsTest();
testCase.testConstrainedListRandomAccessFalse();
}
public void testConstrainedSetIllegal() throws Exception {
com.google.common.collect.ConstraintsTest testCase = new com.google.common.collect.ConstraintsTest();
testCase.testConstrainedSetIllegal();
}
public void testConstrainedSetLegal() throws Exception {
com.google.common.collect.ConstraintsTest testCase = new com.google.common.collect.ConstraintsTest();
testCase.testConstrainedSetLegal();
}
public void testConstrainedSortedSetIllegal() throws Exception {
com.google.common.collect.ConstraintsTest testCase = new com.google.common.collect.ConstraintsTest();
testCase.testConstrainedSortedSetIllegal();
}
public void testConstrainedSortedSetLegal() throws Exception {
com.google.common.collect.ConstraintsTest testCase = new com.google.common.collect.ConstraintsTest();
testCase.testConstrainedSortedSetLegal();
}
public void testNefariousAddAll() throws Exception {
com.google.common.collect.ConstraintsTest testCase = new com.google.common.collect.ConstraintsTest();
testCase.testNefariousAddAll();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ConstraintsTest_gwt.java | Java | asf20 | 2,923 |
/*
* Copyright (C) 2008 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;
public class ComparisonChainTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testCompareFalseFirst() throws Exception {
com.google.common.collect.ComparisonChainTest testCase = new com.google.common.collect.ComparisonChainTest();
testCase.testCompareFalseFirst();
}
public void testCompareTrueFirst() throws Exception {
com.google.common.collect.ComparisonChainTest testCase = new com.google.common.collect.ComparisonChainTest();
testCase.testCompareTrueFirst();
}
public void testDegenerate() throws Exception {
com.google.common.collect.ComparisonChainTest testCase = new com.google.common.collect.ComparisonChainTest();
testCase.testDegenerate();
}
public void testManyEqual() throws Exception {
com.google.common.collect.ComparisonChainTest testCase = new com.google.common.collect.ComparisonChainTest();
testCase.testManyEqual();
}
public void testOneEqual() throws Exception {
com.google.common.collect.ComparisonChainTest testCase = new com.google.common.collect.ComparisonChainTest();
testCase.testOneEqual();
}
public void testOneEqualUsingComparator() throws Exception {
com.google.common.collect.ComparisonChainTest testCase = new com.google.common.collect.ComparisonChainTest();
testCase.testOneEqualUsingComparator();
}
public void testShortCircuitGreater() throws Exception {
com.google.common.collect.ComparisonChainTest testCase = new com.google.common.collect.ComparisonChainTest();
testCase.testShortCircuitGreater();
}
public void testShortCircuitLess() throws Exception {
com.google.common.collect.ComparisonChainTest testCase = new com.google.common.collect.ComparisonChainTest();
testCase.testShortCircuitLess();
}
public void testShortCircuitSecondStep() throws Exception {
com.google.common.collect.ComparisonChainTest testCase = new com.google.common.collect.ComparisonChainTest();
testCase.testShortCircuitSecondStep();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ComparisonChainTest_gwt.java | Java | asf20 | 2,645 |
/*
* Copyright (C) 2008 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;
public class MultimapsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testAsMap_listMultimap() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testAsMap_listMultimap();
}
public void testAsMap_multimap() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testAsMap_multimap();
}
public void testAsMap_setMultimap() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testAsMap_setMultimap();
}
public void testAsMap_sortedSetMultimap() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testAsMap_sortedSetMultimap();
}
public void testFilteredKeysListMultimapGetBadValue() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testFilteredKeysListMultimapGetBadValue();
}
public void testFilteredKeysSetMultimapGetBadValue() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testFilteredKeysSetMultimapGetBadValue();
}
public void testFilteredKeysSetMultimapReplaceValues() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testFilteredKeysSetMultimapReplaceValues();
}
public void testForMap() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testForMap();
}
public void testForMapAsMap() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testForMapAsMap();
}
public void testForMapGetIteration() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testForMapGetIteration();
}
public void testForMapRemoveAll() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testForMapRemoveAll();
}
public void testIndex() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testIndex();
}
public void testIndexIterator() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testIndexIterator();
}
public void testIndex_nullKey() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testIndex_nullKey();
}
public void testIndex_nullValue() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testIndex_nullValue();
}
public void testIndex_ordering() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testIndex_ordering();
}
public void testInvertFrom() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testInvertFrom();
}
public void testNewListMultimap() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testNewListMultimap();
}
public void testNewMultimap() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testNewMultimap();
}
public void testNewMultimapWithCollectionRejectingNegativeElements() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testNewMultimapWithCollectionRejectingNegativeElements();
}
public void testNewSetMultimap() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testNewSetMultimap();
}
public void testNewSortedSetMultimap() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testNewSortedSetMultimap();
}
public void testSynchronizedMultimapSampleCodeCompilation() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testSynchronizedMultimapSampleCodeCompilation();
}
public void testUnmodifiableArrayListMultimapRandomAccess() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testUnmodifiableArrayListMultimapRandomAccess();
}
public void testUnmodifiableLinkedListMultimapRandomAccess() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testUnmodifiableLinkedListMultimapRandomAccess();
}
public void testUnmodifiableListMultimapShortCircuit() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testUnmodifiableListMultimapShortCircuit();
}
public void testUnmodifiableMultimapEntries() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testUnmodifiableMultimapEntries();
}
public void testUnmodifiableMultimapIsView() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testUnmodifiableMultimapIsView();
}
public void testUnmodifiableMultimapShortCircuit() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testUnmodifiableMultimapShortCircuit();
}
public void testUnmodifiableSetMultimapShortCircuit() throws Exception {
com.google.common.collect.MultimapsTest testCase = new com.google.common.collect.MultimapsTest();
testCase.testUnmodifiableSetMultimapShortCircuit();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/MultimapsTest_gwt.java | Java | asf20 | 6,985 |
/*
* Copyright (C) 2008 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;
public class MultisetsTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testContainsOccurrences() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testContainsOccurrences();
}
public void testContainsOccurrencesEmpty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testContainsOccurrencesEmpty();
}
public void testDifferenceEmptyNonempty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testDifferenceEmptyNonempty();
}
public void testDifferenceNonemptyEmpty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testDifferenceNonemptyEmpty();
}
public void testDifferenceWithMoreElementsInSecondMultiset() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testDifferenceWithMoreElementsInSecondMultiset();
}
public void testDifferenceWithNoRemovedElements() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testDifferenceWithNoRemovedElements();
}
public void testDifferenceWithRemovedElement() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testDifferenceWithRemovedElement();
}
public void testHighestCountFirst() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testHighestCountFirst();
}
public void testIntersectEmptyNonempty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testIntersectEmptyNonempty();
}
public void testIntersectNonemptyEmpty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testIntersectNonemptyEmpty();
}
public void testNewTreeMultisetComparator() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testNewTreeMultisetComparator();
}
public void testNewTreeMultisetDerived() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testNewTreeMultisetDerived();
}
public void testNewTreeMultisetNonGeneric() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testNewTreeMultisetNonGeneric();
}
public void testRemoveEmptyOccurrences() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testRemoveEmptyOccurrences();
}
public void testRemoveOccurrences() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testRemoveOccurrences();
}
public void testRemoveOccurrencesEmpty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testRemoveOccurrencesEmpty();
}
public void testRetainEmptyOccurrences() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testRetainEmptyOccurrences();
}
public void testRetainOccurrences() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testRetainOccurrences();
}
public void testRetainOccurrencesEmpty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testRetainOccurrencesEmpty();
}
public void testSum() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testSum();
}
public void testSumEmptyNonempty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testSumEmptyNonempty();
}
public void testSumNonemptyEmpty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testSumNonemptyEmpty();
}
public void testUnion() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testUnion();
}
public void testUnionEmptyNonempty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testUnionEmptyNonempty();
}
public void testUnionEqualMultisets() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testUnionEqualMultisets();
}
public void testUnionNonemptyEmpty() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testUnionNonemptyEmpty();
}
public void testUnmodifiableMultisetShortCircuit() throws Exception {
com.google.common.collect.MultisetsTest testCase = new com.google.common.collect.MultisetsTest();
testCase.testUnmodifiableMultisetShortCircuit();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/MultisetsTest_gwt.java | Java | asf20 | 6,275 |
/*
* Copyright (C) 2008 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;
public class TreeMultimapExplicitTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testComparator() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testComparator();
}
public void testGetComparator() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testGetComparator();
}
public void testMultimapComparators() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testMultimapComparators();
}
public void testMultimapCreateFromTreeMultimap() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testMultimapCreateFromTreeMultimap();
}
public void testOrderedAsMapEntries() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testOrderedAsMapEntries();
}
public void testOrderedEntries() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testOrderedEntries();
}
public void testOrderedGet() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testOrderedGet();
}
public void testOrderedKeySet() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testOrderedKeySet();
}
public void testOrderedValues() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testOrderedValues();
}
public void testSortedKeySet() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testSortedKeySet();
}
public void testToString() throws Exception {
com.google.common.collect.TreeMultimapExplicitTest testCase = new com.google.common.collect.TreeMultimapExplicitTest();
testCase.testToString();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/TreeMultimapExplicitTest_gwt.java | Java | asf20 | 3,146 |
/*
* Copyright (C) 2008 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;
public class AbstractSequentialIteratorTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testBroken() throws Exception {
com.google.common.collect.AbstractSequentialIteratorTest testCase = new com.google.common.collect.AbstractSequentialIteratorTest();
testCase.testBroken();
}
public void testDoubler() throws Exception {
com.google.common.collect.AbstractSequentialIteratorTest testCase = new com.google.common.collect.AbstractSequentialIteratorTest();
testCase.testDoubler();
}
public void testEmpty() throws Exception {
com.google.common.collect.AbstractSequentialIteratorTest testCase = new com.google.common.collect.AbstractSequentialIteratorTest();
testCase.testEmpty();
}
public void testSampleCode() throws Exception {
com.google.common.collect.AbstractSequentialIteratorTest testCase = new com.google.common.collect.AbstractSequentialIteratorTest();
testCase.testSampleCode();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/AbstractSequentialIteratorTest_gwt.java | Java | asf20 | 1,660 |
/*
* Copyright (C) 2008 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;
public class HashBiMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testBashIt() throws Exception {
com.google.common.collect.HashBiMapTest testCase = new com.google.common.collect.HashBiMapTest();
testCase.testBashIt();
}
public void testBiMapEntrySetIteratorRemove() throws Exception {
com.google.common.collect.HashBiMapTest testCase = new com.google.common.collect.HashBiMapTest();
testCase.testBiMapEntrySetIteratorRemove();
}
public void testMapConstructor() throws Exception {
com.google.common.collect.HashBiMapTest testCase = new com.google.common.collect.HashBiMapTest();
testCase.testMapConstructor();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/HashBiMapTest_gwt.java | Java | asf20 | 1,385 |
/*
* Copyright (C) 2008 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;
public class TableCollectionTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testClear__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testClear();
}
public void testContainsKey__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testContainsKey();
}
public void testContainsValue__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testContainsValue();
}
public void testEntrySet__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testGetNull();
}
public void testHashCode__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testSize();
}
public void testValues__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testValues();
}
public void testValuesClear__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__UnmodifiableTreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testClear();
}
public void testContainsKey__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testContainsKey();
}
public void testContainsValue__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testContainsValue();
}
public void testEntrySet__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testGetNull();
}
public void testHashCode__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testSize();
}
public void testValues__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testValues();
}
public void testValuesClear__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__UnmodifiableHashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testClear();
}
public void testContainsKey__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testContainsKey();
}
public void testContainsValue__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testContainsValue();
}
public void testEntrySet__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testGetNull();
}
public void testHashCode__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testSize();
}
public void testValues__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testValues();
}
public void testValuesClear__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TransformValueColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testClear();
}
public void testContainsKey__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testContainsKey();
}
public void testContainsValue__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testContainsValue();
}
public void testEntrySet__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testGetNull();
}
public void testHashCode__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testSize();
}
public void testValues__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testValues();
}
public void testValuesClear__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TreeColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testClear();
}
public void testContainsKey__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testContainsKey();
}
public void testContainsValue__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testContainsValue();
}
public void testEntrySet__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testGetNull();
}
public void testHashCode__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testSize();
}
public void testValues__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testValues();
}
public void testValuesClear__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__HashColumnMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnMapTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testClear();
}
public void testContainsKey__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testContainsKey();
}
public void testContainsValue__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testContainsValue();
}
public void testEntrySet__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testGetNull();
}
public void testHashCode__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testSize();
}
public void testValues__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testValues();
}
public void testValuesClear__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__UnmodifiableTreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testClear();
}
public void testContainsKey__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testContainsKey();
}
public void testContainsValue__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testContainsValue();
}
public void testEntrySet__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testGetNull();
}
public void testHashCode__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testSize();
}
public void testValues__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testValues();
}
public void testValuesClear__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__UnmodifiableHashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testClear();
}
public void testContainsKey__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testContainsKey();
}
public void testContainsValue__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testContainsValue();
}
public void testEntrySet__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testGetNull();
}
public void testHashCode__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testSize();
}
public void testValues__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testValues();
}
public void testValuesClear__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TransformValueRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testClear();
}
public void testContainsKey__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testContainsKey();
}
public void testContainsValue__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testContainsValue();
}
public void testEntrySet__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testGetNull();
}
public void testHashCode__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testSize();
}
public void testValues__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testValues();
}
public void testValuesClear__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TreeRowMapSubMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapSubMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testClear();
}
public void testContainsKey__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testContainsKey();
}
public void testContainsValue__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testContainsValue();
}
public void testEntrySet__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testGetNull();
}
public void testHashCode__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testSize();
}
public void testValues__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testValues();
}
public void testValuesClear__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TreeRowMapTailMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTailMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testClear();
}
public void testContainsKey__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testContainsKey();
}
public void testContainsValue__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testContainsValue();
}
public void testEntrySet__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testGetNull();
}
public void testHashCode__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testSize();
}
public void testValues__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testValues();
}
public void testValuesClear__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TreeRowMapHeadMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapHeadMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testClear();
}
public void testContainsKey__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testContainsKey();
}
public void testContainsValue__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testContainsValue();
}
public void testEntrySet__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testGetNull();
}
public void testHashCode__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testSize();
}
public void testValues__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testValues();
}
public void testValuesClear__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TreeRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowMapTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testClear();
}
public void testContainsKey__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testContainsKey();
}
public void testContainsValue__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testContainsValue();
}
public void testEntrySet__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testGet();
}
public void testGetForEmptyMap__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testGetNull();
}
public void testHashCode__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testPutNewKey();
}
public void testPutNullKey__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testPutNullKey();
}
public void testPutNullValue__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testRemove();
}
public void testRemoveMissingKey__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testRemoveMissingKey();
}
public void testSize__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testSize();
}
public void testValues__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testValues();
}
public void testValuesClear__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__HashRowMapTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowMapTests testCase = new com.google.common.collect.TableCollectionTest.HashRowMapTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testClear();
}
public void testContainsKey__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testContainsKey();
}
public void testContainsValue__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testContainsValue();
}
public void testEntrySet__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testGet();
}
public void testGetForEmptyMap__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testGetNull();
}
public void testHashCode__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testPutNewKey();
}
public void testPutNullKey__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testPutNullKey();
}
public void testPutNullValue__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testRemove();
}
public void testRemoveMissingKey__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testRemoveMissingKey();
}
public void testSize__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testSize();
}
public void testValues__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testValues();
}
public void testValuesClear__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__UnmodifiableTreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeColumnTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testClear();
}
public void testContainsKey__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testContainsKey();
}
public void testContainsValue__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testContainsValue();
}
public void testEntrySet__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testGet();
}
public void testGetForEmptyMap__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testGetNull();
}
public void testHashCode__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testPutNewKey();
}
public void testPutNullKey__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testPutNullKey();
}
public void testPutNullValue__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testRemove();
}
public void testRemoveMissingKey__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testRemoveMissingKey();
}
public void testSize__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testSize();
}
public void testValues__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testValues();
}
public void testValuesClear__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__UnmodifiableHashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashColumnTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testClear();
}
public void testContainsKey__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testContainsKey();
}
public void testContainsValue__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testContainsValue();
}
public void testEntrySet__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testGet();
}
public void testGetForEmptyMap__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testGetNull();
}
public void testHashCode__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testRemoveMissingKey();
}
public void testSize__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testSize();
}
public void testValues__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testValues();
}
public void testValuesClear__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TransformValueColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueColumnTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testClear();
}
public void testContainsKey__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testContainsKey();
}
public void testContainsValue__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testContainsValue();
}
public void testEntrySet__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testGet();
}
public void testGetForEmptyMap__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testGetNull();
}
public void testHashCode__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testRemoveMissingKey();
}
public void testSize__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testSize();
}
public void testValues__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testValues();
}
public void testValuesClear__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TransposeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TransposeColumnTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testClear();
}
public void testContainsKey__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testContainsKey();
}
public void testContainsValue__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testContainsValue();
}
public void testEntrySet__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testGet();
}
public void testGetForEmptyMap__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testGetNull();
}
public void testHashCode__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testRemoveMissingKey();
}
public void testSize__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testSize();
}
public void testValues__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testValues();
}
public void testValuesClear__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TreeColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeColumnTests testCase = new com.google.common.collect.TableCollectionTest.TreeColumnTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testClear();
}
public void testContainsKey__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testContainsKey();
}
public void testContainsValue__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testContainsValue();
}
public void testEntrySet__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testGet();
}
public void testGetForEmptyMap__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testGetNull();
}
public void testHashCode__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testPutNewKey();
}
public void testPutNullKey__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testPutNullKey();
}
public void testPutNullValue__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testRemove();
}
public void testRemoveMissingKey__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testRemoveMissingKey();
}
public void testSize__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testSize();
}
public void testValues__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testValues();
}
public void testValuesClear__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__HashColumnTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashColumnTests testCase = new com.google.common.collect.TableCollectionTest.HashColumnTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testClear();
}
public void testContainsKey__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testContainsKey();
}
public void testContainsValue__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testContainsValue();
}
public void testEntrySet__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testGet();
}
public void testGetForEmptyMap__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testGetNull();
}
public void testHashCode__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testPutNewKey();
}
public void testPutNullKey__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testPutNullKey();
}
public void testPutNullValue__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testRemove();
}
public void testRemoveMissingKey__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testRemoveMissingKey();
}
public void testSize__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testSize();
}
public void testValues__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testValues();
}
public void testValuesClear__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__UnmodifiableTreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableTreeRowTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testClear();
}
public void testContainsKey__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testContainsKey();
}
public void testContainsValue__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testContainsValue();
}
public void testEntrySet__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testGet();
}
public void testGetForEmptyMap__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testGetNull();
}
public void testHashCode__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testPutNewKey();
}
public void testPutNullKey__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testPutNullKey();
}
public void testPutNullValue__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testRemove();
}
public void testRemoveMissingKey__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testRemoveMissingKey();
}
public void testSize__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testSize();
}
public void testValues__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testValues();
}
public void testValuesClear__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__UnmodifiableHashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests testCase = new com.google.common.collect.TableCollectionTest.UnmodifiableHashRowTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testClear();
}
public void testContainsKey__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testContainsKey();
}
public void testContainsValue__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testContainsValue();
}
public void testEntrySet__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testGet();
}
public void testGetForEmptyMap__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testGetNull();
}
public void testHashCode__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testRemoveMissingKey();
}
public void testSize__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testSize();
}
public void testValues__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testValues();
}
public void testValuesClear__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TransformValueRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransformValueRowTests testCase = new com.google.common.collect.TableCollectionTest.TransformValueRowTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testClear();
}
public void testContainsKey__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testContainsKey();
}
public void testContainsValue__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testContainsValue();
}
public void testEntrySet__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testGet();
}
public void testGetForEmptyMap__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testGetNull();
}
public void testHashCode__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testRemoveMissingKey();
}
public void testSize__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testSize();
}
public void testValues__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testValues();
}
public void testValuesClear__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TransposeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TransposeRowTests testCase = new com.google.common.collect.TableCollectionTest.TransposeRowTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testClear();
}
public void testContainsKey__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testContainsKey();
}
public void testContainsValue__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testContainsValue();
}
public void testEntrySet__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testGet();
}
public void testGetForEmptyMap__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testGetNull();
}
public void testHashCode__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testPutNewKey();
}
public void testPutNullKey__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testPutNullKey();
}
public void testPutNullValue__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testRemove();
}
public void testRemoveMissingKey__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testRemoveMissingKey();
}
public void testSize__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testSize();
}
public void testValues__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testValues();
}
public void testValuesClear__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__TreeRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.TreeRowTests testCase = new com.google.common.collect.TableCollectionTest.TreeRowTests();
testCase.testValuesRetainAllNullFromEmpty();
}
public void testClear__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testClear();
}
public void testContainsKey__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testContainsKey();
}
public void testContainsValue__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testContainsValue();
}
public void testEntrySet__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testEqualsForSmallerMap();
}
public void testGet__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testGet();
}
public void testGetForEmptyMap__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testGetForEmptyMap();
}
public void testGetNull__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testGetNull();
}
public void testHashCode__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testKeySetClear();
}
public void testKeySetRemove__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testPutAllNewKey();
}
public void testPutExistingKey__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testPutExistingKey();
}
public void testPutNewKey__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testPutNewKey();
}
public void testPutNullKey__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testPutNullKey();
}
public void testPutNullValue__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testPutNullValueForExistingKey();
}
public void testRemove__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testRemove();
}
public void testRemoveMissingKey__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testRemoveMissingKey();
}
public void testSize__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testSize();
}
public void testValues__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testValues();
}
public void testValuesClear__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testValuesClear();
}
public void testValuesIteratorRemove__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testValuesRemove();
}
public void testValuesRemoveAll__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty__HashRowTests() throws Exception {
com.google.common.collect.TableCollectionTest.HashRowTests testCase = new com.google.common.collect.TableCollectionTest.HashRowTests();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/TableCollectionTest_gwt.java | Java | asf20 | 386,851 |
/*
* Copyright (C) 2008 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;
public class ConstrainedMultimapAsMapImplementsMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testClear() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testClear();
}
public void testContainsKey() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testContainsKey();
}
public void testContainsValue() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testContainsValue();
}
public void testEntrySet() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testEqualsForSmallerMap();
}
public void testGet() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testGet();
}
public void testGetForEmptyMap() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testGetForEmptyMap();
}
public void testGetNull() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testGetNull();
}
public void testHashCode() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testKeySetClear();
}
public void testKeySetRemove() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testPutAllNewKey();
}
public void testPutExistingKey() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testPutExistingKey();
}
public void testPutNewKey() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testPutNewKey();
}
public void testPutNullKey() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testPutNullKey();
}
public void testPutNullValue() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testPutNullValueForExistingKey();
}
public void testRemove() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testRemove();
}
public void testRemoveMissingKey() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testRemoveMissingKey();
}
public void testSize() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testSize();
}
public void testValues() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testValues();
}
public void testValuesClear() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testValuesClear();
}
public void testValuesIteratorRemove() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testValuesRemove();
}
public void testValuesRemoveAll() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ConstrainedMultimapAsMapImplementsMapTest();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ConstrainedMultimapAsMapImplementsMapTest_gwt.java | Java | asf20 | 14,905 |
/*
* Copyright (C) 2008 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;
public class AbstractMapEntryTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testEquals() throws Exception {
com.google.common.collect.AbstractMapEntryTest testCase = new com.google.common.collect.AbstractMapEntryTest();
testCase.testEquals();
}
public void testEqualsNull() throws Exception {
com.google.common.collect.AbstractMapEntryTest testCase = new com.google.common.collect.AbstractMapEntryTest();
testCase.testEqualsNull();
}
public void testHashCode() throws Exception {
com.google.common.collect.AbstractMapEntryTest testCase = new com.google.common.collect.AbstractMapEntryTest();
testCase.testHashCode();
}
public void testHashCodeNull() throws Exception {
com.google.common.collect.AbstractMapEntryTest testCase = new com.google.common.collect.AbstractMapEntryTest();
testCase.testHashCodeNull();
}
public void testToString() throws Exception {
com.google.common.collect.AbstractMapEntryTest testCase = new com.google.common.collect.AbstractMapEntryTest();
testCase.testToString();
}
public void testToStringNull() throws Exception {
com.google.common.collect.AbstractMapEntryTest testCase = new com.google.common.collect.AbstractMapEntryTest();
testCase.testToStringNull();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/AbstractMapEntryTest_gwt.java | Java | asf20 | 1,974 |
/*
* Copyright (C) 2008 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;
public class UnmodifiableIteratorTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testRemove() throws Exception {
com.google.common.collect.UnmodifiableIteratorTest testCase = new com.google.common.collect.UnmodifiableIteratorTest();
testCase.testRemove();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/UnmodifiableIteratorTest_gwt.java | Java | asf20 | 1,016 |
/*
* Copyright (C) 2008 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;
public class ConstrainedBiMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testPutWithAllowedKeyForbiddenValue() throws Exception {
com.google.common.collect.ConstrainedBiMapTest testCase = new com.google.common.collect.ConstrainedBiMapTest();
testCase.testPutWithAllowedKeyForbiddenValue();
}
public void testPutWithForbiddenKeyAllowedValue() throws Exception {
com.google.common.collect.ConstrainedBiMapTest testCase = new com.google.common.collect.ConstrainedBiMapTest();
testCase.testPutWithForbiddenKeyAllowedValue();
}
public void testPutWithForbiddenKeyForbiddenValue() throws Exception {
com.google.common.collect.ConstrainedBiMapTest testCase = new com.google.common.collect.ConstrainedBiMapTest();
testCase.testPutWithForbiddenKeyForbiddenValue();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ConstrainedBiMapTest_gwt.java | Java | asf20 | 1,530 |
/*
* Copyright (C) 2008 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;
public class ImmutableListTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testAsList__BasicTests() throws Exception {
com.google.common.collect.ImmutableListTest.BasicTests testCase = new com.google.common.collect.ImmutableListTest.BasicTests();
testCase.testAsList();
}
public void testBuilderAdd__BasicTests() throws Exception {
com.google.common.collect.ImmutableListTest.BasicTests testCase = new com.google.common.collect.ImmutableListTest.BasicTests();
testCase.testBuilderAdd();
}
public void testBuilderAddAllHandlesNullsCorrectly__BasicTests() throws Exception {
com.google.common.collect.ImmutableListTest.BasicTests testCase = new com.google.common.collect.ImmutableListTest.BasicTests();
testCase.testBuilderAddAllHandlesNullsCorrectly();
}
public void testBuilderAddAll_iterable__BasicTests() throws Exception {
com.google.common.collect.ImmutableListTest.BasicTests testCase = new com.google.common.collect.ImmutableListTest.BasicTests();
testCase.testBuilderAddAll_iterable();
}
public void testBuilderAddAll_iterator__BasicTests() throws Exception {
com.google.common.collect.ImmutableListTest.BasicTests testCase = new com.google.common.collect.ImmutableListTest.BasicTests();
testCase.testBuilderAddAll_iterator();
}
public void testBuilderAddHandlesNullsCorrectly__BasicTests() throws Exception {
com.google.common.collect.ImmutableListTest.BasicTests testCase = new com.google.common.collect.ImmutableListTest.BasicTests();
testCase.testBuilderAddHandlesNullsCorrectly();
}
public void testBuilderAdd_varargs__BasicTests() throws Exception {
com.google.common.collect.ImmutableListTest.BasicTests testCase = new com.google.common.collect.ImmutableListTest.BasicTests();
testCase.testBuilderAdd_varargs();
}
public void testComplexBuilder__BasicTests() throws Exception {
com.google.common.collect.ImmutableListTest.BasicTests testCase = new com.google.common.collect.ImmutableListTest.BasicTests();
testCase.testComplexBuilder();
}
public void testEquals_immutableList__BasicTests() throws Exception {
com.google.common.collect.ImmutableListTest.BasicTests testCase = new com.google.common.collect.ImmutableListTest.BasicTests();
testCase.testEquals_immutableList();
}
public void testBuilderAddArrayHandlesNulls__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testBuilderAddArrayHandlesNulls();
}
public void testBuilderAddCollectionHandlesNulls__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testBuilderAddCollectionHandlesNulls();
}
public void testCopyOf_arrayContainingOnlyNull__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_arrayContainingOnlyNull();
}
public void testCopyOf_arrayOfOneElement__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_arrayOfOneElement();
}
public void testCopyOf_collectionContainingNull__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_collectionContainingNull();
}
public void testCopyOf_collection_empty__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_collection_empty();
}
public void testCopyOf_collection_general__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_collection_general();
}
public void testCopyOf_collection_oneElement__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_collection_oneElement();
}
public void testCopyOf_concurrentlyMutating__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_concurrentlyMutating();
}
public void testCopyOf_emptyArray__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_emptyArray();
}
public void testCopyOf_iteratorContainingNull__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_iteratorContainingNull();
}
public void testCopyOf_iteratorNull__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_iteratorNull();
}
public void testCopyOf_iterator_empty__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_iterator_empty();
}
public void testCopyOf_iterator_general__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_iterator_general();
}
public void testCopyOf_iterator_oneElement__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_iterator_oneElement();
}
public void testCopyOf_nullArray__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_nullArray();
}
public void testCopyOf_plainIterable__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_plainIterable();
}
public void testCopyOf_plainIterable_iteratesOnce__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_plainIterable_iteratesOnce();
}
public void testCopyOf_shortcut_empty__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_shortcut_empty();
}
public void testCopyOf_shortcut_immutableList__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_shortcut_immutableList();
}
public void testCopyOf_shortcut_singleton__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCopyOf_shortcut_singleton();
}
public void testCreation_arrayOfArray__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_arrayOfArray();
}
public void testCreation_eightElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_eightElements();
}
public void testCreation_elevenElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_elevenElements();
}
public void testCreation_fiveElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_fiveElements();
}
public void testCreation_fourElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_fourElements();
}
public void testCreation_fourteenElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_fourteenElements();
}
public void testCreation_generic__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_generic();
}
public void testCreation_nineElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_nineElements();
}
public void testCreation_noArgs__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_noArgs();
}
public void testCreation_oneElement__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_oneElement();
}
public void testCreation_sevenElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_sevenElements();
}
public void testCreation_singletonNull__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_singletonNull();
}
public void testCreation_sixElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_sixElements();
}
public void testCreation_tenElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_tenElements();
}
public void testCreation_thirteenElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_thirteenElements();
}
public void testCreation_threeElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_threeElements();
}
public void testCreation_twelveElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_twelveElements();
}
public void testCreation_twoElements__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_twoElements();
}
public void testCreation_withNull__CreationTests() throws Exception {
com.google.common.collect.ImmutableListTest.CreationTests testCase = new com.google.common.collect.ImmutableListTest.CreationTests();
testCase.testCreation_withNull();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ImmutableListTest_gwt.java | Java | asf20 | 13,269 |
/*
* Copyright (C) 2008 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;
public class TreeMultisetTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testCreate() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testCreate();
}
public void testCreateFromIterable() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testCreateFromIterable();
}
public void testCreateWithComparator() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testCreateWithComparator();
}
public void testCustomComparator() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testCustomComparator();
}
public void testDegenerateComparator() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testDegenerateComparator();
}
public void testElementSetSortedSetMethods() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testElementSetSortedSetMethods();
}
public void testElementSetSubsetClear() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testElementSetSubsetClear();
}
public void testElementSetSubsetRemove() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testElementSetSubsetRemove();
}
public void testElementSetSubsetRemoveAll() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testElementSetSubsetRemoveAll();
}
public void testElementSetSubsetRetainAll() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testElementSetSubsetRetainAll();
}
public void testNullAcceptingComparator() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testNullAcceptingComparator();
}
public void testSubMultisetSize() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testSubMultisetSize();
}
public void testToString() throws Exception {
com.google.common.collect.TreeMultisetTest testCase = new com.google.common.collect.TreeMultisetTest();
testCase.testToString();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/TreeMultisetTest_gwt.java | Java | asf20 | 3,462 |
/*
* Copyright (C) 2008 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;
public class MapsSortedTransformValuesTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testClear() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testClear();
}
public void testContainsKey() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testContainsKey();
}
public void testContainsValue() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testContainsValue();
}
public void testEntrySet() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testEqualsForSmallerMap();
}
public void testGet() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testGet();
}
public void testGetForEmptyMap() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testGetForEmptyMap();
}
public void testGetNull() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testGetNull();
}
public void testHashCode() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testKeySetClear();
}
public void testKeySetRemove() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testPutAllNewKey();
}
public void testPutExistingKey() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testPutExistingKey();
}
public void testPutNewKey() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testPutNewKey();
}
public void testPutNullKey() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testPutNullKey();
}
public void testPutNullValue() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testPutNullValueForExistingKey();
}
public void testRemove() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testRemove();
}
public void testRemoveMissingKey() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testRemoveMissingKey();
}
public void testSize() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testSize();
}
public void testTransformChangesAreReflectedInUnderlyingMap() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformChangesAreReflectedInUnderlyingMap();
}
public void testTransformEmptyMapEquality() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformEmptyMapEquality();
}
public void testTransformEntrySetContains() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformEntrySetContains();
}
public void testTransformEqualityOfMapsWithNullValues() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformEqualityOfMapsWithNullValues();
}
public void testTransformEquals() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformEquals();
}
public void testTransformIdentityFunctionEquality() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformIdentityFunctionEquality();
}
public void testTransformPutEntryIsUnsupported() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformPutEntryIsUnsupported();
}
public void testTransformReflectsUnderlyingMap() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformReflectsUnderlyingMap();
}
public void testTransformRemoveEntry() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformRemoveEntry();
}
public void testTransformSingletonMapEquality() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformSingletonMapEquality();
}
public void testTransformValuesSecretlySortedMap() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testTransformValuesSecretlySortedMap();
}
public void testValues() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testValues();
}
public void testValuesClear() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testValuesClear();
}
public void testValuesIteratorRemove() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testValuesRemove();
}
public void testValuesRemoveAll() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.MapsSortedTransformValuesTest testCase = new com.google.common.collect.MapsSortedTransformValuesTest();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/MapsSortedTransformValuesTest_gwt.java | Java | asf20 | 16,299 |
/*
* Copyright (C) 2008 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;
public class EmptyImmutableTableTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testCellSet() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testCellSet();
}
public void testClear() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testClear();
}
public void testColumn() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testColumn();
}
public void testColumnKeySet() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testColumnKeySet();
}
public void testColumnMap() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testColumnMap();
}
public void testConsistentHashCode() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testConsistentHashCode();
}
public void testConsistentToString() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testConsistentToString();
}
public void testContains() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testContains();
}
public void testContainsColumn() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testContainsColumn();
}
public void testContainsRow() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testContainsRow();
}
public void testContainsValue() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testContainsValue();
}
public void testEqualsObject() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testEqualsObject();
}
public void testGet() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testGet();
}
public void testHashCode() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testHashCode();
}
public void testIsEmpty() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testIsEmpty();
}
public void testPut() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testPut();
}
public void testPutAll() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testPutAll();
}
public void testRemove() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testRemove();
}
public void testRow() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testRow();
}
public void testRowKeySet() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testRowKeySet();
}
public void testRowMap() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testRowMap();
}
public void testSize() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testSize();
}
public void testToString() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testToString();
}
public void testValues() throws Exception {
com.google.common.collect.EmptyImmutableTableTest testCase = new com.google.common.collect.EmptyImmutableTableTest();
testCase.testValues();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/EmptyImmutableTableTest_gwt.java | Java | asf20 | 5,545 |
/*
* Copyright (C) 2008 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;
public class HashMultisetTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testCreate() throws Exception {
com.google.common.collect.HashMultisetTest testCase = new com.google.common.collect.HashMultisetTest();
testCase.testCreate();
}
public void testCreateFromIterable() throws Exception {
com.google.common.collect.HashMultisetTest testCase = new com.google.common.collect.HashMultisetTest();
testCase.testCreateFromIterable();
}
public void testCreateWithSize() throws Exception {
com.google.common.collect.HashMultisetTest testCase = new com.google.common.collect.HashMultisetTest();
testCase.testCreateWithSize();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/HashMultisetTest_gwt.java | Java | asf20 | 1,388 |
/*
* Copyright (C) 2008 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;
public class ImmutableMultimapAsMapImplementsMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testClear() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testClear();
}
public void testContainsKey() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testContainsKey();
}
public void testContainsValue() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testContainsValue();
}
public void testEntrySet() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySet();
}
public void testEntrySetAddAndAddAll() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetAddAndAddAll();
}
public void testEntrySetClear() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetClear();
}
public void testEntrySetContainsEntryIncompatibleKey() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryIncompatibleKey();
}
public void testEntrySetContainsEntryNullKeyMissing() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryNullKeyMissing();
}
public void testEntrySetContainsEntryNullKeyPresent() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetContainsEntryNullKeyPresent();
}
public void testEntrySetForEmptyMap() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetForEmptyMap();
}
public void testEntrySetIteratorRemove() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetIteratorRemove();
}
public void testEntrySetRemove() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemove();
}
public void testEntrySetRemoveAll() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveAll();
}
public void testEntrySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveAllNullFromEmpty();
}
public void testEntrySetRemoveDifferentValue() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveDifferentValue();
}
public void testEntrySetRemoveMissingKey() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveMissingKey();
}
public void testEntrySetRemoveNullKeyMissing() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveNullKeyMissing();
}
public void testEntrySetRemoveNullKeyPresent() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRemoveNullKeyPresent();
}
public void testEntrySetRetainAll() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRetainAll();
}
public void testEntrySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetRetainAllNullFromEmpty();
}
public void testEntrySetSetValue() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetSetValue();
}
public void testEntrySetSetValueSameValue() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEntrySetSetValueSameValue();
}
public void testEqualsForEmptyMap() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEqualsForEmptyMap();
}
public void testEqualsForEqualMap() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEqualsForEqualMap();
}
public void testEqualsForLargerMap() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEqualsForLargerMap();
}
public void testEqualsForSmallerMap() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testEqualsForSmallerMap();
}
public void testGet() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testGet();
}
public void testGetForEmptyMap() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testGetForEmptyMap();
}
public void testGetNull() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testGetNull();
}
public void testHashCode() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testHashCode();
}
public void testHashCodeForEmptyMap() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testHashCodeForEmptyMap();
}
public void testKeySetClear() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testKeySetClear();
}
public void testKeySetRemove() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testKeySetRemove();
}
public void testKeySetRemoveAll() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testKeySetRemoveAll();
}
public void testKeySetRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testKeySetRemoveAllNullFromEmpty();
}
public void testKeySetRetainAll() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testKeySetRetainAll();
}
public void testKeySetRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testKeySetRetainAllNullFromEmpty();
}
public void testPutAllExistingKey() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testPutAllExistingKey();
}
public void testPutAllNewKey() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testPutAllNewKey();
}
public void testPutExistingKey() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testPutExistingKey();
}
public void testPutNewKey() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testPutNewKey();
}
public void testPutNullKey() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testPutNullKey();
}
public void testPutNullValue() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testPutNullValue();
}
public void testPutNullValueForExistingKey() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testPutNullValueForExistingKey();
}
public void testRemove() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testRemove();
}
public void testRemoveMissingKey() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testRemoveMissingKey();
}
public void testSize() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testSize();
}
public void testValues() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testValues();
}
public void testValuesClear() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testValuesClear();
}
public void testValuesIteratorRemove() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testValuesIteratorRemove();
}
public void testValuesRemove() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testValuesRemove();
}
public void testValuesRemoveAll() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveAll();
}
public void testValuesRemoveAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveAllNullFromEmpty();
}
public void testValuesRemoveMissing() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testValuesRemoveMissing();
}
public void testValuesRetainAll() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testValuesRetainAll();
}
public void testValuesRetainAllNullFromEmpty() throws Exception {
com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest testCase = new com.google.common.collect.ImmutableMultimapAsMapImplementsMapTest();
testCase.testValuesRetainAllNullFromEmpty();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ImmutableMultimapAsMapImplementsMapTest_gwt.java | Java | asf20 | 14,679 |
/*
* Copyright (C) 2008 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;
public class ConstrainedMapTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testPutWithAllowedKeyForbiddenValue() throws Exception {
com.google.common.collect.ConstrainedMapTest testCase = new com.google.common.collect.ConstrainedMapTest();
testCase.testPutWithAllowedKeyForbiddenValue();
}
public void testPutWithForbiddenKeyAllowedValue() throws Exception {
com.google.common.collect.ConstrainedMapTest testCase = new com.google.common.collect.ConstrainedMapTest();
testCase.testPutWithForbiddenKeyAllowedValue();
}
public void testPutWithForbiddenKeyForbiddenValue() throws Exception {
com.google.common.collect.ConstrainedMapTest testCase = new com.google.common.collect.ConstrainedMapTest();
testCase.testPutWithForbiddenKeyForbiddenValue();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/ConstrainedMapTest_gwt.java | Java | asf20 | 1,516 |
/*
* Copyright (C) 2008 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;
public class AbstractIteratorTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testCantRemove() throws Exception {
com.google.common.collect.AbstractIteratorTest testCase = new com.google.common.collect.AbstractIteratorTest();
testCase.testCantRemove();
}
public void testDefaultBehaviorOfNextAndHasNext() throws Exception {
com.google.common.collect.AbstractIteratorTest testCase = new com.google.common.collect.AbstractIteratorTest();
testCase.testDefaultBehaviorOfNextAndHasNext();
}
public void testDefaultBehaviorOfPeek() throws Exception {
com.google.common.collect.AbstractIteratorTest testCase = new com.google.common.collect.AbstractIteratorTest();
testCase.testDefaultBehaviorOfPeek();
}
public void testDefaultBehaviorOfPeekForEmptyIteration() throws Exception {
com.google.common.collect.AbstractIteratorTest testCase = new com.google.common.collect.AbstractIteratorTest();
testCase.testDefaultBehaviorOfPeekForEmptyIteration();
}
public void testException() throws Exception {
com.google.common.collect.AbstractIteratorTest testCase = new com.google.common.collect.AbstractIteratorTest();
testCase.testException();
}
public void testExceptionAfterEndOfData() throws Exception {
com.google.common.collect.AbstractIteratorTest testCase = new com.google.common.collect.AbstractIteratorTest();
testCase.testExceptionAfterEndOfData();
}
public void testReentrantHasNext() throws Exception {
com.google.common.collect.AbstractIteratorTest testCase = new com.google.common.collect.AbstractIteratorTest();
testCase.testReentrantHasNext();
}
public void testSneakyThrow() throws Exception {
com.google.common.collect.AbstractIteratorTest testCase = new com.google.common.collect.AbstractIteratorTest();
testCase.testSneakyThrow();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/AbstractIteratorTest_gwt.java | Java | asf20 | 2,528 |
/*
* Copyright (C) 2008 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;
public class TablesTest_gwt extends com.google.gwt.junit.client.GWTTestCase {
@Override public String getModuleName() {
return "com.google.common.collect.testModule";
}
public void testEntryEquals() throws Exception {
com.google.common.collect.TablesTest testCase = new com.google.common.collect.TablesTest();
testCase.testEntryEquals();
}
public void testEntryEqualsNull() throws Exception {
com.google.common.collect.TablesTest testCase = new com.google.common.collect.TablesTest();
testCase.testEntryEqualsNull();
}
public void testImmutableEntryToString() throws Exception {
com.google.common.collect.TablesTest testCase = new com.google.common.collect.TablesTest();
testCase.testImmutableEntryToString();
}
}
| zzhhhhh-aw4rwer | guava-gwt/test/com/google/common/collect/TablesTest_gwt.java | Java | asf20 | 1,366 |