1 files changed, 189 insertions, 0 deletions
diff --git a/api/src/test/java/io/opencensus/metrics/SummaryTest.java b/api/src/test/java/io/opencensus/metrics/SummaryTest.java
new file mode 100644
index 00000000..0b70d94e
--- /dev/null
+++ b/api/src/test/java/io/opencensus/metrics/SummaryTest.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright 2018, OpenCensus 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 io.opencensus.metrics;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.testing.EqualsTester;
+import io.opencensus.metrics.Summary.Snapshot;
+import io.opencensus.metrics.Summary.Snapshot.ValueAtPercentile;
+import java.util.Collections;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link Summary}. */
+@RunWith(JUnit4.class)
+public class SummaryTest {
+
+  @Rule public final ExpectedException thrown = ExpectedException.none();
+  private static final double TOLERANCE = 1e-6;
+
+  @Test
+  public void createAndGet_ValueAtPercentile() {
+    ValueAtPercentile valueAtPercentile = ValueAtPercentile.create(99.5, 10.2);
+    assertThat(valueAtPercentile.getPercentile()).isWithin(TOLERANCE).of(99.5);
+    assertThat(valueAtPercentile.getValue()).isWithin(TOLERANCE).of(10.2);
+  }
+
+  @Test
+  public void createValueAtPercentile_InvalidValueAtPercentileInterval() {
+    thrown.expect(IllegalArgumentException.class);
+    thrown.expectMessage("percentile must be in the interval (0.0, 100.0]");
+    ValueAtPercentile.create(100.1, 10.2);
+  }
+
+  @Test
+  public void createValueAtPercentile_NegativeValue() {
+    thrown.expect(IllegalArgumentException.class);
+    thrown.expectMessage("value must be non-negative");
+    ValueAtPercentile.create(99.5, -10.2);
+  }
+
+  @Test
+  public void createAndGet_Snapshot() {
+    Snapshot snapshot =
+        Snapshot.create(
+            10L, 87.07, Collections.singletonList(ValueAtPercentile.create(99.5, 10.2)));
+    assertThat(snapshot.getCount()).isEqualTo(10);
+    assertThat(snapshot.getSum()).isWithin(TOLERANCE).of(87.07);
+    assertThat(snapshot.getValueAtPercentiles())
+        .containsExactly(ValueAtPercentile.create(99.5, 10.2));
+  }
+
+  @Test
+  public void createAndGet_Snapshot_WithNullCountAndSum() {
+    Snapshot snapshot =
+        Snapshot.create(
+            null, null, Collections.singletonList(ValueAtPercentile.create(99.5, 10.2)));
+    assertThat(snapshot.getCount()).isNull();
+    assertThat(snapshot.getSum()).isNull();
+    assertThat(snapshot.getValueAtPercentiles())
+        .containsExactly(ValueAtPercentile.create(99.5, 10.2));
+  }
+
+  @Test
+  public void createSnapshot_NegativeCount() {
+    thrown.expect(IllegalArgumentException.class);
+    thrown.expectMessage("count must be non-negative");
+    Snapshot.create(-10L, 87.07, Collections.singletonList(ValueAtPercentile.create(99.5, 10.2)));
+  }
+
+  @Test
+  public void createSnapshot_NegativeSum() {
+    thrown.expect(IllegalArgumentException.class);
+    thrown.expectMessage("sum must be non-negative");
+    Snapshot.create(10L, -87.07, Collections.singletonList(ValueAtPercentile.create(99.5, 10.2)));
+  }
+
+  @Test
+  public void createSnapshot_ZeroCountAndNonZeroSum() {
+    thrown.expect(IllegalArgumentException.class);
+    thrown.expectMessage("sum must be 0 if count is 0");
+    Snapshot.create(0L, 87.07, Collections.singletonList(ValueAtPercentile.create(99.5, 10.2)));
+  }
+
+  @Test
+  public void createSnapshot_NullValueAtPercentilesList() {
+    thrown.expect(NullPointerException.class);
+    thrown.expectMessage("valueAtPercentiles");
+    Snapshot.create(10L, 87.07, null);
+  }
+
+  @Test
+  public void createSnapshot_OneNullValueAtPercentile() {
+    thrown.expect(NullPointerException.class);
+    thrown.expectMessage("value in valueAtPercentiles");
+    Snapshot.create(10L, 87.07, Collections.<ValueAtPercentile>singletonList(null));
+  }
+
+  @Test
+  public void createAndGet_Summary() {
+    Snapshot snapshot =
+        Snapshot.create(
+            10L, 87.07, Collections.singletonList(ValueAtPercentile.create(99.5, 10.2)));
+    Summary summary = Summary.create(10L, 6.6, snapshot);
+    assertThat(summary.getCount()).isEqualTo(10);
+    assertThat(summary.getSum()).isWithin(TOLERANCE).of(6.6);
+    assertThat(summary.getSnapshot()).isEqualTo(snapshot);
+  }
+
+  @Test
+  public void createSummary_NegativeCount() {
+    thrown.expect(IllegalArgumentException.class);
+    thrown.expectMessage("count must be non-negative");
+    Summary.create(
+        -10L, 6.6, Snapshot.create(null, null, Collections.<ValueAtPercentile>emptyList()));
+  }
+
+  @Test
+  public void createSummary_NegativeSum() {
+    thrown.expect(IllegalArgumentException.class);
+    thrown.expectMessage("sum must be non-negative");
+    Summary.create(
+        10L, -6.6, Snapshot.create(null, null, Collections.<ValueAtPercentile>emptyList()));
+  }
+
+  @Test
+  public void createSummary_ZeroCountAndNonZeroSum() {
+    thrown.expect(IllegalArgumentException.class);
+    thrown.expectMessage("sum must be 0 if count is 0");
+    Summary.create(
+        0L, 6.6, Snapshot.create(null, null, Collections.<ValueAtPercentile>emptyList()));
+  }
+
+  @Test
+  public void createSummary_NullSnapshot() {
+    thrown.expect(NullPointerException.class);
+    thrown.expectMessage("snapshot");
+    Summary.create(10L, 6.6, null);
+  }
+
+  @Test
+  public void testEquals() {
+    new EqualsTester()
+        .addEqualityGroup(
+            Summary.create(
+                10L,
+                10.0,
+                Snapshot.create(
+                    10L, 87.07, Collections.singletonList(ValueAtPercentile.create(99.5, 10.2)))),
+            Summary.create(
+                10L,
+                10.0,
+                Snapshot.create(
+                    10L, 87.07, Collections.singletonList(ValueAtPercentile.create(99.5, 10.2)))))
+        .addEqualityGroup(
+            Summary.create(
+                7L,
+                10.0,
+                Snapshot.create(
+                    10L, 87.07, Collections.singletonList(ValueAtPercentile.create(99.5, 10.2)))))
+        .addEqualityGroup(
+            Summary.create(
+                10L,
+                7.0,
+                Snapshot.create(
+                    10L, 87.07, Collections.singletonList(ValueAtPercentile.create(99.5, 10.2)))))
+        .addEqualityGroup(
+            Summary.create(
+                10L, 10.0, Snapshot.create(null, null, Collections.<ValueAtPercentile>emptyList())))
+        .testEquals();
+  }
+}