guava-tests/test/com/google/common/primitives/ImmutableDoubleArrayTest.java - platform/external/guava - Git at Google

 /*
  * 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.primitives.TestPlatform.reduceIterationsIfGwt;
 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.AtomicInteger;
 import java.util.stream.DoubleStream;
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;

 /** @author Kevin Bourrillion */
 @GwtCompatible(emulated = true)
 public class ImmutableDoubleArrayTest extends TestCase {
   // Test all creation paths very lazily: by assuming asList() works

   public void testOf0() {
     assertThat(ImmutableDoubleArray.of().asList()).isEmpty();
   }

   public void testOf1() {
     assertThat(ImmutableDoubleArray.of(0).asList()).containsExactly(0.0);
   }

   public void testOf2() {
     assertThat(ImmutableDoubleArray.of(0, 1).asList()).containsExactly(0.0, 1.0).inOrder();
   }

   public void testOf3() {
     assertThat(ImmutableDoubleArray.of(0, 1, 3).asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
   }

   public void testOf4() {
     assertThat(ImmutableDoubleArray.of(0, 1, 3, 6).asList())
         .containsExactly(0.0, 1.0, 3.0, 6.0)
         .inOrder();
   }

   public void testOf5() {
     assertThat(ImmutableDoubleArray.of(0, 1, 3, 6, 10).asList())
         .containsExactly(0.0, 1.0, 3.0, 6.0, 10.0)
         .inOrder();
   }

   public void testOf6() {
     assertThat(ImmutableDoubleArray.of(0, 1, 3, 6, 10, 15).asList())
         .containsExactly(0.0, 1.0, 3.0, 6.0, 10.0, 15.0)
         .inOrder();
   }

   public void testOf7() {
     assertThat(ImmutableDoubleArray.of(0, 1, 3, 6, 10, 15, 21).asList())
         .containsExactly(0.0, 1.0, 3.0, 6.0, 10.0, 15.0, 21.0)
         .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(ImmutableDoubleArray.copyOf(new double[0]))
         .isSameInstanceAs(ImmutableDoubleArray.of());
   }

   public void testCopyOf_array_nonempty() {
     double[] array = new double[] {0, 1, 3};
     ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf(array);
     array[2] = 2;
     assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
   }

   public void testCopyOf_iterable_notCollection_empty() {
     Iterable<Double> iterable = iterable(Collections.<Double>emptySet());
     assertThat(ImmutableDoubleArray.copyOf(iterable)).isSameInstanceAs(ImmutableDoubleArray.of());
   }

   public void testCopyOf_iterable_notCollection_nonempty() {
     List<Double> list = Arrays.asList(0.0, 1.0, 3.0);
     ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf(iterable(list));
     list.set(2, 2.0);
     assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
   }

   public void testCopyOf_iterable_collection_empty() {
     Iterable<Double> iterable = Collections.emptySet();
     assertThat(ImmutableDoubleArray.copyOf(iterable)).isSameInstanceAs(ImmutableDoubleArray.of());
   }

   public void testCopyOf_iterable_collection_nonempty() {
     List<Double> list = Arrays.asList(0.0, 1.0, 3.0);
     ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf((Iterable<Double>) list);
     list.set(2, 2.0);
     assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
   }

   public void testCopyOf_collection_empty() {
     Collection<Double> iterable = Collections.emptySet();
     assertThat(ImmutableDoubleArray.copyOf(iterable)).isSameInstanceAs(ImmutableDoubleArray.of());
   }

   public void testCopyOf_collection_nonempty() {
     List<Double> list = Arrays.asList(0.0, 1.0, 3.0);
     ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf(list);
     list.set(2, 2.0);
     assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
   }

   public void testCopyOf_stream() {
     assertThat(ImmutableDoubleArray.copyOf(DoubleStream.empty()))
         .isSameInstanceAs(ImmutableDoubleArray.of());
     assertThat(ImmutableDoubleArray.copyOf(DoubleStream.of(0, 1, 3)).asList())
         .containsExactly(0.0, 1.0, 3.0)
         .inOrder();
   }

   public void testBuilder_presize_zero() {
     ImmutableDoubleArray.Builder builder = ImmutableDoubleArray.builder(0);
     builder.add(5.0);
     ImmutableDoubleArray array = builder.build();
     assertThat(array.asList()).containsExactly(5.0);
   }

   public void testBuilder_presize_negative() {
     try {
       ImmutableDoubleArray.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 (int i = 0; i < reduceIterationsIfGwt(100); i++) {
       ImmutableDoubleArray.Builder builder = ImmutableDoubleArray.builder(RANDOM.nextInt(20));
       AtomicInteger counter = new AtomicInteger(0);
       while (counter.get() < 1000) {
         BuilderOp op = BuilderOp.randomOp();
         op.doIt(builder, counter);
       }
       ImmutableDoubleArray iia = builder.build();
       for (int j = 0; j < iia.length(); j++) {
         assertThat(iia.get(j)).isEqualTo((double) j);
       }
     }
   }

   private enum BuilderOp {
     ADD_ONE {
       @Override
       void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
         builder.add(counter.getAndIncrement());
       }
     },
     ADD_ARRAY {
       @Override
       void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
         double[] array = new double[RANDOM.nextInt(10)];
         for (int i = 0; i < array.length; i++) {
           array[i] = counter.getAndIncrement();
         }
         builder.addAll(array);
       }
     },
     ADD_COLLECTION {
       @Override
       void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
         List<Double> list = new ArrayList<>();
         double num = RANDOM.nextInt(10);
         for (int i = 0; i < num; i++) {
           list.add((double) counter.getAndIncrement());
         }
         builder.addAll(list);
       }
     },
     ADD_ITERABLE {
       @Override
       void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
         List<Double> list = new ArrayList<>();
         double num = RANDOM.nextInt(10);
         for (int i = 0; i < num; i++) {
           list.add((double) counter.getAndIncrement());
         }
         builder.addAll(iterable(list));
       }
     },
     ADD_STREAM {
       @Override
       void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
         double[] array = new double[RANDOM.nextInt(10)];
         for (int i = 0; i < array.length; i++) {
           array[i] = counter.getAndIncrement();
         }
         builder.addAll(Arrays.stream(array));
       }
     },
     ADD_IIA {
       @Override
       void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
         double[] array = new double[RANDOM.nextInt(10)];
         for (int i = 0; i < array.length; i++) {
           array[i] = counter.getAndIncrement();
         }
         builder.addAll(ImmutableDoubleArray.copyOf(array));
       }
     },
     ADD_LARGER_ARRAY {
       @Override
       void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
         double[] array = new double[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(ImmutableDoubleArray.Builder builder, AtomicInteger counter);
   }

   private static final Random RANDOM = new Random(42);

   public void testLength() {
     assertThat(ImmutableDoubleArray.of().length()).isEqualTo(0);
     assertThat(ImmutableDoubleArray.of(0).length()).isEqualTo(1);
     assertThat(ImmutableDoubleArray.of(0, 1, 3).length()).isEqualTo(3);
     assertThat(ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).length()).isEqualTo(0);
     assertThat(ImmutableDoubleArray.of(0, 1, 3).subArray(1, 2).length()).isEqualTo(1);
   }

   public void testIsEmpty() {
     assertThat(ImmutableDoubleArray.of().isEmpty()).isTrue();
     assertThat(ImmutableDoubleArray.of(0).isEmpty()).isFalse();
     assertThat(ImmutableDoubleArray.of(0, 1, 3).isEmpty()).isFalse();
     assertThat(ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).isEmpty()).isTrue();
     assertThat(ImmutableDoubleArray.of(0, 1, 3).subArray(1, 2).isEmpty()).isFalse();
   }

   public void testGet_good() {
     ImmutableDoubleArray iia = ImmutableDoubleArray.of(0, 1, 3);
     assertThat(iia.get(0)).isEqualTo(0.0);
     assertThat(iia.get(2)).isEqualTo(3.0);
     assertThat(iia.subArray(1, 3).get(1)).isEqualTo(3.0);
   }

   public void testGet_bad() {
     ImmutableDoubleArray iia = ImmutableDoubleArray.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() {
     ImmutableDoubleArray iia = ImmutableDoubleArray.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(ImmutableDoubleArray.of(13).indexOf(13)).isEqualTo(0);
     assertThat(ImmutableDoubleArray.of().indexOf(21)).isEqualTo(-1);
     assertThat(iia.subArray(1, 5).indexOf(1)).isEqualTo(0);
   }

   public void testIndexOf_specialValues() {
     ImmutableDoubleArray iia =
         ImmutableDoubleArray.of(-0.0, 0.0, Double.MAX_VALUE, Double.POSITIVE_INFINITY, Double.NaN);
     assertThat(iia.indexOf(-0.0)).isEqualTo(0);
     assertThat(iia.indexOf(0.0)).isEqualTo(1);
     assertThat(iia.indexOf(Double.MAX_VALUE)).isEqualTo(2);
     assertThat(iia.indexOf(Double.POSITIVE_INFINITY)).isEqualTo(3);
     assertThat(iia.indexOf(Double.NaN)).isEqualTo(4);
   }

   public void testLastIndexOf() {
     ImmutableDoubleArray iia = ImmutableDoubleArray.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(ImmutableDoubleArray.of(13).lastIndexOf(13)).isEqualTo(0);
     assertThat(ImmutableDoubleArray.of().lastIndexOf(21)).isEqualTo(-1);
     assertThat(iia.subArray(1, 5).lastIndexOf(1)).isEqualTo(0);
   }

   public void testContains() {
     ImmutableDoubleArray iia = ImmutableDoubleArray.of(1, 1, 2, 3, 5, 8);
     assertThat(iia.contains(1)).isTrue();
     assertThat(iia.contains(8)).isTrue();
     assertThat(iia.contains(4)).isFalse();
     assertThat(ImmutableDoubleArray.of(13).contains(13)).isTrue();
     assertThat(ImmutableDoubleArray.of().contains(21)).isFalse();
     assertThat(iia.subArray(1, 5).contains(1)).isTrue();
   }

   public void testForEach() {
     ImmutableDoubleArray.of().forEach(i -> fail());
     ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).forEach(i -> fail());

     AtomicInteger count = new AtomicInteger(0);
     ImmutableDoubleArray.of(0, 1, 2, 3)
         .forEach(i -> assertThat(i).isEqualTo((double) count.getAndIncrement()));
     assertEquals(4, count.get());
   }

   public void testStream() {
     ImmutableDoubleArray.of().stream().forEach(i -> fail());
     ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).stream().forEach(i -> fail());
     assertThat(ImmutableDoubleArray.of(0, 1, 3).stream().toArray())
         .isEqualTo(new double[] {0, 1, 3});
   }

   public void testSubArray() {
     ImmutableDoubleArray iia0 = ImmutableDoubleArray.of();
     ImmutableDoubleArray iia1 = ImmutableDoubleArray.of(5);
     ImmutableDoubleArray iia3 = ImmutableDoubleArray.of(5, 25, 125);

     assertThat(iia0.subArray(0, 0)).isSameInstanceAs(ImmutableDoubleArray.of());
     assertThat(iia1.subArray(0, 0)).isSameInstanceAs(ImmutableDoubleArray.of());
     assertThat(iia1.subArray(1, 1)).isSameInstanceAs(ImmutableDoubleArray.of());
     assertThat(iia1.subArray(0, 1).asList()).containsExactly(5.0);
     assertThat(iia3.subArray(0, 2).asList()).containsExactly(5.0, 25.0).inOrder();
     assertThat(iia3.subArray(1, 3).asList()).containsExactly(25.0, 125.0).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(ImmutableDoubleArray.of())
         .addEqualityGroup(
             ImmutableDoubleArray.of(1, 2),
             reserialize(ImmutableDoubleArray.of(1, 2)),
             ImmutableDoubleArray.of(0, 1, 2, 3).subArray(1, 3))
         .addEqualityGroup(ImmutableDoubleArray.of(1, 3))
         .addEqualityGroup(ImmutableDoubleArray.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() {
     ImmutableDoubleArray iia = ImmutableDoubleArray.of(0, 1, 3);
     assertDoesntActuallyTrim(iia);
     assertDoesntActuallyTrim(iia.subArray(0, 3));
     assertActuallyTrims(iia.subArray(0, 2));
     assertActuallyTrims(iia.subArray(1, 3));

     ImmutableDoubleArray rightSized = ImmutableDoubleArray.builder(3).add(0).add(1).add(3).build();
     assertDoesntActuallyTrim(rightSized);

     ImmutableDoubleArray overSized = ImmutableDoubleArray.builder(3).add(0).add(1).build();
     assertActuallyTrims(overSized);

     ImmutableDoubleArray underSized = ImmutableDoubleArray.builder(2).add(0).add(1).add(3).build();
     assertActuallyTrims(underSized);
   }

   @GwtIncompatible // SerializableTester
   public void testSerialization() {
     assertThat(reserialize(ImmutableDoubleArray.of())).isSameInstanceAs(ImmutableDoubleArray.of());
     assertThat(reserialize(ImmutableDoubleArray.of(0, 1).subArray(1, 1)))
         .isSameInstanceAs(ImmutableDoubleArray.of());

     ImmutableDoubleArray iia = ImmutableDoubleArray.of(0, 1, 3, 6).subArray(1, 3);
     ImmutableDoubleArray iia2 = reserialize(iia);
     assertThat(iia2).isEqualTo(iia);
     assertDoesntActuallyTrim(iia2);
   }

   private static void assertActuallyTrims(ImmutableDoubleArray iia) {
     ImmutableDoubleArray trimmed = iia.trimmed();
     assertThat(trimmed).isNotSameInstanceAs(iia);

     // Yes, this is apparently how you check array equality in Truth
     assertThat(trimmed.toArray()).isEqualTo(iia.toArray());
   }

   private static void assertDoesntActuallyTrim(ImmutableDoubleArray iia) {
     assertThat(iia.trimmed()).isSameInstanceAs(iia);
   }

   @GwtIncompatible // suite
   public static Test suite() {
     List<ListTestSuiteBuilder<Double>> builders =
         ImmutableList.of(
             ListTestSuiteBuilder.using(new ImmutableDoubleArrayAsListGenerator())
                 .named("ImmutableDoubleArray.asList"),
             ListTestSuiteBuilder.using(new ImmutableDoubleArrayHeadSubListAsListGenerator())
                 .named("ImmutableDoubleArray.asList, head subList"),
             ListTestSuiteBuilder.using(new ImmutableDoubleArrayTailSubListAsListGenerator())
                 .named("ImmutableDoubleArray.asList, tail subList"),
             ListTestSuiteBuilder.using(new ImmutableDoubleArrayMiddleSubListAsListGenerator())
                 .named("ImmutableDoubleArray.asList, middle subList"));

     TestSuite suite = new TestSuite();
     for (ListTestSuiteBuilder<Double> 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());
     }
     suite.addTestSuite(ImmutableDoubleArrayTest.class);
     return suite;
   }

   @GwtIncompatible // used only from suite
   private static ImmutableDoubleArray makeArray(Double[] values) {
     return ImmutableDoubleArray.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 ImmutableDoubleArrayAsListGenerator extends TestDoubleListGenerator {
     @Override
     protected List<Double> create(Double[] elements) {
       return makeArray(elements).asList();
     }
   }

   @GwtIncompatible // used only from suite
   public static final class ImmutableDoubleArrayHeadSubListAsListGenerator
       extends TestDoubleListGenerator {
     @Override
     protected List<Double> create(Double[] elements) {
       Double[] suffix = {Double.MIN_VALUE, Double.MAX_VALUE};
       Double[] all = concat(elements, suffix);
       return makeArray(all).subArray(0, elements.length).asList();
     }
   }

   @GwtIncompatible // used only from suite
   public static final class ImmutableDoubleArrayTailSubListAsListGenerator
       extends TestDoubleListGenerator {
     @Override
     protected List<Double> create(Double[] elements) {
       Double[] prefix = {86.0, 99.0};
       Double[] all = concat(prefix, elements);
       return makeArray(all).subArray(2, elements.length + 2).asList();
     }
   }

   @GwtIncompatible // used only from suite
   public static final class ImmutableDoubleArrayMiddleSubListAsListGenerator
       extends TestDoubleListGenerator {
     @Override
     protected List<Double> create(Double[] elements) {
       Double[] prefix = {Double.MIN_VALUE, Double.MAX_VALUE};
       Double[] suffix = {86.0, 99.0};
       Double[] all = concat(concat(prefix, elements), suffix);
       return makeArray(all).subArray(2, elements.length + 2).asList();
     }
   }

   @GwtIncompatible // used only from suite
   private static Double[] concat(Double[] a, Double[] b) {
     return ObjectArrays.concat(a, b, Double.class);
   }

   @GwtIncompatible // used only from suite
   public abstract static class TestDoubleListGenerator implements TestListGenerator<Double> {
     @Override
     public SampleElements<Double> samples() {
       return new SampleDoubles();
     }

     @Override
     public List<Double> create(Object... elements) {
       Double[] array = new Double[elements.length];
       int i = 0;
       for (Object e : elements) {
         array[i++] = (Double) e;
       }
       return create(array);
     }

     /**
      * Creates a new collection containing the given elements; implement this method instead of
      * {@link #create(Object...)}.
      */
     protected abstract List<Double> create(Double[] elements);

     @Override
     public Double[] createArray(int length) {
       return new Double[length];
     }

     /** Returns the original element list, unchanged. */
     @Override
     public List<Double> order(List<Double> insertionOrder) {
       return insertionOrder;
     }
   }

   @GwtIncompatible // used only from suite
   public static class SampleDoubles extends SampleElements<Double> {
     public SampleDoubles() {
       super(-0.0, Long.MAX_VALUE * 3.0, Double.MAX_VALUE, Double.POSITIVE_INFINITY, Double.NaN);
     }
   }
 }
	/*
	* 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.primitives.TestPlatform.reduceIterationsIfGwt;
	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.AtomicInteger;
	import java.util.stream.DoubleStream;
	import junit.framework.Test;
	import junit.framework.TestCase;
	import junit.framework.TestSuite;

	/** @author Kevin Bourrillion */
	@GwtCompatible(emulated = true)
	public class ImmutableDoubleArrayTest extends TestCase {
	// Test all creation paths very lazily: by assuming asList() works

	public void testOf0() {
	assertThat(ImmutableDoubleArray.of().asList()).isEmpty();
	}

	public void testOf1() {
	assertThat(ImmutableDoubleArray.of(0).asList()).containsExactly(0.0);
	}

	public void testOf2() {
	assertThat(ImmutableDoubleArray.of(0, 1).asList()).containsExactly(0.0, 1.0).inOrder();
	}

	public void testOf3() {
	assertThat(ImmutableDoubleArray.of(0, 1, 3).asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
	}

	public void testOf4() {
	assertThat(ImmutableDoubleArray.of(0, 1, 3, 6).asList())
	.containsExactly(0.0, 1.0, 3.0, 6.0)
	.inOrder();
	}

	public void testOf5() {
	assertThat(ImmutableDoubleArray.of(0, 1, 3, 6, 10).asList())
	.containsExactly(0.0, 1.0, 3.0, 6.0, 10.0)
	.inOrder();
	}

	public void testOf6() {
	assertThat(ImmutableDoubleArray.of(0, 1, 3, 6, 10, 15).asList())
	.containsExactly(0.0, 1.0, 3.0, 6.0, 10.0, 15.0)
	.inOrder();
	}

	public void testOf7() {
	assertThat(ImmutableDoubleArray.of(0, 1, 3, 6, 10, 15, 21).asList())
	.containsExactly(0.0, 1.0, 3.0, 6.0, 10.0, 15.0, 21.0)
	.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(ImmutableDoubleArray.copyOf(new double[0]))
	.isSameInstanceAs(ImmutableDoubleArray.of());
	}

	public void testCopyOf_array_nonempty() {
	double[] array = new double[] {0, 1, 3};
	ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf(array);
	array[2] = 2;
	assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
	}

	public void testCopyOf_iterable_notCollection_empty() {
	Iterable<Double> iterable = iterable(Collections.<Double>emptySet());
	assertThat(ImmutableDoubleArray.copyOf(iterable)).isSameInstanceAs(ImmutableDoubleArray.of());
	}

	public void testCopyOf_iterable_notCollection_nonempty() {
	List<Double> list = Arrays.asList(0.0, 1.0, 3.0);
	ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf(iterable(list));
	list.set(2, 2.0);
	assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
	}

	public void testCopyOf_iterable_collection_empty() {
	Iterable<Double> iterable = Collections.emptySet();
	assertThat(ImmutableDoubleArray.copyOf(iterable)).isSameInstanceAs(ImmutableDoubleArray.of());
	}

	public void testCopyOf_iterable_collection_nonempty() {
	List<Double> list = Arrays.asList(0.0, 1.0, 3.0);
	ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf((Iterable<Double>) list);
	list.set(2, 2.0);
	assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
	}

	public void testCopyOf_collection_empty() {
	Collection<Double> iterable = Collections.emptySet();
	assertThat(ImmutableDoubleArray.copyOf(iterable)).isSameInstanceAs(ImmutableDoubleArray.of());
	}

	public void testCopyOf_collection_nonempty() {
	List<Double> list = Arrays.asList(0.0, 1.0, 3.0);
	ImmutableDoubleArray iia = ImmutableDoubleArray.copyOf(list);
	list.set(2, 2.0);
	assertThat(iia.asList()).containsExactly(0.0, 1.0, 3.0).inOrder();
	}

	public void testCopyOf_stream() {
	assertThat(ImmutableDoubleArray.copyOf(DoubleStream.empty()))
	.isSameInstanceAs(ImmutableDoubleArray.of());
	assertThat(ImmutableDoubleArray.copyOf(DoubleStream.of(0, 1, 3)).asList())
	.containsExactly(0.0, 1.0, 3.0)
	.inOrder();
	}

	public void testBuilder_presize_zero() {
	ImmutableDoubleArray.Builder builder = ImmutableDoubleArray.builder(0);
	builder.add(5.0);
	ImmutableDoubleArray array = builder.build();
	assertThat(array.asList()).containsExactly(5.0);
	}

	public void testBuilder_presize_negative() {
	try {
	ImmutableDoubleArray.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 (int i = 0; i < reduceIterationsIfGwt(100); i++) {
	ImmutableDoubleArray.Builder builder = ImmutableDoubleArray.builder(RANDOM.nextInt(20));
	AtomicInteger counter = new AtomicInteger(0);
	while (counter.get() < 1000) {
	BuilderOp op = BuilderOp.randomOp();
	op.doIt(builder, counter);
	}
	ImmutableDoubleArray iia = builder.build();
	for (int j = 0; j < iia.length(); j++) {
	assertThat(iia.get(j)).isEqualTo((double) j);
	}
	}
	}

	private enum BuilderOp {
	ADD_ONE {
	@Override
	void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
	builder.add(counter.getAndIncrement());
	}
	},
	ADD_ARRAY {
	@Override
	void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
	double[] array = new double[RANDOM.nextInt(10)];
	for (int i = 0; i < array.length; i++) {
	array[i] = counter.getAndIncrement();
	}
	builder.addAll(array);
	}
	},
	ADD_COLLECTION {
	@Override
	void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
	List<Double> list = new ArrayList<>();
	double num = RANDOM.nextInt(10);
	for (int i = 0; i < num; i++) {
	list.add((double) counter.getAndIncrement());
	}
	builder.addAll(list);
	}
	},
	ADD_ITERABLE {
	@Override
	void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
	List<Double> list = new ArrayList<>();
	double num = RANDOM.nextInt(10);
	for (int i = 0; i < num; i++) {
	list.add((double) counter.getAndIncrement());
	}
	builder.addAll(iterable(list));
	}
	},
	ADD_STREAM {
	@Override
	void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
	double[] array = new double[RANDOM.nextInt(10)];
	for (int i = 0; i < array.length; i++) {
	array[i] = counter.getAndIncrement();
	}
	builder.addAll(Arrays.stream(array));
	}
	},
	ADD_IIA {
	@Override
	void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
	double[] array = new double[RANDOM.nextInt(10)];
	for (int i = 0; i < array.length; i++) {
	array[i] = counter.getAndIncrement();
	}
	builder.addAll(ImmutableDoubleArray.copyOf(array));
	}
	},
	ADD_LARGER_ARRAY {
	@Override
	void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
	double[] array = new double[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(ImmutableDoubleArray.Builder builder, AtomicInteger counter);
	}

	private static final Random RANDOM = new Random(42);

	public void testLength() {
	assertThat(ImmutableDoubleArray.of().length()).isEqualTo(0);
	assertThat(ImmutableDoubleArray.of(0).length()).isEqualTo(1);
	assertThat(ImmutableDoubleArray.of(0, 1, 3).length()).isEqualTo(3);
	assertThat(ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).length()).isEqualTo(0);
	assertThat(ImmutableDoubleArray.of(0, 1, 3).subArray(1, 2).length()).isEqualTo(1);
	}

	public void testIsEmpty() {
	assertThat(ImmutableDoubleArray.of().isEmpty()).isTrue();
	assertThat(ImmutableDoubleArray.of(0).isEmpty()).isFalse();
	assertThat(ImmutableDoubleArray.of(0, 1, 3).isEmpty()).isFalse();
	assertThat(ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).isEmpty()).isTrue();
	assertThat(ImmutableDoubleArray.of(0, 1, 3).subArray(1, 2).isEmpty()).isFalse();
	}

	public void testGet_good() {
	ImmutableDoubleArray iia = ImmutableDoubleArray.of(0, 1, 3);
	assertThat(iia.get(0)).isEqualTo(0.0);
	assertThat(iia.get(2)).isEqualTo(3.0);
	assertThat(iia.subArray(1, 3).get(1)).isEqualTo(3.0);
	}

	public void testGet_bad() {
	ImmutableDoubleArray iia = ImmutableDoubleArray.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() {
	ImmutableDoubleArray iia = ImmutableDoubleArray.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(ImmutableDoubleArray.of(13).indexOf(13)).isEqualTo(0);
	assertThat(ImmutableDoubleArray.of().indexOf(21)).isEqualTo(-1);
	assertThat(iia.subArray(1, 5).indexOf(1)).isEqualTo(0);
	}

	public void testIndexOf_specialValues() {
	ImmutableDoubleArray iia =
	ImmutableDoubleArray.of(-0.0, 0.0, Double.MAX_VALUE, Double.POSITIVE_INFINITY, Double.NaN);
	assertThat(iia.indexOf(-0.0)).isEqualTo(0);
	assertThat(iia.indexOf(0.0)).isEqualTo(1);
	assertThat(iia.indexOf(Double.MAX_VALUE)).isEqualTo(2);
	assertThat(iia.indexOf(Double.POSITIVE_INFINITY)).isEqualTo(3);
	assertThat(iia.indexOf(Double.NaN)).isEqualTo(4);
	}

	public void testLastIndexOf() {
	ImmutableDoubleArray iia = ImmutableDoubleArray.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(ImmutableDoubleArray.of(13).lastIndexOf(13)).isEqualTo(0);
	assertThat(ImmutableDoubleArray.of().lastIndexOf(21)).isEqualTo(-1);
	assertThat(iia.subArray(1, 5).lastIndexOf(1)).isEqualTo(0);
	}

	public void testContains() {
	ImmutableDoubleArray iia = ImmutableDoubleArray.of(1, 1, 2, 3, 5, 8);
	assertThat(iia.contains(1)).isTrue();
	assertThat(iia.contains(8)).isTrue();
	assertThat(iia.contains(4)).isFalse();
	assertThat(ImmutableDoubleArray.of(13).contains(13)).isTrue();
	assertThat(ImmutableDoubleArray.of().contains(21)).isFalse();
	assertThat(iia.subArray(1, 5).contains(1)).isTrue();
	}

	public void testForEach() {
	ImmutableDoubleArray.of().forEach(i -> fail());
	ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).forEach(i -> fail());

	AtomicInteger count = new AtomicInteger(0);
	ImmutableDoubleArray.of(0, 1, 2, 3)
	.forEach(i -> assertThat(i).isEqualTo((double) count.getAndIncrement()));
	assertEquals(4, count.get());
	}

	public void testStream() {
	ImmutableDoubleArray.of().stream().forEach(i -> fail());
	ImmutableDoubleArray.of(0, 1, 3).subArray(1, 1).stream().forEach(i -> fail());
	assertThat(ImmutableDoubleArray.of(0, 1, 3).stream().toArray())
	.isEqualTo(new double[] {0, 1, 3});
	}

	public void testSubArray() {
	ImmutableDoubleArray iia0 = ImmutableDoubleArray.of();
	ImmutableDoubleArray iia1 = ImmutableDoubleArray.of(5);
	ImmutableDoubleArray iia3 = ImmutableDoubleArray.of(5, 25, 125);

	assertThat(iia0.subArray(0, 0)).isSameInstanceAs(ImmutableDoubleArray.of());
	assertThat(iia1.subArray(0, 0)).isSameInstanceAs(ImmutableDoubleArray.of());
	assertThat(iia1.subArray(1, 1)).isSameInstanceAs(ImmutableDoubleArray.of());
	assertThat(iia1.subArray(0, 1).asList()).containsExactly(5.0);
	assertThat(iia3.subArray(0, 2).asList()).containsExactly(5.0, 25.0).inOrder();
	assertThat(iia3.subArray(1, 3).asList()).containsExactly(25.0, 125.0).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(ImmutableDoubleArray.of())
	.addEqualityGroup(
	ImmutableDoubleArray.of(1, 2),
	reserialize(ImmutableDoubleArray.of(1, 2)),
	ImmutableDoubleArray.of(0, 1, 2, 3).subArray(1, 3))
	.addEqualityGroup(ImmutableDoubleArray.of(1, 3))
	.addEqualityGroup(ImmutableDoubleArray.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() {
	ImmutableDoubleArray iia = ImmutableDoubleArray.of(0, 1, 3);
	assertDoesntActuallyTrim(iia);
	assertDoesntActuallyTrim(iia.subArray(0, 3));
	assertActuallyTrims(iia.subArray(0, 2));
	assertActuallyTrims(iia.subArray(1, 3));

	ImmutableDoubleArray rightSized = ImmutableDoubleArray.builder(3).add(0).add(1).add(3).build();
	assertDoesntActuallyTrim(rightSized);

	ImmutableDoubleArray overSized = ImmutableDoubleArray.builder(3).add(0).add(1).build();
	assertActuallyTrims(overSized);

	ImmutableDoubleArray underSized = ImmutableDoubleArray.builder(2).add(0).add(1).add(3).build();
	assertActuallyTrims(underSized);
	}

	@GwtIncompatible // SerializableTester
	public void testSerialization() {
	assertThat(reserialize(ImmutableDoubleArray.of())).isSameInstanceAs(ImmutableDoubleArray.of());
	assertThat(reserialize(ImmutableDoubleArray.of(0, 1).subArray(1, 1)))
	.isSameInstanceAs(ImmutableDoubleArray.of());

	ImmutableDoubleArray iia = ImmutableDoubleArray.of(0, 1, 3, 6).subArray(1, 3);
	ImmutableDoubleArray iia2 = reserialize(iia);
	assertThat(iia2).isEqualTo(iia);
	assertDoesntActuallyTrim(iia2);
	}

	private static void assertActuallyTrims(ImmutableDoubleArray iia) {
	ImmutableDoubleArray trimmed = iia.trimmed();
	assertThat(trimmed).isNotSameInstanceAs(iia);

	// Yes, this is apparently how you check array equality in Truth
	assertThat(trimmed.toArray()).isEqualTo(iia.toArray());
	}

	private static void assertDoesntActuallyTrim(ImmutableDoubleArray iia) {
	assertThat(iia.trimmed()).isSameInstanceAs(iia);
	}

	@GwtIncompatible // suite
	public static Test suite() {
	List<ListTestSuiteBuilder<Double>> builders =
	ImmutableList.of(
	ListTestSuiteBuilder.using(new ImmutableDoubleArrayAsListGenerator())
	.named("ImmutableDoubleArray.asList"),
	ListTestSuiteBuilder.using(new ImmutableDoubleArrayHeadSubListAsListGenerator())
	.named("ImmutableDoubleArray.asList, head subList"),
	ListTestSuiteBuilder.using(new ImmutableDoubleArrayTailSubListAsListGenerator())
	.named("ImmutableDoubleArray.asList, tail subList"),
	ListTestSuiteBuilder.using(new ImmutableDoubleArrayMiddleSubListAsListGenerator())
	.named("ImmutableDoubleArray.asList, middle subList"));

	TestSuite suite = new TestSuite();
	for (ListTestSuiteBuilder<Double> 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());
	}
	suite.addTestSuite(ImmutableDoubleArrayTest.class);
	return suite;
	}

	@GwtIncompatible // used only from suite
	private static ImmutableDoubleArray makeArray(Double[] values) {
	return ImmutableDoubleArray.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 ImmutableDoubleArrayAsListGenerator extends TestDoubleListGenerator {
	@Override
	protected List<Double> create(Double[] elements) {
	return makeArray(elements).asList();
	}
	}

	@GwtIncompatible // used only from suite
	public static final class ImmutableDoubleArrayHeadSubListAsListGenerator
	extends TestDoubleListGenerator {
	@Override
	protected List<Double> create(Double[] elements) {
	Double[] suffix = {Double.MIN_VALUE, Double.MAX_VALUE};
	Double[] all = concat(elements, suffix);
	return makeArray(all).subArray(0, elements.length).asList();
	}
	}

	@GwtIncompatible // used only from suite
	public static final class ImmutableDoubleArrayTailSubListAsListGenerator
	extends TestDoubleListGenerator {
	@Override
	protected List<Double> create(Double[] elements) {
	Double[] prefix = {86.0, 99.0};
	Double[] all = concat(prefix, elements);
	return makeArray(all).subArray(2, elements.length + 2).asList();
	}
	}

	@GwtIncompatible // used only from suite
	public static final class ImmutableDoubleArrayMiddleSubListAsListGenerator
	extends TestDoubleListGenerator {
	@Override
	protected List<Double> create(Double[] elements) {
	Double[] prefix = {Double.MIN_VALUE, Double.MAX_VALUE};
	Double[] suffix = {86.0, 99.0};
	Double[] all = concat(concat(prefix, elements), suffix);
	return makeArray(all).subArray(2, elements.length + 2).asList();
	}
	}

	@GwtIncompatible // used only from suite
	private static Double[] concat(Double[] a, Double[] b) {
	return ObjectArrays.concat(a, b, Double.class);
	}

	@GwtIncompatible // used only from suite
	public abstract static class TestDoubleListGenerator implements TestListGenerator<Double> {
	@Override
	public SampleElements<Double> samples() {
	return new SampleDoubles();
	}

	@Override
	public List<Double> create(Object... elements) {
	Double[] array = new Double[elements.length];
	int i = 0;
	for (Object e : elements) {
	array[i++] = (Double) e;
	}
	return create(array);
	}

	/**
	* Creates a new collection containing the given elements; implement this method instead of
	* {@link #create(Object...)}.
	*/
	protected abstract List<Double> create(Double[] elements);

	@Override
	public Double[] createArray(int length) {
	return new Double[length];
	}

	/** Returns the original element list, unchanged. */
	@Override
	public List<Double> order(List<Double> insertionOrder) {
	return insertionOrder;
	}
	}

	@GwtIncompatible // used only from suite
	public static class SampleDoubles extends SampleElements<Double> {
	public SampleDoubles() {
	super(-0.0, Long.MAX_VALUE * 3.0, Double.MAX_VALUE, Double.POSITIVE_INFINITY, Double.NaN);
	}
	}
	}