Moves summary tests to the separate module and fix bug with empty summary generation for the Stats.of

settings.gradle

@@ -16,4 +16,5 @@ include 'utbot-instrumentation-tests'
 include 'utbot-summary'
 include 'utbot-gradle'
 include 'utbot-maven'
+include 'utbot-summary-tests'
 

utbot-analytics/build.gradle

@@ -5,7 +5,6 @@ configurations {
     mlmodels
 }
 
-
 def osName = System.getProperty('os.name').toLowerCase().split()[0]
 if (osName == "mac") osName = "macosx"
 String classifier = osName + "-x86_64"
@@ -49,11 +48,9 @@ dependencies {
 }
 
 test {
-
     useJUnitPlatform {
         excludeTags 'Summary'
     }
-
 }
 
 processResources {

utbot-sample/src/main/java/guava/examples/math/Stats.java

@@ -0,0 +1,116 @@
+/*
+ * 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 guava.examples.math;
+
+import java.io.Serializable;
+import java.util.Iterator;
+
+
+public final class Stats implements Serializable {
+
+  private final long count;
+  private final double mean;
+  private final double sumOfSquaresOfDeltas;
+  private final double min;
+  private final double max;
+
+  /**
+   * Internal constructor. Users should use {@link #ofIterable} or {@link StatsAccumulator#snapshot}.
+   *
+   * <p>To ensure that the created instance obeys its contract, the parameters should satisfy the
+   * following constraints. This is the callers responsibility and is not enforced here.
+   *
+   * <ul>
+   *   <li>If {@code count} is 0, {@code mean} may have any finite value (its only usage will be to
+   *       get multiplied by 0 to calculate the sum), and the other parameters may have any values
+   *       (they will not be used).
+   *   <li>If {@code count} is 1, {@code sumOfSquaresOfDeltas} must be exactly 0.0 or {@link
+   *       Double#NaN}.
+   * </ul>
+   */
+  Stats(long count, double mean, double sumOfSquaresOfDeltas, double min, double max) {
+    this.count = count;
+    this.mean = mean;
+    this.sumOfSquaresOfDeltas = sumOfSquaresOfDeltas;
+    this.min = min;
+    this.max = max;
+  }
+
+  /**
+   * Returns statistics over a dataset containing the given values.
+   *
+   * @param values a series of values, which will be converted to {@code double} values (this may
+   *     cause loss of precision)
+   */
+  public static Stats ofIterable(Iterable<? extends Number> values) {
+    StatsAccumulator accumulator = new StatsAccumulator();
+    accumulator.addAll(values);
+    return accumulator.snapshot();
+  }
+
+  /**
+   * Returns statistics over a dataset containing the given values.
+   *
+   * @param values a series of values, which will be converted to {@code double} values (this may
+   *     cause loss of precision)
+   */
+  public static Stats ofIterator(Iterator<? extends Number> values) {
+    StatsAccumulator accumulator = new StatsAccumulator();
+    accumulator.addAll(values);
+    return accumulator.snapshot();
+  }
+
+  /**
+   * Returns statistics over a dataset containing the given values.
+   *
+   * @param values a series of values
+   */
+  public static Stats ofDoubles(double... values) {
+    StatsAccumulator acummulator = new StatsAccumulator();
+    acummulator.addAll(values);
+    return acummulator.snapshot();
+  }
+
+  /**
+   * Returns statistics over a dataset containing the given values.
+   *
+   * @param values a series of values
+   */
+  public static Stats ofInts(int... values) {
+    StatsAccumulator acummulator = new StatsAccumulator();
+    acummulator.addAll(values);
+    return acummulator.snapshot();
+  }
+
+  /**
+   * Returns statistics over a dataset containing the given values.
+   *
+   * @param values a series of values, which will be converted to {@code double} values (this may
+   *     cause loss of precision for longs of magnitude over 2^53 (slightly over 9e15))
+   */
+  public static Stats ofLongs(long... values) {
+    StatsAccumulator acummulator = new StatsAccumulator();
+    acummulator.addAll(values);
+    return acummulator.snapshot();
+  }
+
+  /** Returns the number of values. */
+  public long count() {
+    return count;
+  }
+
+
+  private static final long serialVersionUID = 0;
+}

utbot-sample/src/main/java/guava/examples/math/StatsAccumulator.java

