Improved tuple unit tests

Author: lrhodes

src/main/java/com/yahoo/sketches/tuple/DirectArrayOfDoublesQuickSelectSketchR.java

@@ -6,11 +6,6 @@
 
 final class DirectArrayOfDoublesQuickSelectSketchR extends DirectArrayOfDoublesQuickSelectSketch {
 
-  DirectArrayOfDoublesQuickSelectSketchR(final int nomEntries, final int lgResizeFactor,
-      final float samplingProbability, final int numValues, final long seed, final WritableMemory dstMem) {
-    super(nomEntries, lgResizeFactor, samplingProbability, numValues, seed, dstMem);
-  }
-
   DirectArrayOfDoublesQuickSelectSketchR(final Memory mem, final long seed) {
     super((WritableMemory) mem, seed);
   }

src/main/java/com/yahoo/sketches/tuple/DirectArrayOfDoublesUnionR.java

@@ -5,11 +5,6 @@
 
 final class DirectArrayOfDoublesUnionR extends DirectArrayOfDoublesUnion {
 
-  DirectArrayOfDoublesUnionR(final int nomEntries, final int numValues, final long seed,
-      final WritableMemory dstMem) {
-    super(nomEntries, numValues, seed, dstMem);
-  }
-
   /**
    * Wraps the given Memory.
    * @param mem <a href="{@docRoot}/resources/dictionary.html#mem">See Memory</a>

src/test/java/com/yahoo/sketches/tuple/ArrayOfDoublesUnionTest.java

@@ -42,7 +42,17 @@ public void heapExactMode() {
     Assert.assertEquals(values[0][0], 3.0);
     Assert.assertEquals(values[1][0], 3.0);
     Assert.assertEquals(values[2][0], 3.0);
-  
+
+    WritableMemory wmem = WritableMemory.wrap(union.toByteArray());
+    ArrayOfDoublesUnion wrappedUnion = ArrayOfDoublesSketches.wrapUnion(wmem);
+    result = wrappedUnion.getResult();
+    Assert.assertEquals(result.getEstimate(), 3.0);
+    values = result.getValues();
+    Assert.assertEquals(values[0][0], 3.0);
+    Assert.assertEquals(values[1][0], 3.0);
+    Assert.assertEquals(values[2][0], 3.0);
+
+
     union.reset();
     result = union.getResult();
     Assert.assertTrue(result.isEmpty());
@@ -57,11 +67,15 @@ public void heapExactMode() {
   public void heapEstimationMode() {
     int key = 0;
     ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
-    for (int i = 0; i < 8192; i++) sketch1.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch1.update(key++, new double[] {1.0});
+    }
 
     key -= 4096; // overlap half of the entries
     ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
-    for (int i = 0; i < 8192; i++) sketch2.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch2.update(key++, new double[] {1.0});
+    }
 
     ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
     union.update(sketch1);
@@ -70,7 +84,7 @@ public void heapEstimationMode() {
     Assert.assertFalse(result.isEmpty());
     Assert.assertTrue(result.isEstimationMode());
     Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
-  
+
     union.reset();
     result = union.getResult();
     Assert.assertTrue(result.isEmpty());
@@ -85,11 +99,15 @@ public void heapEstimationMode() {
   public void heapEstimationModeFullOverlapTwoValuesAndDownsizing() {
     int key = 0;
     ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build();
-    for (int i = 0; i < 8192; i++) sketch1.update(key++, new double[] {1.0, 2.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch1.update(key++, new double[] {1.0, 2.0});
+    }
 
     key = 0; // full overlap
     ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setNumberOfValues(2).build();
-    for (int i = 0; i < 8192; i++) sketch2.update(key++, new double[] {1.0, 2.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch2.update(key++, new double[] {1.0, 2.0});
+    }
 
     ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().setNumberOfValues(2).setNominalEntries(1024).buildUnion();
     union.update(sketch1);
@@ -111,11 +129,15 @@ public void heapEstimationModeFullOverlapTwoValuesAndDownsizing() {
   public void heapMixedMode() {
     int key = 0;
     ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
-    for (int i = 0; i < 1000; i++) sketch1.update(key++, new double[] {1.0});
+    for (int i = 0; i < 1000; i++) {
+      sketch1.update(key++, new double[] {1.0});
+    }
 
     key -= 500; // overlap half of the entries
     ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSamplingProbability(0.2f).build();
-    for (int i = 0; i < 20000; i++) sketch2.update(key++, new double[] {1.0});
+    for (int i = 0; i < 20000; i++) {
+      sketch2.update(key++, new double[] {1.0});
+    }
 
     ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion();
     union.update(sketch1);
@@ -130,11 +152,15 @@ public void heapMixedMode() {
   public void heapSerializeDeserialize() {
     int key = 0;
     ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build();
-    for (int i = 0; i < 8192; i++) sketch1.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch1.update(key++, new double[] {1.0});
+    }
 
     key -= 4096; // overlap half of the entries
     ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build();
-    for (int i = 0; i < 8192; i++) sketch2.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch2.update(key++, new double[] {1.0});
+    }
 
     ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion();
     union1.update(sketch1);
@@ -143,7 +169,7 @@ public void heapSerializeDeserialize() {
     ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.heapify(Memory.wrap(union1.toByteArray()));
     ArrayOfDoublesCompactSketch result = union2.getResult();
     Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
-  
+
     union2.reset();
     result = union2.getResult();
     Assert.assertTrue(result.isEmpty());
@@ -153,7 +179,9 @@ public void heapSerializeDeserialize() {
     Assert.assertEquals(result.getLowerBound(1), 0.0);
     Assert.assertEquals(result.getTheta(), 1.0);
     double[][] values = result.getValues();
-    for (int i = 0; i < values.length; i++) Assert.assertEquals(values[i][0], 2.0);
+    for (int i = 0; i < values.length; i++) {
+      Assert.assertEquals(values[i][0], 2.0);
+    }
   }
 
   @Test
@@ -162,7 +190,7 @@ public void heapDeserializeV0_9_1() throws Exception {
     ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.heapify(Memory.wrap(bytes));
     ArrayOfDoublesCompactSketch result = union2.getResult();
     Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
-  
+
     union2.reset();
     result = union2.getResult();
     Assert.assertTrue(result.isEmpty());
@@ -172,19 +200,25 @@ public void heapDeserializeV0_9_1() throws Exception {
     Assert.assertEquals(result.getLowerBound(1), 0.0);
     Assert.assertEquals(result.getTheta(), 1.0);
     double[][] values = result.getValues();
-    for (int i = 0; i < values.length; i++) Assert.assertEquals(values[i][0], 2.0);
+    for (int i = 0; i < values.length; i++) {
+      Assert.assertEquals(values[i][0], 2.0);
+    }
   }
 
   @Test
   public void heapSerializeDeserializeWithSeed() {
     long seed = 1;
     int key = 0;
     ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build();
-    for (int i = 0; i < 8192; i++) sketch1.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch1.update(key++, new double[] {1.0});
+    }
 
     key -= 4096; // overlap half of the entries
     ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed).build();
-    for (int i = 0; i < 8192; i++) sketch2.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch2.update(key++, new double[] {1.0});
+    }
 
     ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().setSeed(seed).buildUnion();
     union1.update(sketch1);
@@ -200,12 +234,16 @@ public void directSerializeDeserialize() {
     int key = 0;
     ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(
         WritableMemory.wrap(new byte[1000000]));
-    for (int i = 0; i < 8192; i++) sketch1.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch1.update(key++, new double[] {1.0});
+    }
 
     key -= 4096; // overlap half of the entries
     ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(
         WritableMemory.wrap(new byte[1000000]));
-    for (int i = 0; i < 8192; i++) sketch2.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch2.update(key++, new double[] {1.0});
+    }
 
     ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().buildUnion(
         WritableMemory.wrap(new byte[1000000]));
@@ -215,7 +253,7 @@ public void directSerializeDeserialize() {
     ArrayOfDoublesUnion union2 = ArrayOfDoublesUnion.wrap(WritableMemory.wrap(union1.toByteArray()));
     ArrayOfDoublesCompactSketch result = union2.getResult(WritableMemory.wrap(new byte[1000000]));
     Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
-  
+
     union2.reset();
     result = union2.getResult();
     Assert.assertTrue(result.isEmpty());
@@ -225,7 +263,9 @@ public void directSerializeDeserialize() {
     Assert.assertEquals(result.getLowerBound(1), 0.0);
     Assert.assertEquals(result.getTheta(), 1.0);
     double[][] values = result.getValues();
-    for (int i = 0; i < values.length; i++) Assert.assertEquals(values[i][0], 2.0);
+    for (int i = 0; i < values.length; i++) {
+      Assert.assertEquals(values[i][0], 2.0);
+    }
   }
 
   @Test
@@ -234,12 +274,16 @@ public void directSerializeDeserializeWithSeed() {
     int key = 0;
     ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed)
         .build(WritableMemory.wrap(new byte[1000000]));
-    for (int i = 0; i < 8192; i++) sketch1.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch1.update(key++, new double[] {1.0});
+    }
 
     key -= 4096; // overlap half of the entries
     ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().setSeed(seed)
         .build(WritableMemory.wrap(new byte[1000000]));
-    for (int i = 0; i < 8192; i++) sketch2.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch2.update(key++, new double[] {1.0});
+    }
 
     ArrayOfDoublesUnion union1 = new ArrayOfDoublesSetOperationBuilder().setSeed(seed)
         .buildUnion(WritableMemory.wrap(new byte[1000000]));
@@ -275,7 +319,7 @@ public void directExactMode() {
     Assert.assertEquals(values[0][0], 3.0);
     Assert.assertEquals(values[1][0], 3.0);
     Assert.assertEquals(values[2][0], 3.0);
-  
+
     union.reset();
     result = union.getResult();
     Assert.assertTrue(result.isEmpty());
@@ -290,18 +334,22 @@ public void directExactMode() {
   public void directEstimationMode() {
     int key = 0;
     ArrayOfDoublesUpdatableSketch sketch1 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
-    for (int i = 0; i < 8192; i++) sketch1.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch1.update(key++, new double[] {1.0});
+    }
 
     key -= 4096; // overlap half of the entries
     ArrayOfDoublesUpdatableSketch sketch2 = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
-    for (int i = 0; i < 8192; i++) sketch2.update(key++, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      sketch2.update(key++, new double[] {1.0});
+    }
 
     ArrayOfDoublesUnion union = new ArrayOfDoublesSetOperationBuilder().buildUnion(WritableMemory.wrap(new byte[1000000]));
     union.update(sketch1);
     union.update(sketch2);
     ArrayOfDoublesCompactSketch result = union.getResult(WritableMemory.wrap(new byte[1000000]));
     Assert.assertEquals(result.getEstimate(), 12288.0, 12288 * 0.01);
-  
+
     union.reset();
     result = union.getResult();
     Assert.assertTrue(result.isEmpty());

src/test/java/com/yahoo/sketches/tuple/DirectArrayOfDoublesCompactSketchTest.java

@@ -4,6 +4,8 @@
  */
 package com.yahoo.sketches.tuple;
 
+import static com.yahoo.sketches.Util.DEFAULT_UPDATE_SEED;
+
 import org.testng.Assert;
 import org.testng.annotations.Test;
 
@@ -14,7 +16,8 @@ public class DirectArrayOfDoublesCompactSketchTest {
 
   @Test
   public void emptyFromQuickSelectSketch() {
-    ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    ArrayOfDoublesUpdatableSketch us =
+        new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
     ArrayOfDoublesCompactSketch sketch = us.compact(WritableMemory.wrap(new byte[1000000]));
     Assert.assertTrue(sketch.isEmpty());
     Assert.assertFalse(sketch.isEstimationMode());
@@ -34,7 +37,8 @@ public void emptyFromQuickSelectSketch() {
 
   @Test
   public void exactModeFromQuickSelectSketch() {
-    ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
+    ArrayOfDoublesUpdatableSketch us =
+        new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
     us.update(1, new double[] {1.0});
     us.update(2, new double[] {1.0});
     us.update(3, new double[] {1.0});
@@ -50,9 +54,12 @@ public void exactModeFromQuickSelectSketch() {
     Assert.assertEquals(sketch.getRetainedEntries(), 3);
     Assert.assertEquals(sketch.getThetaLong(), Long.MAX_VALUE);
     Assert.assertEquals(sketch.getTheta(), 1.0);
+    Assert.assertEquals(sketch.getSeedHash(), Util.computeSeedHash(DEFAULT_UPDATE_SEED));
     double[][] values = sketch.getValues();
     Assert.assertEquals(values.length, 3);
-    for (double[] array: values) Assert.assertEquals(array[0], 2.0);
+    for (double[] array: values) {
+      Assert.assertEquals(array[0], 2.0);
+    }
   }
 
   @Test
@@ -73,13 +80,17 @@ public void serializeDeserializeSmallExact() {
     Assert.assertEquals(sketch2.getTheta(), 1.0);
     double[][] values = sketch2.getValues();
     Assert.assertEquals(values.length, 3);
-    for (double[] array: values) Assert.assertEquals(array[0], 1.0);
+    for (double[] array: values) {
+      Assert.assertEquals(array[0], 1.0);
+    }
   }
 
   @Test
   public void serializeDeserializeEstimation() {
     ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
-    for (int i = 0; i < 8192; i++) us.update(i, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      us.update(i, new double[] {1.0});
+    }
     ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.wrap(new byte[1000000]));
     ArrayOfDoublesSketch sketch2 = ArrayOfDoublesSketches.wrapSketch(WritableMemory.wrap(sketch1.toByteArray()));
     Assert.assertFalse(sketch2.isEmpty());
@@ -91,7 +102,9 @@ public void serializeDeserializeEstimation() {
   @Test(expectedExceptions = SketchesArgumentException.class)
   public void deserializeWithWrongSeed() {
     ArrayOfDoublesUpdatableSketch us = new ArrayOfDoublesUpdatableSketchBuilder().build(WritableMemory.wrap(new byte[1000000]));
-    for (int i = 0; i < 8192; i++) us.update(i, new double[] {1.0});
+    for (int i = 0; i < 8192; i++) {
+      us.update(i, new double[] {1.0});
+    }
     ArrayOfDoublesCompactSketch sketch1 = us.compact(WritableMemory.wrap(new byte[1000000]));
     ArrayOfDoublesSketches.wrapSketch(WritableMemory.wrap(sketch1.toByteArray()), 123);
   }