/*
* Copyright (C) 2017 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;
import static com.google.common.testing.SerializableTester.reserialize;
import static com.google.common.truth.Truth.assertThat;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ObjectArrays;
import com.google.common.collect.testing.ListTestSuiteBuilder;
import com.google.common.collect.testing.SampleElements;
import com.google.common.collect.testing.TestListGenerator;
import com.google.common.collect.testing.features.CollectionFeature;
import com.google.common.collect.testing.features.CollectionSize;
import com.google.common.testing.EqualsTester;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.concurrent.atomic.AtomicLong;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
/** @author Kevin Bourrillion */
@GwtCompatible(emulated = true)
public class ImmutableLongArrayTest extends TestCase {
// Test all creation paths very lazily: by assuming asList() works
public void testOf0() {
assertThat(ImmutableLongArray.of().asList()).isEmpty();
}
public void testOf1() {
assertThat(ImmutableLongArray.of(0).asList()).containsExactly(0L);
}
public void testOf2() {
assertThat(ImmutableLongArray.of(0, 1).asList()).containsExactly(0L, 1L).inOrder();
}
public void testOf3() {
assertThat(ImmutableLongArray.of(0, 1, 3).asList()).containsExactly(0L, 1L, 3L).inOrder();
}
public void testOf4() {
assertThat(ImmutableLongArray.of(0, 1, 3, 6).asList())
.containsExactly(0L, 1L, 3L, 6L)
.inOrder();
}
public void testOf5() {
assertThat(ImmutableLongArray.of(0, 1, 3, 6, 10).asList())
.containsExactly(0L, 1L, 3L, 6L, 10L)
.inOrder();
}
public void testOf6() {
assertThat(ImmutableLongArray.of(0, 1, 3, 6, 10, 15).asList())
.containsExactly(0L, 1L, 3L, 6L, 10L, 15L)
.inOrder();
}
public void testOf7() {
assertThat(ImmutableLongArray.of(0, 1, 3, 6, 10, 15, 21).asList())
.containsExactly(0L, 1L, 3L, 6L, 10L, 15L, 21L)
.inOrder();
}
public void testCopyOf_array_empty() {
/*
* We don't guarantee the same-as property, so we aren't obligated to test it. However, it's
* useful in testing - when two things are the same then one can't have bugs the other doesn't.
*/
assertThat(ImmutableLongArray.copyOf(new long[0])).isSameAs(ImmutableLongArray.of());
}
public void testCopyOf_array_nonempty() {
long[] array = new long[] {0, 1, 3};
ImmutableLongArray iia = ImmutableLongArray.copyOf(array);
array[2] = 2;
assertThat(iia.asList()).containsExactly(0L, 1L, 3L).inOrder();
}
public void testCopyOf_iterable_notCollection_empty() {
Iterable<Long> iterable = iterable(Collections.<Long>emptySet());
assertThat(ImmutableLongArray.copyOf(iterable)).isSameAs(ImmutableLongArray.of());
}
public void testCopyOf_iterable_notCollection_nonempty() {
List<Long> list = Arrays.asList(0L, 1L, 3L);
ImmutableLongArray iia = ImmutableLongArray.copyOf(iterable(list));
list.set(2, 2L);
assertThat(iia.asList()).containsExactly(0L, 1L, 3L).inOrder();
}
public void testCopyOf_iterable_collection_empty() {
Iterable<Long> iterable = Collections.emptySet();
assertThat(ImmutableLongArray.copyOf(iterable)).isSameAs(ImmutableLongArray.of());
}
public void testCopyOf_iterable_collection_nonempty() {
List<Long> list = Arrays.asList(0L, 1L, 3L);
ImmutableLongArray iia = ImmutableLongArray.copyOf((Iterable<Long>) list);
list.set(2, 2L);
assertThat(iia.asList()).containsExactly(0L, 1L, 3L).inOrder();
}
public void testCopyOf_collection_empty() {
Collection<Long> iterable = Collections.emptySet();
assertThat(ImmutableLongArray.copyOf(iterable)).isSameAs(ImmutableLongArray.of());
}
public void testCopyOf_collection_nonempty() {
List<Long> list = Arrays.asList(0L, 1L, 3L);
ImmutableLongArray iia = ImmutableLongArray.copyOf(list);
list.set(2, 2L);
assertThat(iia.asList()).containsExactly(0L, 1L, 3L).inOrder();
}
public void testBuilder_presize_zero() {
ImmutableLongArray.Builder builder = ImmutableLongArray.builder(0);
builder.add(5L);
ImmutableLongArray array = builder.build();
assertThat(array.asList()).containsExactly(5L);
}
public void testBuilder_presize_negative() {
try {
ImmutableLongArray.builder(-1);
fail();
} catch (IllegalArgumentException expected) {
}
}
/**
* If there's a bug in builder growth, we wouldn't know how to expose it. So, brute force the hell
* out of it for a while and see what happens.
*/
public void testBuilder_bruteForce() {
for (long i = 0; i < 100; i++) {
ImmutableLongArray.Builder builder = ImmutableLongArray.builder(RANDOM.nextInt(20));
AtomicLong counter = new AtomicLong(0);
while (counter.get() < 1000) {
BuilderOp op = BuilderOp.randomOp();
op.doIt(builder, counter);
}
ImmutableLongArray iia = builder.build();
for (int j = 0; j < iia.length(); j++) {
assertThat(iia.get(j)).isEqualTo((long) j);
}
}
}
private enum BuilderOp {
ADD_ONE {
@Override
void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
builder.add(counter.getAndIncrement());
}
},
ADD_ARRAY {
@Override
void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
long[] array = new long[RANDOM.nextInt(10)];
for (int i = 0; i < array.length; i++) {
array[i] = counter.getAndIncrement();
}
builder.addAll(array);
}
},
ADD_COLLECTION {
@Override
void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
List<Long> list = new ArrayList<>();
long num = RANDOM.nextInt(10);
for (int i = 0; i < num; i++) {
list.add(counter.getAndIncrement());
}
builder.addAll(list);
}
},
ADD_ITERABLE {
@Override
void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
List<Long> list = new ArrayList<>();
long num = RANDOM.nextInt(10);
for (int i = 0; i < num; i++) {
list.add(counter.getAndIncrement());
}
builder.addAll(iterable(list));
}
},
ADD_IIA {
@Override
void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
long[] array = new long[RANDOM.nextInt(10)];
for (int i = 0; i < array.length; i++) {
array[i] = counter.getAndIncrement();
}
builder.addAll(ImmutableLongArray.copyOf(array));
}
},
ADD_LARGER_ARRAY {
@Override
void doIt(ImmutableLongArray.Builder builder, AtomicLong counter) {
long[] array = new long[RANDOM.nextInt(200) + 200];
for (int i = 0; i < array.length; i++) {
array[i] = counter.getAndIncrement();
}
builder.addAll(array);
}
},
;
static final BuilderOp[] values = values();
static BuilderOp randomOp() {
return values[RANDOM.nextInt(values.length)];
}
abstract void doIt(ImmutableLongArray.Builder builder, AtomicLong counter);
}
private static final Random RANDOM = new Random(42);
public void testLength() {
assertThat(ImmutableLongArray.of().length()).isEqualTo(0);
assertThat(ImmutableLongArray.of(0).length()).isEqualTo(1);
assertThat(ImmutableLongArray.of(0, 1, 3).length()).isEqualTo(3);
assertThat(ImmutableLongArray.of(0, 1, 3).subArray(1, 1).length()).isEqualTo(0);
assertThat(ImmutableLongArray.of(0, 1, 3).subArray(1, 2).length()).isEqualTo(1);
}
public void testIsEmpty() {
assertThat(ImmutableLongArray.of().isEmpty()).isTrue();
assertThat(ImmutableLongArray.of(0).isEmpty()).isFalse();
assertThat(ImmutableLongArray.of(0, 1, 3).isEmpty()).isFalse();
assertThat(ImmutableLongArray.of(0, 1, 3).subArray(1, 1).isEmpty()).isTrue();
assertThat(ImmutableLongArray.of(0, 1, 3).subArray(1, 2).isEmpty()).isFalse();
}
public void testGet_good() {
ImmutableLongArray iia = ImmutableLongArray.of(0, 1, 3);
assertThat(iia.get(0)).isEqualTo(0L);
assertThat(iia.get(2)).isEqualTo(3L);
assertThat(iia.subArray(1, 3).get(1)).isEqualTo(3L);
}
public void testGet_bad() {
ImmutableLongArray iia = ImmutableLongArray.of(0, 1, 3);
try {
iia.get(-1);
fail();
} catch (IndexOutOfBoundsException expected) {
}
try {
iia.get(3);
fail();
} catch (IndexOutOfBoundsException expected) {
}
iia = iia.subArray(1, 2);
try {
iia.get(-1);
fail();
} catch (IndexOutOfBoundsException expected) {
}
}
public void testIndexOf() {
ImmutableLongArray iia = ImmutableLongArray.of(1, 1, 2, 3, 5, 8);
assertThat(iia.indexOf(1)).isEqualTo(0);
assertThat(iia.indexOf(8)).isEqualTo(5);
assertThat(iia.indexOf(4)).isEqualTo(-1);
assertThat(ImmutableLongArray.of(13).indexOf(13)).isEqualTo(0);
assertThat(ImmutableLongArray.of().indexOf(21)).isEqualTo(-1);
assertThat(iia.subArray(1, 5).indexOf(1)).isEqualTo(0);
}
public void testLastIndexOf() {
ImmutableLongArray iia = ImmutableLongArray.of(1, 1, 2, 3, 5, 8);
assertThat(iia.lastIndexOf(1)).isEqualTo(1);
assertThat(iia.lastIndexOf(8)).isEqualTo(5);
assertThat(iia.lastIndexOf(4)).isEqualTo(-1);
assertThat(ImmutableLongArray.of(13).lastIndexOf(13)).isEqualTo(0);
assertThat(ImmutableLongArray.of().lastIndexOf(21)).isEqualTo(-1);
assertThat(iia.subArray(1, 5).lastIndexOf(1)).isEqualTo(0);
}
public void testContains() {
ImmutableLongArray iia = ImmutableLongArray.of(1, 1, 2, 3, 5, 8);
assertThat(iia.contains(1)).isTrue();
assertThat(iia.contains(8)).isTrue();
assertThat(iia.contains(4)).isFalse();
assertThat(ImmutableLongArray.of(13).contains(13)).isTrue();
assertThat(ImmutableLongArray.of().contains(21)).isFalse();
assertThat(iia.subArray(1, 5).contains(1)).isTrue();
}
public void testSubArray() {
ImmutableLongArray iia0 = ImmutableLongArray.of();
ImmutableLongArray iia1 = ImmutableLongArray.of(5);
ImmutableLongArray iia3 = ImmutableLongArray.of(5, 25, 125);
assertThat(iia0.subArray(0, 0)).isSameAs(ImmutableLongArray.of());
assertThat(iia1.subArray(0, 0)).isSameAs(ImmutableLongArray.of());
assertThat(iia1.subArray(1, 1)).isSameAs(ImmutableLongArray.of());
assertThat(iia1.subArray(0, 1).asList()).containsExactly(5L);
assertThat(iia3.subArray(0, 2).asList()).containsExactly(5L, 25L).inOrder();
assertThat(iia3.subArray(1, 3).asList()).containsExactly(25L, 125L).inOrder();
try {
iia3.subArray(-1, 1);
fail();
} catch (IndexOutOfBoundsException expected) {
}
try {
iia3.subArray(1, 4);
fail();
} catch (IndexOutOfBoundsException expected) {
}
}
/*
* Whenever an implementation uses `instanceof` on a parameter instance, the test has to know that
* (so much for "black box") and try instances that both do and don't pass the check. The "don't"
* half of that is more awkward to arrange...
*/
private static <T> Iterable<T> iterable(final Collection<T> collection) {
// return collection::iterator;
return new Iterable<T>() {
@Override
public Iterator<T> iterator() {
return collection.iterator();
}
};
}
public void testEquals() {
new EqualsTester()
.addEqualityGroup(ImmutableLongArray.of())
.addEqualityGroup(
ImmutableLongArray.of(1, 2),
reserialize(ImmutableLongArray.of(1, 2)),
ImmutableLongArray.of(0, 1, 2, 3).subArray(1, 3))
.addEqualityGroup(ImmutableLongArray.of(1, 3))
.addEqualityGroup(ImmutableLongArray.of(1, 2, 3))
.testEquals();
}
/**
* This is probably a weird and hacky way to test what we're really trying to test, but hey, it
* caught a bug.
*/
public void testTrimmed() {
ImmutableLongArray iia = ImmutableLongArray.of(0, 1, 3);
assertDoesntActuallyTrim(iia);
assertDoesntActuallyTrim(iia.subArray(0, 3));
assertActuallyTrims(iia.subArray(0, 2));
assertActuallyTrims(iia.subArray(1, 3));
ImmutableLongArray rightSized = ImmutableLongArray.builder(3).add(0).add(1).add(3).build();
assertDoesntActuallyTrim(rightSized);
ImmutableLongArray overSized = ImmutableLongArray.builder(3).add(0).add(1).build();
assertActuallyTrims(overSized);
ImmutableLongArray underSized = ImmutableLongArray.builder(2).add(0).add(1).add(3).build();
assertActuallyTrims(underSized);
}
@GwtIncompatible // SerializableTester
public void testSerialization() {
assertThat(reserialize(ImmutableLongArray.of())).isSameAs(ImmutableLongArray.of());
assertThat(reserialize(ImmutableLongArray.of(0, 1).subArray(1, 1)))
.isSameAs(ImmutableLongArray.of());
ImmutableLongArray iia = ImmutableLongArray.of(0, 1, 3, 6).subArray(1, 3);
ImmutableLongArray iia2 = reserialize(iia);
assertThat(iia2).isEqualTo(iia);
assertDoesntActuallyTrim(iia2);
}
private static void assertActuallyTrims(ImmutableLongArray iia) {
ImmutableLongArray trimmed = iia.trimmed();
assertThat(trimmed).isNotSameAs(iia);
// Yes, this is apparently how you check array equality in Truth
assertThat(trimmed.toArray()).isEqualTo(iia.toArray());
}
private static void assertDoesntActuallyTrim(ImmutableLongArray iia) {
assertThat(iia.trimmed()).isSameAs(iia);
}
@GwtIncompatible // suite
public static Test suite() {
List<ListTestSuiteBuilder<Long>> builders =
ImmutableList.of(
ListTestSuiteBuilder.using(new ImmutableLongArrayAsListGenerator())
.named("ImmutableLongArray.asList"),
ListTestSuiteBuilder.using(new ImmutableLongArrayHeadSubListAsListGenerator())
.named("ImmutableLongArray.asList, head subList"),
ListTestSuiteBuilder.using(new ImmutableLongArrayTailSubListAsListGenerator())
.named("ImmutableLongArray.asList, tail subList"),
ListTestSuiteBuilder.using(new ImmutableLongArrayMiddleSubListAsListGenerator())
.named("ImmutableLongArray.asList, middle subList"));
TestSuite suite = new TestSuite();
for (ListTestSuiteBuilder<Long> builder : builders) {
suite.addTest(
builder
.withFeatures(
CollectionSize.ZERO,
CollectionSize.ONE,
CollectionSize.SEVERAL,
CollectionFeature.ALLOWS_NULL_QUERIES,
CollectionFeature.RESTRICTS_ELEMENTS,
CollectionFeature.KNOWN_ORDER,
CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)
.createTestSuite());
}
return suite;
}
@GwtIncompatible // used only from suite
private static ImmutableLongArray makeArray(Long[] values) {
return ImmutableLongArray.copyOf(Arrays.asList(values));
}
// Test generators. To let the GWT test suite generator access them, they need to be public named
// classes with a public default constructor (not that we run these suites under GWT yet).
@GwtIncompatible // used only from suite
public static final class ImmutableLongArrayAsListGenerator extends TestLongListGenerator {
@Override
protected List<Long> create(Long[] elements) {
return makeArray(elements).asList();
}
}
@GwtIncompatible // used only from suite
public static final class ImmutableLongArrayHeadSubListAsListGenerator
extends TestLongListGenerator {
@Override
protected List<Long> create(Long[] elements) {
Long[] suffix = {Long.MIN_VALUE, Long.MAX_VALUE};
Long[] all = concat(elements, suffix);
return makeArray(all).subArray(0, elements.length).asList();
}
}
@GwtIncompatible // used only from suite
public static final class ImmutableLongArrayTailSubListAsListGenerator
extends TestLongListGenerator {
@Override
protected List<Long> create(Long[] elements) {
Long[] prefix = {86L, 99L};
Long[] all = concat(prefix, elements);
return makeArray(all).subArray(2, elements.length + 2).asList();
}
}
@GwtIncompatible // used only from suite
public static final class ImmutableLongArrayMiddleSubListAsListGenerator
extends TestLongListGenerator {
@Override
protected List<Long> create(Long[] elements) {
Long[] prefix = {Long.MIN_VALUE, Long.MAX_VALUE};
Long[] suffix = {86L, 99L};
Long[] all = concat(concat(prefix, elements), suffix);
return makeArray(all).subArray(2, elements.length + 2).asList();
}
}
@GwtIncompatible // used only from suite
private static Long[] concat(Long[] a, Long[] b) {
return ObjectArrays.concat(a, b, Long.class);
}
@GwtIncompatible // used only from suite
public abstract static class TestLongListGenerator implements TestListGenerator<Long> {
@Override
public SampleElements<Long> samples() {
return new SampleLongs();
}
@Override
public List<Long> create(Object... elements) {
Long[] array = new Long[elements.length];
int i = 0;
for (Object e : elements) {
array[i++] = (Long) e;
}
return create(array);
}
/**
* Creates a new collection containing the given elements; implement this method instead of
* {@link #create(Object...)}.
*/
protected abstract List<Long> create(Long[] elements);
@Override
public Long[] createArray(int length) {
return new Long[length];
}
/** Returns the original element list, unchanged. */
@Override
public List<Long> order(List<Long> insertionOrder) {
return insertionOrder;
}
}
@GwtIncompatible // used only from suite
public static class SampleLongs extends SampleElements<Long> {
public SampleLongs() {
super(1L << 31, 1L << 33, 1L << 36, 1L << 40, 1L << 45);
}
}
}