Refactor test framework for better verification

Code review was done in master with change-id:
I9f05df85f1becd95283d4b1db6dd6bc3345a12f1

Change-Id: Iba6ef7d3df5de99277727652436baab836448b97
diff --git a/apps/CtsVerifier/src/com/android/cts/verifier/sensors/GyroscopeMeasurementTestActivity.java b/apps/CtsVerifier/src/com/android/cts/verifier/sensors/GyroscopeMeasurementTestActivity.java
index df15b66..4bcdd56 100644
--- a/apps/CtsVerifier/src/com/android/cts/verifier/sensors/GyroscopeMeasurementTestActivity.java
+++ b/apps/CtsVerifier/src/com/android/cts/verifier/sensors/GyroscopeMeasurementTestActivity.java
@@ -89,7 +89,7 @@
     private void verifyMeasurements(
             String scenarioInstructions,
             boolean usePortraitOrientation,
-            double ... expectations) throws Throwable {
+            int ... expectations) throws Throwable {
         final String orientation = usePortraitOrientation ? "Portrait": "Landscape";
         appendText(String.format("\n[Device orientation]: %s", orientation));
         appendText(String.format("Press 'Next' and %s.", scenarioInstructions));
diff --git a/apps/CtsVerifier/src/com/android/cts/verifier/sensors/MagneticFieldMeasurementTestActivity.java b/apps/CtsVerifier/src/com/android/cts/verifier/sensors/MagneticFieldMeasurementTestActivity.java
index 713710d..ffed1ab 100644
--- a/apps/CtsVerifier/src/com/android/cts/verifier/sensors/MagneticFieldMeasurementTestActivity.java
+++ b/apps/CtsVerifier/src/com/android/cts/verifier/sensors/MagneticFieldMeasurementTestActivity.java
@@ -21,7 +21,7 @@
 import android.hardware.SensorEvent;
 import android.hardware.SensorManager;
 import android.hardware.cts.helpers.SensorManagerTestVerifier;
-import android.hardware.cts.helpers.sensorTestOperations.VerifyNormOperation;
+import android.hardware.cts.helpers.sensorTestOperations.VerifyMagnitudeOperation;
 import android.hardware.cts.helpers.sensorTestOperations.VerifyStandardDeviationOperation;
 
 /**
@@ -91,7 +91,7 @@
                 (SensorManager.MAGNETIC_FIELD_EARTH_MAX + SensorManager.MAGNETIC_FIELD_EARTH_MIN) / 2;
         float magneticFieldEarthThreshold =
                 expectedMagneticFieldEarth - SensorManager.MAGNETIC_FIELD_EARTH_MIN;
-        VerifyNormOperation verifyNorm = new VerifyNormOperation(
+        VerifyMagnitudeOperation verifyNorm = new VerifyMagnitudeOperation(
                 this.getApplicationContext(),
                 Sensor.TYPE_MAGNETIC_FIELD,
                 SensorManager.SENSOR_DELAY_FASTEST,
diff --git a/tests/tests/hardware/src/android/hardware/cts/SensorMeasurementTests.java b/tests/tests/hardware/src/android/hardware/cts/SensorMeasurementTests.java
index ea025ba..859b26d 100644
--- a/tests/tests/hardware/src/android/hardware/cts/SensorMeasurementTests.java
+++ b/tests/tests/hardware/src/android/hardware/cts/SensorMeasurementTests.java
@@ -24,7 +24,7 @@
 
 import android.hardware.cts.helpers.SensorTestCase;
 
-import android.hardware.cts.helpers.sensorTestOperations.VerifyNormOperation;
+import android.hardware.cts.helpers.sensorTestOperations.VerifyMagnitudeOperation;
 import android.hardware.cts.helpers.sensorTestOperations.VerifyStandardDeviationOperation;
 
 /**
@@ -104,7 +104,7 @@
      * - the values sampled from the sensor
      */
     public void testEventNorm() throws Throwable {
-        VerifyNormOperation operation = new VerifyNormOperation(
+        VerifyMagnitudeOperation operation = new VerifyMagnitudeOperation(
                 this.getContext(),
                 mSensorType,
                 mSamplingRateInUs,
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/SensorCtsHelper.java b/tests/tests/hardware/src/android/hardware/cts/helpers/SensorCtsHelper.java
index c8733ba..9d860cd 100644
--- a/tests/tests/hardware/src/android/hardware/cts/helpers/SensorCtsHelper.java
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/SensorCtsHelper.java
@@ -16,65 +16,109 @@
 package android.hardware.cts.helpers;
 
 import android.content.Context;
-
 import android.hardware.Sensor;
 import android.hardware.SensorManager;
-
 import android.os.Environment;
-
 import android.util.Log;
 
 import java.io.DataOutputStream;
 import java.io.IOException;
-
 import java.text.SimpleDateFormat;
-
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
-
+import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 /**
  * Set of static helper methods for CTS tests.
  */
 public class SensorCtsHelper {
+
     /**
-     * This is an static class.
+     * Private constructor for static class.
      */
     private SensorCtsHelper() {}
 
-    public static <TValue extends Comparable> TValue get95PercentileValue(
+    /**
+     * Get the value of the 95th percentile using nearest rank algorithm.
+     *
+     * @throws IllegalArgumentException if the collection is null or empty
+     */
+    public static <TValue extends Comparable<? super TValue>> TValue get95PercentileValue(
             Collection<TValue> collection) {
         validateCollection(collection);
 
-        ArrayList<TValue> arrayCopy = new ArrayList<TValue>(collection);
+        List<TValue> arrayCopy = new ArrayList<TValue>(collection);
         Collections.sort(arrayCopy);
 
         // zero-based array index
-        int arrayIndex = (int)(arrayCopy.size() * 0.95) - 1;
-        if(arrayIndex < 0) {
-            arrayIndex = 0;
-        }
+        int arrayIndex = (int) Math.round(arrayCopy.size() * 0.95 + .5) - 1;
 
         return arrayCopy.get(arrayIndex);
     }
 
     /**
      * Calculates the mean for each of the values in the set of TestSensorEvents.
+     *
+     * @throws IllegalArgumentException if there are no events
      */
-    public static void getMeans(TestSensorEvent events[], double means[]) {
-        for(TestSensorEvent event : events) {
-            for(int i = 0; i < means.length; ++i) {
+    public static double[] getMeans(TestSensorEvent[] events) {
+        if (events.length == 0) {
+            throw new IllegalArgumentException("Events cannot be empty");
+        }
+
+        double[] means = new double[events[0].values.length];
+        for (TestSensorEvent event : events) {
+            for (int i = 0; i < means.length; i++) {
                 means[i] += event.values[i];
             }
         }
-        for(int i = 0; i < means.length; ++i) {
+        for (int i = 0; i < means.length; i++) {
             means[i] /= events.length;
         }
+        return means;
     }
 
+    /**
+     * Calculates the variance for each of the values in the set of TestSensorEvents.
+     *
+     * @throws IllegalArgumentException if there are no events
+     */
+    public static double[] getVariances(TestSensorEvent[] events) {
+        double[] means = getMeans(events);
+        double[] variances = new double[means.length];
+        for (int i = 0; i < means.length; i++) {
+            Collection<Double> squaredDiffs = new ArrayList<Double>(events.length);
+            for (TestSensorEvent event : events) {
+                double diff = event.values[i] - means[i];
+                squaredDiffs.add(diff * diff);
+            }
+            variances[i] = getMean(squaredDiffs);
+        }
+        return variances;
+    }
+
+    /**
+     * Calculates the standard deviation for each of the values in the set of TestSensorEvents.
+     *
+     * @throws IllegalArgumentException if there are no events
+     */
+    public static double[] getStandardDeviations(TestSensorEvent[] events) {
+        double[] variances = getVariances(events);
+        double[] stdDevs = new double[variances.length];
+        for (int i = 0; i < variances.length; i++) {
+            stdDevs[i] = Math.sqrt(variances[i]);
+        }
+        return stdDevs;
+    }
+
+    /**
+     * Calculate the mean of a collection.
+     *
+     * @throws IllegalArgumentException if the collection is null or empty
+     */
     public static <TValue extends Number> double getMean(Collection<TValue> collection) {
         validateCollection(collection);
 
@@ -85,6 +129,11 @@
         return sum / collection.size();
     }
 
+    /**
+     * Calculate the variance of a collection.
+     *
+     * @throws IllegalArgumentException if the collection is null or empty
+     */
     public static <TValue extends Number> double getVariance(Collection<TValue> collection) {
         validateCollection(collection);
 
@@ -95,58 +144,52 @@
             squaredDifferences.add(Math.pow(difference, 2));
         }
 
-        double variance = getMean(squaredDifferences);
-        return variance;
-    }
-
-    public static <TValue extends Number> double getStandardDeviation(Collection<TValue> collection) {
-        validateCollection(collection);
-
-        double variance = getVariance(collection);
-        return Math.sqrt(variance);
+        return getMean(squaredDifferences);
     }
 
     /**
-     * Gets the jitter values associated with a set of sensor events.
+     * Calculate the standard deviation of a collection.
      *
-     * @param events The events to use to obtain the jittering information.
-     * @param jitterValues The Collection that will contain the computed jitter values.
-     * @return The mean of the jitter Values.
+     * @throws IllegalArgumentException if the collection is null or empty
      */
-    public static double getJitterMean(TestSensorEvent events[], Collection<Double> jitterValues) {
-        ArrayList<Long> timestampDelayValues = new ArrayList<Long>();
-        double averageTimestampDelay = SensorCtsHelper.getAverageTimestampDelayWithValues(events,
-                timestampDelayValues);
-        for(long frequency : timestampDelayValues) {
-            jitterValues.add(Math.abs(averageTimestampDelay - frequency));
-        }
-
-        double jitterMean = SensorCtsHelper.getMean(timestampDelayValues);
-        return jitterMean;
+    public static <TValue extends Number> double getStandardDeviation(
+            Collection<TValue> collection) {
+        return Math.sqrt(getVariance(collection));
     }
 
     /**
-     * Gets the frequency values associated with a set of sensor events.
+     * Get a list containing the delay between sensor events.
      *
-     * @param events The events to use to obtain the frequency information.
-     * @param timestampDelayValues The Collection that will contain the computed frequency values.
-     * @return The mean of the frequency values.
+     * @param events The array of {@link TestSensorEvent}.
+     * @return A list containing the delay between sensor events in nanoseconds.
      */
-    public static double getAverageTimestampDelayWithValues(
-            TestSensorEvent events[],
-            Collection<Long> timestampDelayValues) {
-        for(int i = 1; i < events.length; ++i) {
-            long previousTimestamp = events[i-1].timestamp;
-            long timestamp = events[i].timestamp;
-            timestampDelayValues.add(timestamp - previousTimestamp);
+    public static List<Long> getTimestampDelayValues(TestSensorEvent[] events) {
+        if (events.length < 2) {
+            return new ArrayList<Long>();
         }
-
-        double timestampDelayMean = SensorCtsHelper.getMean(timestampDelayValues);
-        return timestampDelayMean;
+        List<Long> timestampDelayValues = new ArrayList<Long>(events.length - 1);
+        for (int i = 1; i < events.length; i++) {
+            timestampDelayValues.add(events[i].timestamp - events[i - 1].timestamp);
+        }
+        return timestampDelayValues;
     }
 
-    public static int getSecondsAsMicroSeconds(int seconds) {
-        return (int) TimeUnit.MICROSECONDS.convert(seconds, TimeUnit.SECONDS);
+    /**
+     * Get a list containing the jitter values for a collection of sensor events.
+     *
+     * @param events The array of {@link TestSensorEvent}.
+     * @return A list containing the jitter values between each event.
+     * @throws IllegalArgumentException if the number of events is less that 2.
+     */
+    public static List<Double> getJitterValues(TestSensorEvent[] events) {
+        List<Long> timestampDelayValues = getTimestampDelayValues(events);
+        double averageTimestampDelay = getMean(timestampDelayValues);
+
+        List<Double> jitterValues = new ArrayList<Double>(timestampDelayValues.size());
+        for (long timestampDelay : timestampDelayValues) {
+            jitterValues.add(Math.abs(timestampDelay - averageTimestampDelay));
+        }
+        return jitterValues;
     }
 
     /**
@@ -197,12 +240,11 @@
         return outputFile;
     }
 
+    /**
+     * Get the default sensor for a given type.
+     */
     public static Sensor getSensor(Context context, int sensorType) {
-        SensorManager sensorManager = (SensorManager)context.getSystemService(
-                Context.SENSOR_SERVICE);
-        if(sensorManager == null) {
-            throw new IllegalStateException("SensorService is not present in the system.");
-        }
+        SensorManager sensorManager = getSensorManager(context);
         Sensor sensor = sensorManager.getDefaultSensor(sensorType);
         if(sensor == null) {
             throw new SensorNotSupportedException(sensorType);
@@ -210,10 +252,48 @@
         return sensor;
     }
 
-    public static <TReference extends Number> double getFrequencyInHz(TReference samplingRateInUs) {
-        return 1000000000 / samplingRateInUs.doubleValue();
+    /**
+     * Get all the sensors for a given type.
+     */
+    public static List<Sensor> getSensors(Context context, int sensorType) {
+        SensorManager sensorManager = getSensorManager(context);
+        List<Sensor> sensors = sensorManager.getSensorList(sensorType);
+        if (sensors.size() == 0) {
+            throw new SensorNotSupportedException(sensorType);
+        }
+        return sensors;
     }
 
+    /**
+     * Convert a period to frequency in Hz.
+     */
+    public static <TValue extends Number> double getFrequency(TValue period, TimeUnit unit) {
+        return 1000000000 / (TimeUnit.NANOSECONDS.convert(1, unit) * period.doubleValue());
+    }
+
+    /**
+     * Convert a frequency in Hz into a period.
+     */
+    public static <TValue extends Number> double getPeriod(TValue frequency, TimeUnit unit) {
+        return 1000000000 / (TimeUnit.NANOSECONDS.convert(1, unit) * frequency.doubleValue());
+    }
+
+    /**
+     * Convert number of seconds to number of microseconds.
+     */
+    public static int getSecondsAsMicroSeconds(int seconds) {
+        return (int) TimeUnit.MICROSECONDS.convert(seconds, TimeUnit.SECONDS);
+    }
+
+    /**
+     * Format an assertion message.
+     *
+     * @param verificationName The verification name
+     * @param sensor The sensor under test
+     * @param format The additional format string, use "" if blank
+     * @param params The additional format params
+     * @return The formatted string.
+     */
     public static String formatAssertionMessage(
             String verificationName,
             Sensor sensor,
@@ -222,6 +302,16 @@
         return formatAssertionMessage(verificationName, null, sensor, format, params);
     }
 
+    /**
+     * Format an assertion message.
+     *
+     * @param verificationName The verification name
+     * @param test The test, optional
+     * @param sensor The sensor under test
+     * @param format The additional format string, use "" if blank
+     * @param params The additional format params
+     * @return The formatted string.
+     */
     public static String formatAssertionMessage(
             String verificationName,
             SensorTestOperation test,
@@ -239,8 +329,7 @@
             builder.append("| ");
         }
         // add context information
-        builder.append(
-                SensorTestInformation.getSensorName(sensor.getType()));
+        builder.append(SensorTestInformation.getSensorName(sensor.getType()));
         builder.append(", handle:");
         builder.append(sensor.getHandle());
         builder.append("| ");
@@ -251,11 +340,27 @@
     }
 
     /**
-     * Private helpers
+     * Validate that a collection is not null or empty.
+     *
+     * @throws IllegalStateException if collection is null or empty.
      */
-    private static void validateCollection(Collection collection) {
+    private static <T> void validateCollection(Collection<T> collection) {
         if(collection == null || collection.size() == 0) {
             throw new IllegalStateException("Collection cannot be null or empty");
         }
     }
+
+    /**
+     * Get the SensorManager.
+     *
+     * @throws IllegalStateException if the SensorManager is not present in the system.
+     */
+    private static SensorManager getSensorManager(Context context) {
+        SensorManager sensorManager = (SensorManager) context.getSystemService(
+                Context.SENSOR_SERVICE);
+        if(sensorManager == null) {
+            throw new IllegalStateException("SensorService is not present in the system.");
+        }
+        return sensorManager;
+    }
 }
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/SensorCtsHelperTest.java b/tests/tests/hardware/src/android/hardware/cts/helpers/SensorCtsHelperTest.java
new file mode 100644
index 0000000..ccfaf2a
--- /dev/null
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/SensorCtsHelperTest.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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 android.hardware.cts.helpers;
+
+import junit.framework.TestCase;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Unit tests for the {@link SensorCtsHelper} class.
+ */
+public class SensorCtsHelperTest extends TestCase {
+
+    /**
+     * Test {@link SensorCtsHelper#get95PercentileValue(Collection)}.
+     */
+    public void testGet95PercentileValue() {
+        Collection<Integer> values = new HashSet<Integer>();
+        for (int i = 0; i < 100; i++) {
+            values.add(i);
+        }
+        assertEquals(95, (int) SensorCtsHelper.get95PercentileValue(values));
+
+        values = new HashSet<Integer>();
+        for (int i = 0; i < 1000; i++) {
+            values.add(i);
+        }
+        assertEquals(950, (int) SensorCtsHelper.get95PercentileValue(values));
+
+        values = new HashSet<Integer>();
+        for (int i = 0; i < 100; i++) {
+            values.add(i * i);
+        }
+        assertEquals(95 * 95, (int) SensorCtsHelper.get95PercentileValue(values));
+    }
+
+    /**
+     * Test {@link SensorCtsHelper#getMeans(TestSensorEvent[])}.
+     */
+    public void testGetMeans() {
+        long[] timestamps = {0, 1, 2, 3, 4};
+
+        float[] values = {0, 1, 2, 3, 4};  // 2.0
+        double[] means = SensorCtsHelper.getMeans(getSensorEvents(timestamps, values));
+        assertEquals(1, means.length);
+        assertEquals(2.0, means[0], 0.00001);
+
+        float[] values1 = {0, 1, 2, 3, 4};  // 2.0
+        float[] values2 = {1, 2, 3, 4, 5};  // 3.0
+        float[] values3 = {0, 1, 4, 9, 16};  // 6.0
+        means = SensorCtsHelper.getMeans(
+                getSensorEvents(timestamps, values1, values2, values3));
+        assertEquals(3, means.length);
+        assertEquals(2.0, means[0], 0.00001);
+        assertEquals(3.0, means[1], 0.00001);
+        assertEquals(6.0, means[2], 0.00001);
+    }
+
+    /**
+     * Test {@link SensorCtsHelper#getVariances(TestSensorEvent[])}.
+     */
+    public void testGetVariences() {
+        long[] timestamps = {0, 1, 2, 3, 4};
+
+        float[] values = {0, 1, 2, 3, 4};  // 2.0
+        double[] variances = SensorCtsHelper.getVariances(getSensorEvents(timestamps, values));
+        assertEquals(1, variances.length);
+        assertEquals(2.0, variances[0], 0.00001);
+
+        float[] values1 = {0, 1, 2, 3, 4};  // 2.0
+        float[] values2 = {1, 2, 3, 4, 5};  // 2.0
+        float[] values3 = {0, 2, 4, 6, 8};  // 8.0
+        variances = SensorCtsHelper.getVariances(
+                getSensorEvents(timestamps, values1, values2, values3));
+        assertEquals(3, variances.length);
+        assertEquals(2.0, variances[0], 0.00001);
+        assertEquals(2.0, variances[1], 0.00001);
+        assertEquals(8.0, variances[2], 0.00001);
+    }
+
+    /**
+     * Test {@link SensorCtsHelper#getStandardDeviations(TestSensorEvent[])}.
+     */
+    public void testGetStandardDeviations() {
+        long[] timestamps = {0, 1, 2, 3, 4};
+
+        float[] values = {0, 1, 2, 3, 4};  // sqrt(2.0)
+        double[] stddev = SensorCtsHelper.getStandardDeviations(
+                getSensorEvents(timestamps, values));
+        assertEquals(1, stddev.length);
+        assertEquals(Math.sqrt(2.0), stddev[0], 0.00001);
+
+        float[] values1 = {0, 1, 2, 3, 4};  // sqrt(2.0)
+        float[] values2 = {1, 2, 3, 4, 5};  // sqrt(2.0)
+        float[] values3 = {0, 2, 4, 6, 8};  // sqrt(8.0)
+        stddev = SensorCtsHelper.getStandardDeviations(
+                getSensorEvents(timestamps, values1, values2, values3));
+        assertEquals(3, stddev.length);
+        assertEquals(Math.sqrt(2.0), stddev[0], 0.00001);
+        assertEquals(Math.sqrt(2.0), stddev[1], 0.00001);
+        assertEquals(Math.sqrt(8.0), stddev[2], 0.00001);
+    }
+
+    /**
+     * Test {@link SensorCtsHelper#getMean(Collection)}.
+     */
+    public void testGetMean() {
+        List<Integer> values = Arrays.asList(0, 1, 2, 3, 4);
+        double mean = SensorCtsHelper.getMean(values);
+        assertEquals(2.0, mean, 0.00001);
+
+        values = Arrays.asList(1, 2, 3, 4, 5);
+        mean = SensorCtsHelper.getMean(values);
+        assertEquals(3.0, mean, 0.00001);
+
+        values = Arrays.asList(0, 1, 4, 9, 16);
+        mean = SensorCtsHelper.getMean(values);
+        assertEquals(6.0, mean, 0.00001);
+    }
+
+    /**
+     * Test {@link SensorCtsHelper#getVariance(Collection)}.
+     */
+    public void testGetVariance() {
+        List<Integer> values = Arrays.asList(0, 1, 2, 3, 4);
+        double variance = SensorCtsHelper.getVariance(values);
+        assertEquals(2.0, variance, 0.00001);
+
+        values = Arrays.asList(1, 2, 3, 4, 5);
+        variance = SensorCtsHelper.getVariance(values);
+        assertEquals(2.0, variance, 0.00001);
+
+        values = Arrays.asList(0, 2, 4, 6, 8);
+        variance = SensorCtsHelper.getVariance(values);
+        assertEquals(8.0, variance, 0.00001);
+    }
+
+    /**
+     * Test {@link SensorCtsHelper#getStandardDeviation(Collection)}.
+     */
+    public void testGetStandardDeviation() {
+        List<Integer> values = Arrays.asList(0, 1, 2, 3, 4);
+        double stddev = SensorCtsHelper.getStandardDeviation(values);
+        assertEquals(Math.sqrt(2.0), stddev, 0.00001);
+
+        values = Arrays.asList(1, 2, 3, 4, 5);
+        stddev = SensorCtsHelper.getStandardDeviation(values);
+        assertEquals(Math.sqrt(2.0), stddev, 0.00001);
+
+        values = Arrays.asList(0, 2, 4, 6, 8);
+        stddev = SensorCtsHelper.getStandardDeviation(values);
+        assertEquals(Math.sqrt(8.0), stddev, 0.00001);
+    }
+
+    /**
+     * Test {@link SensorCtsHelper#getTimestampDelayValues(TestSensorEvent[])}.
+     */
+    public void testGetTimestampDelayValues() {
+        float[] values = {0, 1, 2, 3, 4};
+
+        long[] timestamps = {0, 0, 1, 3, 100};
+        List<Long> timestampDelayValues = SensorCtsHelper.getTimestampDelayValues(
+                getSensorEvents(timestamps, values));
+        assertEquals(4, timestampDelayValues.size());
+        assertEquals(0, (long) timestampDelayValues.get(0));
+        assertEquals(1, (long) timestampDelayValues.get(1));
+        assertEquals(2, (long) timestampDelayValues.get(2));
+        assertEquals(97, (long) timestampDelayValues.get(3));
+    }
+
+    /**
+     * Test {@link SensorCtsHelper#getFrequency(Number, TimeUnit)}.
+     */
+    public void testGetFrequency() {
+        assertEquals(1.0, SensorCtsHelper.getFrequency(1, TimeUnit.SECONDS), 0.001);
+        assertEquals(10.0, SensorCtsHelper.getFrequency(0.1, TimeUnit.SECONDS), 0.001);
+        assertEquals(10.0, SensorCtsHelper.getFrequency(100, TimeUnit.MILLISECONDS), 0.001);
+        assertEquals(1000.0, SensorCtsHelper.getFrequency(1, TimeUnit.MILLISECONDS), 0.001);
+        assertEquals(10000.0, SensorCtsHelper.getFrequency(0.1, TimeUnit.MILLISECONDS), 0.001);
+        assertEquals(10000.0, SensorCtsHelper.getFrequency(100, TimeUnit.MICROSECONDS), 0.001);
+        assertEquals(1000000.0, SensorCtsHelper.getFrequency(1, TimeUnit.MICROSECONDS), 0.001);
+        assertEquals(10000000.0, SensorCtsHelper.getFrequency(0.1, TimeUnit.MICROSECONDS), 0.001);
+        assertEquals(10000000.0, SensorCtsHelper.getFrequency(100, TimeUnit.NANOSECONDS), 0.001);
+        assertEquals(1000000000.0, SensorCtsHelper.getFrequency(1, TimeUnit.NANOSECONDS), 0.001);
+    }
+
+    /**
+     * Test {@link SensorCtsHelper#getPeriod(Number, TimeUnit)}.
+     */
+    public void testGetPeriod() {
+        assertEquals(1.0, SensorCtsHelper.getPeriod(1, TimeUnit.SECONDS), 0.001);
+        assertEquals(0.1, SensorCtsHelper.getPeriod(10, TimeUnit.SECONDS), 0.001);
+        assertEquals(100, SensorCtsHelper.getPeriod(10, TimeUnit.MILLISECONDS), 0.001);
+        assertEquals(1, SensorCtsHelper.getPeriod(1000, TimeUnit.MILLISECONDS), 0.001);
+        assertEquals(0.1, SensorCtsHelper.getPeriod(10000, TimeUnit.MILLISECONDS), 0.001);
+        assertEquals(100, SensorCtsHelper.getPeriod(10000, TimeUnit.MICROSECONDS), 0.001);
+        assertEquals(1, SensorCtsHelper.getPeriod(1000000, TimeUnit.MICROSECONDS), 0.001);
+        assertEquals(0.1, SensorCtsHelper.getPeriod(10000000, TimeUnit.MICROSECONDS), 0.001);
+        assertEquals(100, SensorCtsHelper.getPeriod(10000000, TimeUnit.NANOSECONDS), 0.001);
+        assertEquals(1, SensorCtsHelper.getPeriod(1000000000, TimeUnit.NANOSECONDS), 0.001);
+    }
+
+    /**
+     * Test {@link SensorCtsHelper#getJitterValues(TestSensorEvent[])}.
+     */
+    public void testGetJitterValues() {
+        float[] values = {0, 1, 2, 3, 4};
+
+        long[] timestamps1 = {0, 1, 2, 3, 4};
+        List<Double> jitterValues = SensorCtsHelper.getJitterValues(
+                getSensorEvents(timestamps1, values));
+        assertEquals(4, jitterValues.size());
+        assertEquals(0.0, (double) jitterValues.get(0));
+        assertEquals(0.0, (double) jitterValues.get(1));
+        assertEquals(0.0, (double) jitterValues.get(2));
+        assertEquals(0.0, (double) jitterValues.get(3));
+
+        long[] timestamps2 = {0, 0, 2, 4, 4};
+        jitterValues = SensorCtsHelper.getJitterValues(
+                getSensorEvents(timestamps2, values));
+        assertEquals(4, jitterValues.size());
+        assertEquals(1.0, (double) jitterValues.get(0));
+        assertEquals(1.0, (double) jitterValues.get(1));
+        assertEquals(1.0, (double) jitterValues.get(2));
+        assertEquals(1.0, (double) jitterValues.get(3));
+
+        long[] timestamps3 = {0, 1, 4, 9, 16};
+        jitterValues = SensorCtsHelper.getJitterValues(
+                getSensorEvents(timestamps3, values));
+        assertEquals(4, jitterValues.size());
+        assertEquals(3.0, (double) jitterValues.get(0));
+        assertEquals(1.0, (double) jitterValues.get(1));
+        assertEquals(1.0, (double) jitterValues.get(2));
+        assertEquals(3.0, (double) jitterValues.get(3));
+    }
+
+    private TestSensorEvent[] getSensorEvents(long[] timestamps, float[] ... values) {
+        TestSensorEvent[] events = new TestSensorEvent[timestamps.length];
+        for (int i = 0; i < timestamps.length; i++) {
+            float[] eventValues = new float[values.length];
+            for (int j = 0; j < values.length; j++) {
+                eventValues[j] = values[j][i];
+            }
+            events[i] = new TestSensorEvent(null, timestamps[i], 0, eventValues);
+        }
+        return events;
+    }
+}
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/SensorManagerTestVerifier.java b/tests/tests/hardware/src/android/hardware/cts/helpers/SensorManagerTestVerifier.java
index 6e8b758..85f4f0e 100644
--- a/tests/tests/hardware/src/android/hardware/cts/helpers/SensorManagerTestVerifier.java
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/SensorManagerTestVerifier.java
@@ -17,25 +17,23 @@
 package android.hardware.cts.helpers;
 
 import android.content.Context;
-
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener2;
 import android.hardware.SensorManager;
 
-import java.io.Closeable;
+import junit.framework.Assert;
 
+import java.io.Closeable;
 import java.security.InvalidParameterException;
 import java.util.concurrent.ConcurrentLinkedDeque;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
-import junit.framework.Assert;
-
 /**
  * Test class to wrap SensorManager with verifications and test checks.
  * This class allows to perform operations in the Sensor Manager and performs all the expected test
- * verification on behalf of th owner.
+ * verification on behalf of the owner.
  * An object can be used to quickly writing tests that focus on the scenario that needs to be
  * verified, and not in the implicit verifications that need to take place at any step.
  */
@@ -66,30 +64,52 @@
     }
 
     /**
-     * Public listeners for Sensor events, these are available for subclasses to implement if they
-     * need access to the raw eventing model.
+     * {@inheritDoc}
+     * <p>
+     * Available for subclasses to implement if they need access to the raw eventing model.
+     * </p>
      */
     @Override
     public void onAccuracyChanged(Sensor sensor, int accuracy) {}
 
+    /**
+     * {@inheritDoc}
+     * <p>
+     * Available for subclasses to implement if they need access to the raw eventing model.
+     * </p>
+     */
     @Override
     public void onSensorChanged(SensorEvent event) {}
 
+    /**
+     * {@inheritDoc}
+     * <p>
+     * Available for subclasses to implement if they need access to the raw eventing model.
+     * </p>
+     */
     @Override
     public void onFlushCompleted(Sensor sensor) {}
 
     /**
-     * Members
+     * Closes the {@link SensorManagerTestVerifier} and unregister the listener.
      */
+    @Override
     public void close() {
         this.unregisterListener();
         mEventListener = null;
     }
 
+    /**
+     * Get the sensor under test.
+     */
     public Sensor getUnderlyingSensor() {
         return mSensorUnderTest;
     }
 
+    /**
+     * Register the
+     * @param debugInfo
+     */
     public void registerListener(String debugInfo) {
         boolean result = mSensorManager.registerListener(
                 mEventListener,
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/SensorVerificationHelper.java b/tests/tests/hardware/src/android/hardware/cts/helpers/SensorVerificationHelper.java
new file mode 100644
index 0000000..d1013e0
--- /dev/null
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/SensorVerificationHelper.java
@@ -0,0 +1,352 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * 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 android.hardware.cts.helpers;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Set of static helper methods to verify sensor CTS tests.
+ */
+public class SensorVerificationHelper {
+
+    private static final int MESSAGE_LENGTH = 3;
+
+    /**
+     * Class which holds results from the verification.
+     */
+    public static class VerificationResult {
+        private boolean mFailed = false;
+        private String mMessage = null;
+        private Map<String, Object> mValueMap = new HashMap<String, Object>();
+
+        public void fail(String messageFormat, Object ... args) {
+            mFailed = true;
+            mMessage = String.format(messageFormat, args);
+        }
+
+        public boolean isFailed() {
+            return mFailed;
+        }
+
+        public String getFailureMessage() {
+            return mMessage;
+        }
+
+        public void putValue(String key, Object value) {
+            mValueMap.put(key, value);
+        }
+
+        public Object getValue(String key) {
+            return mValueMap.get(key);
+        }
+    }
+
+    /**
+     * Private constructor for static class.
+     */
+    private SensorVerificationHelper() {}
+
+    /**
+     * Verify that the events are in the correct order.
+     *
+     * @param events The array of {@link TestSensorEvent}
+     * @return a {@link VerificationResult} containing the verification info including the keys
+     *     "count" which is the number of events out of order and "positions" which contains an
+     *     array of indexes that were out of order.
+     * @throws IllegalStateException if number of events less than 1.
+     */
+    public static VerificationResult verifyEventOrdering(TestSensorEvent[] events) {
+        VerificationResult result = new VerificationResult();
+        List<Integer> indices = new ArrayList<Integer>();
+        long maxTimestamp = events[0].timestamp;
+        for (int i = 1; i < events.length; i++) {
+            long currentTimestamp = events[i].timestamp;
+            if (currentTimestamp < maxTimestamp) {
+                indices.add(i);
+            } else if (currentTimestamp > maxTimestamp) {
+                maxTimestamp = currentTimestamp;
+            }
+        }
+
+        result.putValue("count", indices.size());
+        result.putValue("positions", indices);
+
+        if (indices.size() > 0) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(indices.size()).append(" events out of order: ");
+            for (int i = 0; i < Math.min(indices.size(), MESSAGE_LENGTH); i++) {
+                int index = indices.get(i);
+                sb.append(String.format("position=%d, previous=%d, timestamp=%d; ", index,
+                        events[index - 1].timestamp, events[index].timestamp));
+            }
+            if (indices.size() > MESSAGE_LENGTH) {
+                sb.append(indices.size() - MESSAGE_LENGTH).append(" more");
+            } else {
+                // Delete the "; "
+                sb.delete(sb.length() - 2, sb.length());
+            }
+
+            result.fail(sb.toString());
+        }
+
+        return result;
+    }
+
+    /**
+     * Verify that the sensor frequency matches the expected frequency.
+     *
+     * @param events The array of {@link TestSensorEvent}
+     * @param expected The expected frequency in Hz
+     * @param threshold The acceptable margin of error in Hz
+     * @return a {@link VerificationResult} containing the verification info including the key
+     *     "frequency" which is the computed frequency of the events in Hz.
+     * @throws IllegalStateException if number of events less than 1.
+     */
+    public static VerificationResult verifyFrequency(TestSensorEvent[] events, double expected,
+            double threshold) {
+        VerificationResult result = new VerificationResult();
+        List<Long> timestampDelayValues = SensorCtsHelper.getTimestampDelayValues(events);
+        double frequency = SensorCtsHelper.getFrequency(
+                SensorCtsHelper.getMean(timestampDelayValues), TimeUnit.NANOSECONDS);
+        result.putValue("frequency", frequency);
+
+        if (Math.abs(frequency - expected) > threshold) {
+            result.fail("Frequency out of range: frequency=%.2fHz, expected=%.2f+/-%.2fHz",
+                    frequency, expected, threshold);
+        }
+        return result;
+    }
+
+    /**
+     * Verify that the jitter is in an acceptable range
+     *
+     * @param events The array of {@link TestSensorEvent}
+     * @param threshold The acceptable margin of error in nanoseconds
+     * @return a {@link VerificationResult} containing the verification info including the keys
+     *     "jitter" which is the list of computed jitter values and "jitter95Percentile" which is
+     *     95th percentile of the jitter values.
+     * @throws IllegalStateException if number of events less than 2.
+     */
+    public static VerificationResult verifyJitter(TestSensorEvent[] events, double threshold) {
+        VerificationResult result = new VerificationResult();
+        List<Double> jitterValues = SensorCtsHelper.getJitterValues(events);
+        double jitter95Percentile = SensorCtsHelper.get95PercentileValue(jitterValues);
+        result.putValue("jitter", jitterValues);
+        result.putValue("jitter95Percentile", jitter95Percentile);
+
+        if (jitter95Percentile > threshold) {
+            result.fail("Jitter out of range: jitter at 95th percentile=%.0fns, expected=<%.0fns",
+                    jitter95Percentile, threshold);
+        }
+        return result;
+    }
+
+    /**
+     * Verify that the means matches the expected measurement.
+     *
+     * @param events The array of {@link TestSensorEvent}
+     * @param expected The array of expected values
+     * @param threshold The array of thresholds
+     * @return a {@link VerificationResult} containing the verification info including the key
+     *     "mean" which is the computed means for each value of the sensor.
+     * @throws IllegalStateException if number of events less than 1.
+     */
+    public static VerificationResult verifyMean(TestSensorEvent[] events, double[] expected,
+            double[] threshold) {
+        VerificationResult result = new VerificationResult();
+        double[] means = SensorCtsHelper.getMeans(events);
+        result.putValue("means", means);
+
+        boolean failed = false;
+        StringBuilder meanSb = new StringBuilder();
+        StringBuilder expectedSb = new StringBuilder();
+
+        if (means.length > 1) {
+            meanSb.append("(");
+            expectedSb.append("(");
+        }
+        for (int i = 0; i < means.length && !failed; i++) {
+            if (Math.abs(means[i] - expected[i]) > threshold[i]) {
+                failed = true;
+            }
+            meanSb.append(String.format("%.2f", means[i]));
+            if (i != means.length - 1) meanSb.append(", ");
+            expectedSb.append(String.format("%.2f+/-%.2f", expected[i], threshold[i]));
+            if (i != means.length - 1) expectedSb.append(", ");
+        }
+        if (means.length > 1) {
+            meanSb.append(")");
+            expectedSb.append(")");
+        }
+
+        if (failed) {
+            result.fail("Mean out of range: mean=%s, expected=%s",
+                    meanSb.toString(), expectedSb.toString());
+        }
+        return result;
+    }
+
+    /**
+     * Verify that the mean of the magnitude of the sensors vector is within the expected range.
+     *
+     * @param events The array of {@link TestSensorEvent}
+     * @param expected The expected value
+     * @param threshold The threshold
+     * @return a {@link VerificationResult} containing the verification info including the key
+     *     "magnitude" which is the mean of the computed magnitude of the sensor values.
+     * @throws IllegalStateException if number of events less than 1.
+     */
+    public static VerificationResult verifyMagnitude(TestSensorEvent[] events, double expected,
+            double threshold) {
+        VerificationResult result = new VerificationResult();
+        Collection<Double> magnitudes = new ArrayList<Double>(events.length);
+
+        for (TestSensorEvent event : events) {
+            double norm = 0;
+            for (int i = 0; i < event.values.length; i++) {
+                norm += event.values[i] * event.values[i];
+            }
+            magnitudes.add(Math.sqrt(norm));
+        }
+
+        double mean = SensorCtsHelper.getMean(magnitudes);
+        result.putValue("magnitude", mean);
+
+        if (Math.abs(mean - expected) > threshold) {
+            result.fail(String.format("Magnitude mean out of range: mean=%s, expected=%s+/-%s",
+                    mean, expected, threshold));
+        }
+        return result;
+    }
+
+    /**
+     * Verify that the sign of each of the sensor values is correct.
+     * <p>
+     * If the value of the measurement is in [-threshold, threshold], the sign is considered 0. If
+     * it is less than -threshold, it is considered -1. If it is greater than threshold, it is
+     * considered 1.
+     * </p>
+     *
+     * @param events
+     * @param threshold The threshold that needs to be crossed to consider a measurement nonzero
+     * @return a {@link VerificationResult} containing the verification info including the key
+     *     "mean" which is the computed means for each value of the sensor.
+     * @throws IllegalStateException if number of events less than 1.
+     */
+    public static VerificationResult verifySignum(TestSensorEvent[] events, int[] expected,
+            double[] threshold) {
+        VerificationResult result = new VerificationResult();
+        for (int i = 0; i < expected.length; i++) {
+            if (!(expected[i] == -1 || expected[i] == 0 || expected[i] == 1)) {
+                throw new IllegalArgumentException("Expected value must be -1, 0, or 1");
+            }
+        }
+        double[] means = SensorCtsHelper.getMeans(events);
+        result.putValue("means", means);
+
+        boolean failed = false;
+        StringBuilder meanSb = new StringBuilder();
+        StringBuilder expectedSb = new StringBuilder();
+
+        if (means.length > 1) {
+            meanSb.append("(");
+            expectedSb.append("(");
+        }
+        for (int i = 0; i < means.length; i++) {
+            meanSb.append(String.format("%.2f", means[i]));
+            if (i != means.length - 1) meanSb.append(", ");
+
+            if (expected[i] == 0) {
+                if (Math.abs(means[i]) > threshold[i]) {
+                    failed = true;
+                }
+                expectedSb.append(String.format("[%.2f, %.2f]", -threshold[i], threshold[i]));
+            } else {
+                if (expected[i] > 0) {
+                    if (means[i] <= threshold[i]) {
+                        failed = true;
+                    }
+                    expectedSb.append(String.format("(%.2f, inf)", threshold[i]));
+                } else {
+                    if (means[i] >= -1 * threshold[i]) {
+                        failed = true;
+                    }
+                    expectedSb.append(String.format("(-inf, %.2f)", -1 * threshold[i]));
+                }
+            }
+            if (i != means.length - 1) expectedSb.append(", ");
+        }
+        if (means.length > 1) {
+            meanSb.append(")");
+            expectedSb.append(")");
+        }
+
+        if (failed) {
+            result.fail("Signum out of range: mean=%s, expected=%s",
+                    meanSb.toString(), expectedSb.toString());
+        }
+        return result;
+    }
+
+    /**
+     * Verify that the standard deviations is within the expected range.
+     *
+     * @param events The array of {@link TestSensorEvent}
+     * @param threshold The array of thresholds
+     * @return a {@link VerificationResult} containing the verification info including the key
+     *     "stddevs" which is the computed standard deviations for each value of the sensor.
+     * @throws IllegalStateException if number of events less than 1.
+     */
+    public static VerificationResult verifyStandardDeviation(TestSensorEvent[] events,
+            double[] threshold) {
+        VerificationResult result = new VerificationResult();
+        double[] standardDeviations = SensorCtsHelper.getStandardDeviations(events);
+        result.putValue("stddevs", standardDeviations);
+
+        boolean failed = false;
+        StringBuilder meanSb = new StringBuilder();
+        StringBuilder expectedSb = new StringBuilder();
+
+        if (standardDeviations.length > 1) {
+            meanSb.append("(");
+            expectedSb.append("(");
+        }
+        for (int i = 0; i < standardDeviations.length && !failed; i++) {
+            if (standardDeviations[i] > threshold[i]) {
+                failed = true;
+            }
+            meanSb.append(String.format("%.2f", standardDeviations[i]));
+            if (i != standardDeviations.length - 1) meanSb.append(", ");
+            expectedSb.append(String.format("0+/-%.2f", threshold[i]));
+            if (i != standardDeviations.length - 1) expectedSb.append(", ");
+        }
+        if (standardDeviations.length > 1) {
+            meanSb.append(")");
+            expectedSb.append(")");
+        }
+
+        if (failed) {
+            result.fail("Standard deviation out of range: mean=%s, expected=%s",
+                    meanSb.toString(), expectedSb.toString());
+        }
+        return result;
+    }
+}
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/SensorVerificationHelperTest.java b/tests/tests/hardware/src/android/hardware/cts/helpers/SensorVerificationHelperTest.java
new file mode 100644
index 0000000..94ea57d
--- /dev/null
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/SensorVerificationHelperTest.java
@@ -0,0 +1,284 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * 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 android.hardware.cts.helpers;
+
+import android.hardware.cts.helpers.SensorVerificationHelper.VerificationResult;
+
+import junit.framework.TestCase;
+
+import java.util.List;
+
+/**
+ * Unit tests for the {@link SensorVerificationHelper} class.
+ */
+public class SensorVerificationHelperTest extends TestCase {
+
+    /**
+     * Test {@link SensorVerificationHelper#verifyEventOrdering(TestSensorEvent[])}.
+     */
+    @SuppressWarnings("unchecked")
+    public void testVerifyEventOrdering() {
+        float[] values = {0, 1, 2, 3, 4};
+
+        long[] timestamps1 = {0, 0, 0, 0, 0};
+        TestSensorEvent[] events1 = getSensorEvents(timestamps1, values);
+        VerificationResult result = SensorVerificationHelper.verifyEventOrdering(events1);
+        assertFalse(result.isFailed());
+        assertEquals(0, result.getValue("count"));
+
+        long[] timestamps2 = {0, 1, 2, 3, 4};
+        TestSensorEvent[] events2 = getSensorEvents(timestamps2, values);
+        result = SensorVerificationHelper.verifyEventOrdering(events2);
+        assertFalse(result.isFailed());
+        assertEquals(0, result.getValue("count"));
+
+        long[] timestamps3 = {0, 2, 1, 3, 4};
+        TestSensorEvent[] events3 = getSensorEvents(timestamps3, values);
+        result = SensorVerificationHelper.verifyEventOrdering(events3);
+        assertTrue(result.isFailed());
+        assertEquals(1, result.getValue("count"));
+        List<Integer> indices = (List<Integer>) result.getValue("positions");
+        assertTrue(indices.contains(2));
+
+        long[] timestamps4 = {4, 0, 1, 2, 3};
+        TestSensorEvent[] events4 = getSensorEvents(timestamps4, values);
+        result = SensorVerificationHelper.verifyEventOrdering(events4);
+        assertTrue(result.isFailed());
+        assertEquals(4, result.getValue("count"));
+        indices = (List<Integer>) result.getValue("positions");
+        assertTrue(indices.contains(1));
+        assertTrue(indices.contains(2));
+        assertTrue(indices.contains(3));
+        assertTrue(indices.contains(4));
+    }
+
+    /**
+     * Test {@link SensorVerificationHelper#verifyFrequency(TestSensorEvent[], double, double)}.
+     */
+    public void testVerifyFrequency() {
+        float[] values = {0, 1, 2, 3, 4};
+        long[] timestamps = {0, 1000000, 2000000, 3000000, 4000000};  // 1000Hz
+        TestSensorEvent[] events = getSensorEvents(timestamps, values);
+
+        VerificationResult result = SensorVerificationHelper.verifyFrequency(events, 1000.0, 1.0);
+        assertFalse(result.isFailed());
+        assertEquals(1000.0, (Double) result.getValue("frequency"), 0.01);
+
+        result = SensorVerificationHelper.verifyFrequency(events, 950.0, 100.0);
+        assertFalse(result.isFailed());
+        assertEquals(1000.0, (Double) result.getValue("frequency"), 0.01);
+
+        result = SensorVerificationHelper.verifyFrequency(events, 1050.0, 100.0);
+        assertFalse(result.isFailed());
+        assertEquals(1000.0, (Double) result.getValue("frequency"), 0.01);
+
+        result = SensorVerificationHelper.verifyFrequency(events, 950.0, 25.0);
+        assertTrue(result.isFailed());
+        assertEquals(1000.0, (Double) result.getValue("frequency"), 0.01);
+    }
+
+    /**
+     * Test {@link SensorVerificationHelper#verifyJitter(TestSensorEvent[], double)}.
+     */
+    public void testVerifyJitter() {
+        final int SAMPLE_SIZE = 100;
+        float[] values = new float[SAMPLE_SIZE];
+        for (int i = 0; i < SAMPLE_SIZE; i++) {
+            values[i] = i;
+        }
+
+        long[] timestamps1 = new long[SAMPLE_SIZE];  // 100 samples at 1000Hz
+        for (int i = 0; i < SAMPLE_SIZE; i++) {
+            timestamps1[i] = i * 100000;
+        }
+        TestSensorEvent[] events1 = getSensorEvents(timestamps1, values);
+        VerificationResult result = SensorVerificationHelper.verifyJitter(events1, 100000);
+        assertFalse(result.isFailed());
+        assertEquals(0.0, (Double) result.getValue("jitter95Percentile"), 0.01);
+
+        long[] timestamps2 = new long[SAMPLE_SIZE];  // 90 samples at 1000Hz, 10 samples at 2000Hz
+        long timestamp = 0;
+        for (int i = 0; i < SAMPLE_SIZE; i++) {
+            timestamps2[i] = timestamp;
+            timestamp += (i % 10 == 0) ? 500000 : 1000000;
+        }
+        TestSensorEvent[] events2 = getSensorEvents(timestamps2, values);
+        result = SensorVerificationHelper.verifyJitter(events2, 100000);
+        assertTrue(result.isFailed());
+        assertNotNull(result.getValue("jitter"));
+        assertNotNull(result.getValue("jitter95Percentile"));
+    }
+
+    /**
+     * Test {@link SensorVerificationHelper#verifyMean(TestSensorEvent[], double[], double[])}.
+     */
+    public void testVerifyMean() {
+        long[] timestamps = {0, 1, 2, 3, 4};
+        float[] values1 = {0, 1, 2, 3, 4};
+        float[] values2 = {1, 2, 3, 4, 5};
+        float[] values3 = {0, 1, 4, 9, 16};
+        TestSensorEvent[] events = getSensorEvents(timestamps, values1, values2, values3);
+
+        double[] expected1 = {2.0, 3.0, 6.0};
+        double[] threshold1 = {0.1, 0.1, 0.1};
+        VerificationResult result = SensorVerificationHelper.verifyMean(events, expected1,
+                threshold1);
+        assertFalse(result.isFailed());
+        double[] means = (double[]) result.getValue("means");
+        assertEquals(2.0, means[0], 0.01);
+        assertEquals(3.0, means[1], 0.01);
+        assertEquals(6.0, means[2], 0.01);
+
+        double[] expected2 = {2.5, 2.5, 5.5};
+        double[] threshold2 = {0.6, 0.6, 0.6};
+        result = SensorVerificationHelper.verifyMean(events, expected2, threshold2);
+        assertFalse(result.isFailed());
+
+        double[] expected3 = {2.5, 2.5, 5.5};
+        double[] threshold3 = {0.1, 0.6, 0.6};
+        result = SensorVerificationHelper.verifyMean(events, expected3, threshold3);
+        assertTrue(result.isFailed());
+
+        double[] expected4 = {2.5, 2.5, 5.5};
+        double[] threshold4 = {0.6, 0.1, 0.6};
+        result = SensorVerificationHelper.verifyMean(events, expected4, threshold4);
+        assertTrue(result.isFailed());
+
+        double[] expected5 = {2.5, 2.5, 5.5};
+        double[] threshold5 = {0.6, 0.6, 0.1};
+        result = SensorVerificationHelper.verifyMean(events, expected5, threshold5);
+        assertTrue(result.isFailed());
+    }
+
+    /**
+     * Test {@link SensorVerificationHelper#verifyMagnitude(TestSensorEvent[], double, double)}.
+     */
+    public void testVerifyMagnitude() {
+        long[] timestamps = {0, 1, 2, 3, 4};
+        float[] values1 = {0, 4, 3, 0, 6};
+        float[] values2 = {3, 0, 4, 0, 0};
+        float[] values3 = {4, 3, 0, 4, 0};
+        TestSensorEvent[] events = getSensorEvents(timestamps, values1, values2, values3);
+
+        double expected = 5.0;
+        double threshold = 0.1;
+        VerificationResult result = SensorVerificationHelper.verifyMagnitude(events, expected,
+                threshold);
+        assertFalse(result.isFailed());
+        assertEquals(5.0, (Double) result.getValue("norm"), 0.01);
+
+        expected = 4.5;
+        threshold = 0.6;
+        result = SensorVerificationHelper.verifyMagnitude(events, expected, threshold);
+        assertFalse(result.isFailed());
+
+        expected = 5.5;
+        threshold = 0.6;
+        result = SensorVerificationHelper.verifyMagnitude(events, expected, threshold);
+        assertFalse(result.isFailed());
+
+        expected = 4.5;
+        threshold = 0.1;
+        result = SensorVerificationHelper.verifyMagnitude(events, expected, threshold);
+        assertTrue(result.isFailed());
+
+        expected = 5.5;
+        threshold = 0.1;
+        result = SensorVerificationHelper.verifyMagnitude(events, expected, threshold);
+        assertTrue(result.isFailed());
+    }
+
+    /**
+     * Test {@link SensorVerificationHelper#verifySignum(TestSensorEvent[], int[], double[])}.
+     */
+    public void testVerifySignum() {
+        long[] timestamps = {0};
+        float[][] values = {{1}, {0.2f}, {0}, {-0.2f}, {-1}};
+        TestSensorEvent[] events = getSensorEvents(timestamps, values);
+
+        int[] expected1 = {1, 1, 0, -1, -1};
+        double[] threshold1 = {0.1, 0.1, 0.1, 0.1, 0.1};
+        VerificationResult result = SensorVerificationHelper.verifySignum(events, expected1,
+                threshold1);
+        assertFalse(result.isFailed());
+        assertNotNull(result.getValue("means"));
+
+        int[] expected2 = {1, 0, 0, 0, -1};
+        double[] threshold2 = {0.5, 0.5, 0.5, 0.5, 0.5};
+        result = SensorVerificationHelper.verifySignum(events, expected2, threshold2);
+        assertFalse(result.isFailed());
+
+        int[] expected3 = {0, 1, 0, -1, 0};
+        double[] threshold3 = {1.5, 0.1, 0.1, 0.1, 1.5};
+        result = SensorVerificationHelper.verifySignum(events, expected3, threshold3);
+        assertFalse(result.isFailed());
+
+        int[] expected4 = {1, 0, 0, 0, 1};
+        double[] threshold4 = {0.5, 0.5, 0.5, 0.5, 0.5};
+        result = SensorVerificationHelper.verifySignum(events, expected4, threshold4);
+        assertTrue(result.isFailed());
+
+        int[] expected5 = {-1, 0, 0, 0, -1};
+        double[] threshold5 = {0.5, 0.5, 0.5, 0.5, 0.5};
+        result = SensorVerificationHelper.verifySignum(events, expected5, threshold5);
+        assertTrue(result.isFailed());
+    }
+
+    /**
+     * Test {@link SensorVerificationHelper#verifyStandardDeviation(TestSensorEvent[], double[])}.
+     */
+    public void testVerifyStandardDeviation() {
+        long[] timestamps = {0, 1, 2, 3, 4};
+        float[] values1 = {0, 1, 2, 3, 4};  // sqrt(2.0)
+        float[] values2 = {1, 2, 3, 4, 5};  // sqrt(2.0)
+        float[] values3 = {0, 2, 4, 6, 8};  // sqrt(8.0)
+        TestSensorEvent[] events = getSensorEvents(timestamps, values1, values2, values3);
+
+        double[] threshold1 = {2, 2, 3};
+        VerificationResult result = SensorVerificationHelper.verifyStandardDeviation(events,
+                threshold1);
+        assertFalse(result.isFailed());
+        double[] means = (double[]) result.getValue("stddevs");
+        assertEquals(Math.sqrt(2.0), means[0], 0.01);
+        assertEquals(Math.sqrt(2.0), means[1], 0.01);
+        assertEquals(Math.sqrt(8.0), means[2], 0.01);
+
+        double[] threshold2 = {1, 2, 3};
+        result = SensorVerificationHelper.verifyStandardDeviation(events, threshold2);
+        assertTrue(result.isFailed());
+
+        double[] threshold3 = {2, 1, 3};
+        result = SensorVerificationHelper.verifyStandardDeviation(events, threshold3);
+        assertTrue(result.isFailed());
+
+        double[] threshold4 = {2, 2, 2};
+        result = SensorVerificationHelper.verifyStandardDeviation(events, threshold4);
+        assertTrue(result.isFailed());
+    }
+
+    private TestSensorEvent[] getSensorEvents(long[] timestamps, float[] ... values) {
+        TestSensorEvent[] events = new TestSensorEvent[timestamps.length];
+        for (int i = 0; i < timestamps.length; i++) {
+            float[] eventValues = new float[values.length];
+            for (int j = 0; j < values.length; j++) {
+                eventValues[j] = values[j][i];
+            }
+            events[i] = new TestSensorEvent(null, timestamps[i], 0, eventValues);
+        }
+        return events;
+    }
+}
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/TestSensorEvent.java b/tests/tests/hardware/src/android/hardware/cts/helpers/TestSensorEvent.java
index 1a2cdfe..48bc1d3 100644
--- a/tests/tests/hardware/src/android/hardware/cts/helpers/TestSensorEvent.java
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/TestSensorEvent.java
@@ -38,4 +38,14 @@
         timestamp = event.timestamp;
         accuracy = event.accuracy;
     }
+
+    /**
+     * Constructor for TestSensorEvent. Exposed for unit testing.
+     */
+    protected TestSensorEvent(Sensor sensor, long timestamp, int accuracy, float[] values) {
+        this.sensor = sensor;
+        this.timestamp = timestamp;
+        this.accuracy = accuracy;
+        this.values = values;
+    }
 }
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyEventOrderingOperation.java b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyEventOrderingOperation.java
index bb43b01..03d0f9a 100644
--- a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyEventOrderingOperation.java
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyEventOrderingOperation.java
@@ -16,15 +16,16 @@
 
 package android.hardware.cts.helpers.sensorTestOperations;
 
-import junit.framework.Assert;
-
 import android.content.Context;
-
 import android.hardware.cts.helpers.SensorCtsHelper;
 import android.hardware.cts.helpers.SensorManagerTestVerifier;
 import android.hardware.cts.helpers.SensorTestOperation;
+import android.hardware.cts.helpers.SensorVerificationHelper;
+import android.hardware.cts.helpers.SensorVerificationHelper.VerificationResult;
 import android.hardware.cts.helpers.TestSensorEvent;
 
+import junit.framework.Assert;
+
 /**
  * Test Operation class that validates the ordering of sensor events.
  */
@@ -45,23 +46,14 @@
 
     @Override
     public void doWork() {
-        TestSensorEvent events[] = mSensor.collectEvents(100);
-        for(int i = 1; i < events.length; ++i) {
-            long previousTimestamp = events[i-1].timestamp;
-            long timestamp = events[i].timestamp;
-            // allow two identical timestamps to be considered in order, in case the resolution of
-            // the timestamp is not granular enough
-            if(previousTimestamp > timestamp) {
-                String message = SensorCtsHelper.formatAssertionMessage(
-                        "Ordering",
-                        this,
-                        mSensor.getUnderlyingSensor(),
-                        "position:%d, previous:%d, timestamp:%d",
-                        i,
-                        previousTimestamp,
-                        timestamp);
-                Assert.fail(message);
-            }
+        TestSensorEvent[] events = mSensor.collectEvents(100);
+        VerificationResult result = SensorVerificationHelper.verifyEventOrdering(events);
+        if (result.isFailed()) {
+            Assert.fail(SensorCtsHelper.formatAssertionMessage(
+                    "Ordering",
+                    this,
+                    mSensor.getUnderlyingSensor(),
+                    result.getFailureMessage()));
         }
     }
 }
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyJitteringOperation.java b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyJitteringOperation.java
index 6f1c03a..303dc9b 100644
--- a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyJitteringOperation.java
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyJitteringOperation.java
@@ -16,21 +16,18 @@
 
 package android.hardware.cts.helpers.sensorTestOperations;
 
-import junit.framework.Assert;
-
 import android.content.Context;
 import android.hardware.cts.helpers.SensorCtsHelper;
 import android.hardware.cts.helpers.SensorManagerTestVerifier;
 import android.hardware.cts.helpers.SensorTestInformation;
 import android.hardware.cts.helpers.SensorTestOperation;
+import android.hardware.cts.helpers.SensorVerificationHelper;
+import android.hardware.cts.helpers.SensorVerificationHelper.VerificationResult;
 import android.hardware.cts.helpers.TestSensorEvent;
 
-import android.util.Log;
+import junit.framework.Assert;
 
 import java.security.InvalidParameterException;
-
-import java.util.ArrayList;
-
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -71,26 +68,14 @@
 
     @Override
     public void doWork() {
-        TestSensorEvent events[] = mSensor.collectEvents(100);
-        ArrayList<Double> jitterValues = new ArrayList<Double>();
-        double jitterMean = SensorCtsHelper.getJitterMean(events, jitterValues);
-        double percentile95InNs = SensorCtsHelper.get95PercentileValue(jitterValues);
-
-        if(percentile95InNs > mThresholdInNs) {
-            for(double jitter : jitterValues) {
-                Log.e(LOG_TAG, "Jitter: " + jitter);
-            }
-            double actualPercentValue = (percentile95InNs * 100) / jitterMean;
-            String message = SensorCtsHelper.formatAssertionMessage(
-                    "Jitter(95%%ile)",
+        TestSensorEvent[] events = mSensor.collectEvents(100);
+        VerificationResult result = SensorVerificationHelper.verifyJitter(events, mThresholdInNs);
+        if (result.isFailed()) {
+            Assert.fail(SensorCtsHelper.formatAssertionMessage(
+                    "Jitter(95%ile)",
                     this,
                     mSensor.getUnderlyingSensor(),
-                    "expected:%dns(%d%%), actual:%fns(%.2f%%)",
-                    mThresholdInNs,
-                    mThresholdPercentage,
-                    percentile95InNs,
-                    actualPercentValue);
-            Assert.fail(message);
+                    result.getFailureMessage()));
         }
     }
 }
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyNormOperation.java b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMagnitudeOperation.java
similarity index 67%
rename from tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyNormOperation.java
rename to tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMagnitudeOperation.java
index cce3412..cbcff6a 100644
--- a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyNormOperation.java
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMagnitudeOperation.java
@@ -16,27 +16,28 @@
 
 package android.hardware.cts.helpers.sensorTestOperations;
 
-import junit.framework.Assert;
-
 import android.content.Context;
-
 import android.hardware.cts.helpers.SensorCtsHelper;
 import android.hardware.cts.helpers.SensorManagerTestVerifier;
 import android.hardware.cts.helpers.SensorTestInformation;
 import android.hardware.cts.helpers.SensorTestOperation;
+import android.hardware.cts.helpers.SensorVerificationHelper;
+import android.hardware.cts.helpers.SensorVerificationHelper.VerificationResult;
 import android.hardware.cts.helpers.TestSensorEvent;
 
+import junit.framework.Assert;
+
 /**
  * Test Operation class that validates the norm of a given sensor.
  * The operation relies in the number of axes each sensor type reports.
  */
-public class VerifyNormOperation extends SensorTestOperation {
+public class VerifyMagnitudeOperation extends SensorTestOperation {
     private SensorManagerTestVerifier mSensor;
     private int mAxisCount;
     private double mReferenceValue;
     private double mThreshold;
 
-    public VerifyNormOperation(
+    public VerifyMagnitudeOperation(
             Context context,
             int sensorType,
             int samplingRateInUs,
@@ -55,28 +56,15 @@
 
     @Override
     public void doWork() {
-        TestSensorEvent event = mSensor.collectEvents(1)[0];
-        StringBuilder valuesBuilder = new StringBuilder();
-        double norm = 0.0;
-
-        for(int i = 0; i < mAxisCount; ++i) {
-            float value = event.values[i];
-            norm += Math.pow(value, 2);
-
-            valuesBuilder.append(value);
-            valuesBuilder.append(", ");
+        TestSensorEvent[] events = mSensor.collectEvents(1);
+        VerificationResult result = SensorVerificationHelper.verifyMagnitude(events, mReferenceValue,
+                mThreshold);
+        if (result.isFailed()) {
+            Assert.fail(SensorCtsHelper.formatAssertionMessage(
+                    "Norm",
+                    this,
+                    mSensor.getUnderlyingSensor(),
+                    result.getFailureMessage()));
         }
-        norm = Math.sqrt(norm);
-
-        String message = SensorCtsHelper.formatAssertionMessage(
-                "Norm",
-                this,
-                mSensor.getUnderlyingSensor(),
-                "expected:%f, threshold:%f, actual:%f ( %s)",
-                mReferenceValue,
-                mThreshold,
-                norm,
-                valuesBuilder.toString());
-        Assert.assertTrue(message, Math.abs(mReferenceValue - norm) <= mThreshold);
     }
 }
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMaximumFrequencyOperation.java b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMaximumFrequencyOperation.java
index 3cdffe0..0af15a2 100644
--- a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMaximumFrequencyOperation.java
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMaximumFrequencyOperation.java
@@ -16,21 +16,18 @@
 
 package android.hardware.cts.helpers.sensorTestOperations;
 
-import junit.framework.Assert;
-
 import android.content.Context;
-
 import android.hardware.cts.helpers.SensorCtsHelper;
 import android.hardware.cts.helpers.SensorManagerTestVerifier;
 import android.hardware.cts.helpers.SensorTestInformation;
 import android.hardware.cts.helpers.SensorTestOperation;
+import android.hardware.cts.helpers.SensorVerificationHelper;
+import android.hardware.cts.helpers.SensorVerificationHelper.VerificationResult;
 import android.hardware.cts.helpers.TestSensorEvent;
 
-import android.util.Log;
+import junit.framework.Assert;
 
 import java.security.InvalidParameterException;
-import java.util.ArrayList;
-
 import java.util.concurrent.TimeUnit;
 
 /**
@@ -71,28 +68,15 @@
 
     @Override
     public void doWork() {
-        TestSensorEvent events[] = mSensor.collectEvents(100);
-        ArrayList<Long> timestampDelayValues = new ArrayList<Long>();
-        Double frequencyMeanInUs = SensorCtsHelper.getAverageTimestampDelayWithValues(
-                events,
-                timestampDelayValues);
-
-        if(Math.abs(mExpectedTimestampInNs - frequencyMeanInUs) > mThresholdInNs) {
-            for(long value : timestampDelayValues) {
-                Log.e(LOG_TAG, "TimestampDelay: " + value);
-            }
-            String message = SensorCtsHelper.formatAssertionMessage(
+        TestSensorEvent[] events = mSensor.collectEvents(100);
+        VerificationResult result = SensorVerificationHelper.verifyFrequency(events,
+                mExpectedTimestampInNs, mThresholdInNs);
+        if (result.isFailed()) {
+            Assert.fail(SensorCtsHelper.formatAssertionMessage(
                     "Frequency",
                     this,
                     mSensor.getUnderlyingSensor(),
-                    "expected:%dns(%.2fHz), actual:%fns(%.2fHz), threshold:%dns(%d%%)",
-                    mExpectedTimestampInNs,
-                    SensorCtsHelper.getFrequencyInHz(mExpectedTimestampInNs),
-                    frequencyMeanInUs,
-                    SensorCtsHelper.getFrequencyInHz(frequencyMeanInUs),
-                    mThresholdInNs,
-                    mThresholdPercentage);
-            Assert.fail(message);
+                    result.getFailureMessage()));
         }
     }
 }
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMeasurementsOperation.java b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMeasurementsOperation.java
index d0c991b3..2368eb4 100644
--- a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMeasurementsOperation.java
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyMeasurementsOperation.java
@@ -16,16 +16,17 @@
 
 package android.hardware.cts.helpers.sensorTestOperations;
 
-import junit.framework.Assert;
-
 import android.content.Context;
-
 import android.hardware.cts.helpers.SensorCtsHelper;
 import android.hardware.cts.helpers.SensorManagerTestVerifier;
 import android.hardware.cts.helpers.SensorTestInformation;
 import android.hardware.cts.helpers.SensorTestOperation;
+import android.hardware.cts.helpers.SensorVerificationHelper;
+import android.hardware.cts.helpers.SensorVerificationHelper.VerificationResult;
 import android.hardware.cts.helpers.TestSensorEvent;
 
+import junit.framework.Assert;
+
 import java.security.InvalidParameterException;
 
 /**
@@ -37,8 +38,8 @@
 public class VerifyMeasurementsOperation extends SensorTestOperation {
     private final SensorManagerTestVerifier mSensor;
     private final int mAxisCount;
-    private final double mReferenceValues[];
-    private final double mThreshold;
+    private final double[] mReferenceValues;
+    private final double[] mThreshold;
 
     public VerifyMeasurementsOperation(
             Context context,
@@ -59,39 +60,23 @@
                 reportLatencyInUs);
         // set expectations
         mReferenceValues = referenceValues;
-        mThreshold = threshold;
+        mThreshold = new double[mAxisCount];
+        for (int i = 0; i < mThreshold.length; i++) {
+            mThreshold[i] = threshold;
+        }
     }
 
     @Override
     public void doWork() {
-        final String VALUE_SEPARATOR = ", ";
-        TestSensorEvent events[] = mSensor.collectEvents(100);
-        double measuredValues[] = new double[mReferenceValues.length];
-        SensorCtsHelper.getMeans(events, measuredValues);
-
-        boolean success = true;
-        StringBuilder referenceValuesBuilder = new StringBuilder();
-        StringBuilder measuredValuesBuilder = new StringBuilder();
-        for(int i = 0; i < mReferenceValues.length; i++) {
-            double reference = mReferenceValues[i];
-            double measurement = measuredValues[i];
-            double delta = Math.abs(reference - measurement);
-            success &= (delta <= mThreshold);
-            referenceValuesBuilder.append(reference);
-            referenceValuesBuilder.append(VALUE_SEPARATOR);
-            measuredValuesBuilder.append(measurement);
-            measuredValuesBuilder.append(VALUE_SEPARATOR);
-        }
-        if(!success) {
-            String message = SensorCtsHelper.formatAssertionMessage(
+        TestSensorEvent[] events = mSensor.collectEvents(100);
+        VerificationResult result = SensorVerificationHelper.verifyMean(events, mReferenceValues,
+                mThreshold);
+        if (result.isFailed()) {
+            Assert.fail(SensorCtsHelper.formatAssertionMessage(
                     "Measurement",
                     this,
                     mSensor.getUnderlyingSensor(),
-                    "expected:( %s), threshold:%f, actual: ( %s)",
-                    referenceValuesBuilder.toString(),
-                    mThreshold,
-                    measuredValuesBuilder.toString());
-            Assert.fail(message);
+                    result.getFailureMessage()));
         }
     }
 }
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifySignumOperation.java b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifySignumOperation.java
index 0ccf92a..f58baa1 100644
--- a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifySignumOperation.java
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifySignumOperation.java
@@ -16,15 +16,17 @@
 
 package android.hardware.cts.helpers.sensorTestOperations;
 
-import junit.framework.Assert;
-
 import android.content.Context;
 import android.hardware.cts.helpers.SensorCtsHelper;
 import android.hardware.cts.helpers.SensorManagerTestVerifier;
 import android.hardware.cts.helpers.SensorTestInformation;
 import android.hardware.cts.helpers.SensorTestOperation;
+import android.hardware.cts.helpers.SensorVerificationHelper;
+import android.hardware.cts.helpers.SensorVerificationHelper.VerificationResult;
 import android.hardware.cts.helpers.TestSensorEvent;
 
+import junit.framework.Assert;
+
 import java.security.InvalidParameterException;
 
 /**
@@ -34,8 +36,8 @@
 public class VerifySignumOperation extends SensorTestOperation {
     private final SensorManagerTestVerifier mSensor;
     private final int mAxisCount;
-    private final double mReferenceValues[];
-    private final double mNoiseThreshold;
+    private final int mReferenceValues[];
+    private final double mNoiseThresholds[];
 
     /**
      * @param noiseThreshold Defines the threshold that needs to be crossed to consider a
@@ -45,7 +47,7 @@
             Context context,
             int sensorType,
             int samplingRateInUs,
-            double referenceValues[],
+            int referenceValues[],
             double noiseThreshold) {
         mAxisCount = SensorTestInformation.getAxisCount(sensorType);
         if(mAxisCount != referenceValues.length) {
@@ -53,7 +55,7 @@
                     String.format("%d reference values are expected.", mAxisCount));
         }
         for(int i = 0; i < referenceValues.length; ++i) {
-            double value = referenceValues[i];
+            int value = referenceValues[i];
             if(value != 0 && value != -1 && value != +1) {
                 throw new InvalidParameterException(
                         "A ReferenceValue can only be one of the following: -1, 0, +1");
@@ -66,46 +68,23 @@
                 0 /*reportLatencyInUs*/);
         // set expectations
         mReferenceValues = referenceValues;
-        mNoiseThreshold = noiseThreshold;
+        mNoiseThresholds = new double[mReferenceValues.length];
+        for (int i = 0; i < mNoiseThresholds.length; i++) {
+            mNoiseThresholds[i] = noiseThreshold;
+        }
     }
 
     @Override
     public void doWork() {
-        final String VALUE_SEPARATOR = ", ";
-        TestSensorEvent events[] = mSensor.collectEvents(100);
-        double measuredValues[] = new double[mReferenceValues.length];
-        SensorCtsHelper.getMeans(events, measuredValues);
-
-        boolean success = true;
-        StringBuilder referenceValuesBuilder = new StringBuilder();
-        StringBuilder measuredValuesBuilder = new StringBuilder();
-        for(int i = 0; i < mReferenceValues.length; i++) {
-            double reference = mReferenceValues[i];
-            double measurement = measuredValues[i];
-            if(reference == 0) {
-                success &= Math.abs(measurement) < mNoiseThreshold;
-            } else {
-                double combinedValue = reference * measurement;
-                if(combinedValue < mNoiseThreshold) {
-                    combinedValue = 0;
-                }
-                success &= combinedValue > 0;
-            }
-            referenceValuesBuilder.append(reference);
-            referenceValuesBuilder.append(VALUE_SEPARATOR);
-            measuredValuesBuilder.append(measurement);
-            measuredValuesBuilder.append(VALUE_SEPARATOR);
-        }
-        if(!success) {
-            String message = SensorCtsHelper.formatAssertionMessage(
+        TestSensorEvent[] events = mSensor.collectEvents(100);
+        VerificationResult result = SensorVerificationHelper.verifySignum(events, mReferenceValues,
+                mNoiseThresholds);
+        if (result.isFailed()) {
+            Assert.fail(SensorCtsHelper.formatAssertionMessage(
                     "Measurement",
                     this,
                     mSensor.getUnderlyingSensor(),
-                    "expected:( %s), actual:( %s), noiseThreshold:%f",
-                    referenceValuesBuilder.toString(),
-                    measuredValuesBuilder.toString(),
-                    mNoiseThreshold);
-            Assert.fail(message);
+                    result.getFailureMessage()));
         }
     }
 }
diff --git a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyStandardDeviationOperation.java b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyStandardDeviationOperation.java
index 89cff94..05b92e0 100644
--- a/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyStandardDeviationOperation.java
+++ b/tests/tests/hardware/src/android/hardware/cts/helpers/sensorTestOperations/VerifyStandardDeviationOperation.java
@@ -16,19 +16,16 @@
 
 package android.hardware.cts.helpers.sensorTestOperations;
 
-import junit.framework.Assert;
-
 import android.content.Context;
-
 import android.hardware.cts.helpers.SensorCtsHelper;
 import android.hardware.cts.helpers.SensorManagerTestVerifier;
 import android.hardware.cts.helpers.SensorTestInformation;
 import android.hardware.cts.helpers.SensorTestOperation;
+import android.hardware.cts.helpers.SensorVerificationHelper;
+import android.hardware.cts.helpers.SensorVerificationHelper.VerificationResult;
 import android.hardware.cts.helpers.TestSensorEvent;
 
-import android.util.Log;
-
-import java.util.ArrayList;
+import junit.framework.Assert;
 
 /**
  * Test Operation class that validates the standard deviation of a given sensor.
@@ -36,7 +33,7 @@
 public class VerifyStandardDeviationOperation extends SensorTestOperation {
     private SensorManagerTestVerifier mSensor;
     private int mAxisCount;
-    private double mExpectedStandardDeviation;
+    private double[] mExpectedStandardDeviation;
 
     public VerifyStandardDeviationOperation(
             Context context,
@@ -51,33 +48,23 @@
                 reportLatencyInUs);
         // set expectations
         mAxisCount = SensorTestInformation.getAxisCount(mSensor.getUnderlyingSensor().getType());
-        mExpectedStandardDeviation = expectedStandardDeviation;
+        mExpectedStandardDeviation = new double[mAxisCount];
+        for (int i = 0; i < mExpectedStandardDeviation.length; i++) {
+            mExpectedStandardDeviation[i] = expectedStandardDeviation;
+        }
     }
 
     @Override
     public void doWork() {
-        TestSensorEvent events[] = mSensor.collectEvents(100);
-        for(int i = 0; i < mAxisCount; ++i) {
-            ArrayList<Float> values = new ArrayList<Float>();
-            for(TestSensorEvent event : events) {
-                values.add(event.values[i]);
-            }
-
-            double standardDeviation = SensorCtsHelper.getStandardDeviation(values);
-            if(standardDeviation > mExpectedStandardDeviation) {
-                for(float value : values) {
-                    Log.e(LOG_TAG, String.format("SensorValue:%f", value));
-                }
-                String message = SensorCtsHelper.formatAssertionMessage(
-                        "StandardDeviation",
-                        this,
-                        mSensor.getUnderlyingSensor(),
-                        "axis:%d, expected:%f, actual:%f",
-                        i,
-                        mExpectedStandardDeviation,
-                        standardDeviation);
-                Assert.fail(message);
-            }
+        TestSensorEvent[] events = mSensor.collectEvents(100);
+        VerificationResult result = SensorVerificationHelper.verifyStandardDeviation(events,
+                mExpectedStandardDeviation);
+        if (result.isFailed()) {
+            Assert.fail(SensorCtsHelper.formatAssertionMessage(
+                    "StandardDeviation",
+                    this,
+                    mSensor.getUnderlyingSensor(),
+                    result.getFailureMessage()));
         }
     }
 }