@@ -0,0 +1,159 @@
+/*
+ * 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 guava.examples.math;
+
+import java.util.Iterator;
+
+import static java.lang.Double.*;
+
+public final class StatsAccumulator {
+
+  // These fields must satisfy the requirements of Stats' constructor as well as those of the stat
+  // methods of this class.
+  private long count = 0;
+  private double mean = 0.0; // any finite value will do, we only use it to multiply by zero for sum
+  private double sumOfSquaresOfDeltas = 0.0;
+  private double min = NaN; // any value will do
+  private double max = NaN; // any value will do
+
+  /** Adds the given value to the dataset. */
+  public void add(double value) {
+    if (count == 0) {
+      count = 1;
+      mean = value;
+      min = value;
+      max = value;
+      if (!isFinite(value)) {
+        sumOfSquaresOfDeltas = NaN;
+      }
+    } else {
+      count++;
+      if (isFinite(value) && isFinite(mean)) {
+        // Art of Computer Programming vol. 2, Knuth, 4.2.2, (15) and (16)
+        double delta = value - mean;
+        mean += delta / count;
+        sumOfSquaresOfDeltas += delta * (value - mean);
+      } else {
+        mean = calculateNewMeanNonFinite(mean, value);
+        sumOfSquaresOfDeltas = NaN;
+      }
+      min = Math.min(min, value);
+      max = Math.max(max, value);
+    }
+  }
+
+  /**
+   * Adds the given values to the dataset.
+   *
+   * @param values a series of values, which will be converted to {@code double} values (this may
+   *     cause loss of precision)
+   */
+  public void addAll(Iterable<? extends Number> values) {
+    for (Number value : values) {
+      add(value.doubleValue());
+    }
+  }
+
+  /**
+   * Adds the given values to the dataset.
+   *
+   * @param values a series of values, which will be converted to {@code double} values (this may
+   *     cause loss of precision)
+   */
+  public void addAll(Iterator<? extends Number> values) {
+    while (values.hasNext()) {
+      add(values.next().doubleValue());
+    }
+  }
+
+  /**
+   * Adds the given values to the dataset.
+   *
+   * @param values a series of values
+   */
+  public void addAll(double... values) {
+    for (double value : values) {
+      add(value);
+    }
+  }
+
+  /**
+   * Adds the given values to the dataset.
+   *
+   * @param values a series of values
+   */
+  public void addAll(int... values) {
+    for (int value : values) {
+      add(value);
+    }
+  }
+
+  /**
+   * Adds the given values to the dataset.
+   *
+   * @param values a series of values, which will be converted to {@code double} values (this may
+   *     cause loss of precision for longs of magnitude over 2^53 (slightly over 9e15))
+   */
+  public void addAll(long... values) {
+    for (long value : values) {
+      add(value);
+    }
+  }
+
+  /** Returns an immutable snapshot of the current statistics. */
+  public Stats snapshot() {
+    return new Stats(count, mean, sumOfSquaresOfDeltas, min, max);
+  }
+
+  /** Returns the number of values. */
+  public long count() {
+    return count;
+  }
+
+  /**
+   * Calculates the new value for the accumulated mean when a value is added, in the case where at
+   * least one of the previous mean and the value is non-finite.
+   */
+  static double calculateNewMeanNonFinite(double previousMean, double value) {
+    /*
+     * Desired behaviour is to match the results of applying the naive mean formula. In particular,
+     * the update formula can subtract infinities in cases where the naive formula would add them.
+     *
+     * Consequently:
+     * 1. If the previous mean is finite and the new value is non-finite then the new mean is that
+     *    value (whether it is NaN or infinity).
+     * 2. If the new value is finite and the previous mean is non-finite then the mean is unchanged
+     *    (whether it is NaN or infinity).
+     * 3. If both the previous mean and the new value are non-finite and...
+     * 3a. ...either or both is NaN (so mean != value) then the new mean is NaN.
+     * 3b. ...they are both the same infinities (so mean == value) then the mean is unchanged.
+     * 3c. ...they are different infinities (so mean != value) then the new mean is NaN.
+     */
+    if (isFinite(previousMean)) {
+      // This is case 1.
+      return value;
+    } else if (isFinite(value) || previousMean == value) {
+      // This is case 2. or 3b.
+      return previousMean;
+    } else {
+      // This is case 3a. or 3c.
+      return NaN;
+    }
+  }
+
+  public static boolean isFinite(double value) {
+    return NEGATIVE_INFINITY < value && value < POSITIVE_INFINITY;
+  }
+}

utbot-summary-tests/build.gradle

@@ -0,0 +1,17 @@
+apply from: "${parent.projectDir}/gradle/include/jvm-project.gradle"
+apply plugin: "java"
+
+evaluationDependsOn(':utbot-framework')
+compileTestJava.dependsOn tasks.getByPath(':utbot-framework:testClasses')
+
+dependencies {
+    implementation(project(":utbot-framework"))
+    implementation(project(':utbot-instrumentation'))
+    testImplementation project(':utbot-sample')
+    testImplementation group: 'junit', name: 'junit', version: junit4_version
+    testCompile project(':utbot-framework').sourceSets.test.output
+}
+
+test {
+    useJUnitPlatform()
+}