tests/sensor/src/android/hardware/cts/SensorBatchingTests.java - platform/cts - Git at Google

 /*
  * 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;

 import android.hardware.Sensor;
 import android.hardware.SensorManager;
 import android.hardware.cts.helpers.SensorCtsHelper;
 import android.hardware.cts.helpers.SensorStats;
 import android.hardware.cts.helpers.TestSensorEnvironment;
 import android.hardware.cts.helpers.sensoroperations.TestSensorOperation;
 import android.hardware.cts.helpers.sensorverification.EventBasicVerification;
 import android.hardware.cts.helpers.sensorverification.ISensorVerification;
 import android.hardware.cts.helpers.sensorverification.MeanLargerThanVerification;

 import java.util.concurrent.TimeUnit;

 /**
  * Set of tests to verify that sensors operate correctly when operating in batching mode.
  * This class defines tests for continuous sensors when the device is awake.
  * On-change and special sensors are tested separately inside CtsVerifier, and they are defined in:
  * {@link com.android.cts.verifier.sensors.BatchingTestActivity}.
  *
  * Each test is expected to pass even if batching is not supported for a particular sensor. This is
  * usually achieved by ensuring that {@link ISensorVerification}s fallback accordingly.
  *
  * <p>To execute these test cases, the following command can be used:</p>
  * <pre>
  * adb shell am instrument -e class android.hardware.cts.SensorBatchingTests \
  *     -w android.hardware.cts/android.test.AndroidJUnitRunner
  * </pre>
  */
 public class SensorBatchingTests extends SensorTestCase {
     private static final String TAG = "SensorBatchingTests";

     private static final int BATCHING_PERIOD = 10;  // sec
     private static final int RATE_50HZ = 20000;
     private static final int RATE_FASTEST = SensorManager.SENSOR_DELAY_FASTEST;

     /**
      * An arbitrary 'padding' time slot to wait for events after batching latency expires.
      * This allows for the test to wait for event arrivals after batching was expected.
      */
     private static final int BATCHING_PADDING_TIME_S = (int) Math.ceil(BATCHING_PERIOD * 0.1f + 2);

     public void testAccelerometer_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testAccelerometer_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testAccelerometer_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_ACCELEROMETER, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testAccelerometer_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_ACCELEROMETER, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testAccelerometerUncalibrated_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED,
                               RATE_FASTEST,
                               BATCHING_PERIOD);
     }

     public void testAccelUncalibrated() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED,
                               RATE_FASTEST,
                               BATCHING_PERIOD);
     }

     public void testAccelUncalibrated_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testAccelUncalibrated_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testAccelUncalibrated_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testAccelerometerLimitedAxes_fastest_batching() throws Throwable {
         runBatchingSensorTest(
                 Sensor.TYPE_ACCELEROMETER_LIMITED_AXES,
                 RATE_FASTEST,
                 BATCHING_PERIOD);
     }

     public void testAccelerometerLimitedAxes_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testAccelerometerLimitedAxes_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testAccelerometerLimitedAxes_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testAccelerometerLimitedAxesUncalibrated_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED,
                               RATE_FASTEST,
                               BATCHING_PERIOD);
     }

     public void testAccelerometerLimitedAxesUncalibrated() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED,
                               RATE_FASTEST,
                               BATCHING_PERIOD);
     }

     public void testAccelerometerLimitedAxesUncalibrated_50hz_batching() throws Throwable {
         runBatchingSensorTest(
                 Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED,
                 RATE_50HZ,
                 BATCHING_PERIOD);
     }

     public void testAccelerometerLimitedAxesUncalibrated_fastest_flush() throws Throwable {
         runFlushSensorTest(
                 Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED,
                 RATE_FASTEST,
                 BATCHING_PERIOD);
     }

     public void testAccelerometerLimitedAxesUncalibrated_50hz_flush() throws Throwable {
         runFlushSensorTest(
                 Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED,
                 RATE_50HZ,
                 BATCHING_PERIOD);
     }

     public void testMagneticField_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_MAGNETIC_FIELD, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testMagneticField_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_MAGNETIC_FIELD, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testMagneticField_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_MAGNETIC_FIELD, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testMagneticField_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_MAGNETIC_FIELD, RATE_50HZ, BATCHING_PERIOD);
     }

     @SuppressWarnings("deprecation")
     public void testOrientation_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ORIENTATION, RATE_FASTEST, BATCHING_PERIOD);
     }

     @SuppressWarnings("deprecation")
     public void testOrientation_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ORIENTATION, RATE_50HZ, BATCHING_PERIOD);
     }

     @SuppressWarnings("deprecation")
     public void testOrientation_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_ORIENTATION, RATE_FASTEST, BATCHING_PERIOD);
     }

     @SuppressWarnings("deprecation")
     public void testOrientation_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_ORIENTATION, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGyroscope_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GYROSCOPE, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testGyroscope_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GYROSCOPE, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGyroscope_fastest_flush() throws Throwable {
         runFlushSensorTest(
                 Sensor.TYPE_GYROSCOPE,
                 SensorManager.SENSOR_DELAY_FASTEST,
                 BATCHING_PERIOD);
     }

     public void testGyroscope_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_GYROSCOPE, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGyroscopeLimitedAxes_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GYROSCOPE_LIMITED_AXES, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testGyroscopeLimitedAxes_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GYROSCOPE_LIMITED_AXES, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGyroscopeLimitedAxes_fastest_flush() throws Throwable {
         runFlushSensorTest(
                 Sensor.TYPE_GYROSCOPE_LIMITED_AXES,
                 SensorManager.SENSOR_DELAY_FASTEST,
                 BATCHING_PERIOD);
     }

     public void testGyroscopeLimitedAxes_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_GYROSCOPE_LIMITED_AXES, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testPressure_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_PRESSURE, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testPressure_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_PRESSURE, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testPressure_fastest_flush() throws Throwable {
         runFlushSensorTest(
                 Sensor.TYPE_PRESSURE,
                 SensorManager.SENSOR_DELAY_FASTEST,
                 BATCHING_PERIOD);
     }

     public void testPressure_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_PRESSURE, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGravity_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GRAVITY, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testGravity_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GRAVITY, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGravity_fastest_flush() throws Throwable {
         runFlushSensorTest(
                 Sensor.TYPE_GRAVITY,
                 SensorManager.SENSOR_DELAY_FASTEST,
                 BATCHING_PERIOD);
     }

     public void testGravity_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_GRAVITY, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testRotationVector_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ROTATION_VECTOR, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testRotationVector_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testRotationVector_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_ROTATION_VECTOR, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testRotationVector_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testMagneticFieldUncalibrated_fastest_batching() throws Throwable {
         runBatchingSensorTest(
                 Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED,
                 RATE_FASTEST,
                 BATCHING_PERIOD);
     }

     public void testMagneticFieldUncalibrated_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testMagneticFieldUncalibrated_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testMagneticFieldUncalibrated_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGameRotationVector_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GAME_ROTATION_VECTOR, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testGameRotationVector_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GAME_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGameRotationVector_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_GAME_ROTATION_VECTOR, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testGameRotationVector_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_GAME_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGyroscopeUncalibrated_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GYROSCOPE_UNCALIBRATED, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testGyroscopeUncalibrated_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GYROSCOPE_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGyroscopeUncalibrated_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_GYROSCOPE_UNCALIBRATED, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testGyroscopeUncalibrated_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_GYROSCOPE_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGyroscopeLimitedAxesUncalibrated_fastest_batching() throws Throwable {
         runBatchingSensorTest(
                 Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED,
                 RATE_FASTEST,
                 BATCHING_PERIOD);
     }

     public void testGyroscopeLimitedAxesUncalibrated_50hz_batching() throws Throwable {
         runBatchingSensorTest(
                 Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED,
                 RATE_50HZ,
                 BATCHING_PERIOD);
     }

     public void testGyroscopeLimitedAxesUncalibrated_fastest_flush() throws Throwable {
         runFlushSensorTest(
                 Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED,
                 RATE_FASTEST,
                 BATCHING_PERIOD);
     }

     public void testGyroscopeLimitedAxesUncalibrated_50hz_flush() throws Throwable {
         runFlushSensorTest(
                 Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED,
                 RATE_50HZ,
                 BATCHING_PERIOD);
     }

     public void testLinearAcceleration_fastest_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_LINEAR_ACCELERATION, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testLinearAcceleration_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_LINEAR_ACCELERATION, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testLinearAcceleration_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_LINEAR_ACCELERATION, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testLinearAcceleration_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_LINEAR_ACCELERATION, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGeomagneticRotationVector_fastest_batching() throws Throwable {
         runBatchingSensorTest(
                 Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR,
                 RATE_FASTEST,
                 BATCHING_PERIOD);
     }

     public void testGeomagneticRotationVector_50hz_batching() throws Throwable {
         runBatchingSensorTest(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
     }

     public void testGeomagneticRotationVector_fastest_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR, RATE_FASTEST, BATCHING_PERIOD);
     }

     public void testGeomagneticRotationVector_50hz_flush() throws Throwable {
         runFlushSensorTest(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
     }

     private void runBatchingSensorTest(int sensorType, int rateUs, int maxBatchReportLatencySec)
             throws Throwable {
         int maxBatchReportLatencyUs = (int) TimeUnit.SECONDS.toMicros(maxBatchReportLatencySec);
         int testDurationSec = maxBatchReportLatencySec + BATCHING_PADDING_TIME_S;

         TestSensorEnvironment environment = new TestSensorEnvironment(
                 getContext(),
                 sensorType,
                 shouldEmulateSensorUnderLoad(),
                 rateUs,
                 maxBatchReportLatencyUs);
         TestSensorOperation operation =
                 TestSensorOperation.createOperation(environment, testDurationSec, TimeUnit.SECONDS);

         operation.addVerification(
                 EventBasicVerification.getDefault(
                         environment, TimeUnit.SECONDS.toMicros(testDurationSec)
                 )
         );
         if (sensorType == Sensor.TYPE_GYROSCOPE_UNCALIBRATED) {
             // Checks gyroscope uncalibrated should not have high pass filter.
             operation.addVerification(
                 MeanLargerThanVerification.getDefault(environment)
             );
         }
         executeTest(environment, operation, false /* flushExpected */);
     }

     private void runFlushSensorTest(int sensorType, int rateUs, int maxBatchReportLatencySec)
             throws Throwable {
         int maxBatchReportLatencyUs = (int) TimeUnit.SECONDS.toMicros(maxBatchReportLatencySec);
         int flushDurationSec = maxBatchReportLatencySec / 2;

         TestSensorEnvironment environment = new TestSensorEnvironment(
                 getContext(),
                 sensorType,
                 shouldEmulateSensorUnderLoad(),
                 rateUs,
                 maxBatchReportLatencyUs);
         TestSensorOperation operation = TestSensorOperation
                 .createFlushOperation(environment, flushDurationSec, TimeUnit.SECONDS);

         executeTest(environment, operation, true /* flushExpected */);
     }

     private void executeTest(
             TestSensorEnvironment environment,
             TestSensorOperation operation,
             boolean flushExpected) throws Throwable {
         SensorCtsHelper.sleep(3, TimeUnit.SECONDS);
         operation.addDefaultVerifications();

         try {
             operation.execute(getCurrentTestNode());
         } finally {
             SensorStats stats = operation.getStats();
             stats.log(TAG);

             String sensorRate;
             if (environment.getRequestedSamplingPeriodUs() == SensorManager.SENSOR_DELAY_FASTEST) {
                 sensorRate = "fastest";
             } else {
                 sensorRate = String.format("%.0fhz", environment.getFrequencyHz());
             }
             String batching = environment.getMaxReportLatencyUs() > 0 ? "_batching" : "";
             String flush = flushExpected ? "_flush" : "";
             String fileName = String.format(
                     "batching_%s_%s%s%s.txt",
                     SensorStats.getSanitizedSensorName(environment.getSensor()),
                     sensorRate,
                     batching,
                     flush);
             stats.logToFile(environment.getContext(), fileName);
         }
     }
 }
	/*
	* 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;

	import android.hardware.Sensor;
	import android.hardware.SensorManager;
	import android.hardware.cts.helpers.SensorCtsHelper;
	import android.hardware.cts.helpers.SensorStats;
	import android.hardware.cts.helpers.TestSensorEnvironment;
	import android.hardware.cts.helpers.sensoroperations.TestSensorOperation;
	import android.hardware.cts.helpers.sensorverification.EventBasicVerification;
	import android.hardware.cts.helpers.sensorverification.ISensorVerification;
	import android.hardware.cts.helpers.sensorverification.MeanLargerThanVerification;

	import java.util.concurrent.TimeUnit;

	/**
	* Set of tests to verify that sensors operate correctly when operating in batching mode.
	* This class defines tests for continuous sensors when the device is awake.
	* On-change and special sensors are tested separately inside CtsVerifier, and they are defined in:
	* {@link com.android.cts.verifier.sensors.BatchingTestActivity}.
	*
	* Each test is expected to pass even if batching is not supported for a particular sensor. This is
	* usually achieved by ensuring that {@link ISensorVerification}s fallback accordingly.
	*
	* <p>To execute these test cases, the following command can be used:</p>
	* <pre>
	* adb shell am instrument -e class android.hardware.cts.SensorBatchingTests \
	* -w android.hardware.cts/android.test.AndroidJUnitRunner
	* </pre>
	*/
	public class SensorBatchingTests extends SensorTestCase {
	private static final String TAG = "SensorBatchingTests";

	private static final int BATCHING_PERIOD = 10; // sec
	private static final int RATE_50HZ = 20000;
	private static final int RATE_FASTEST = SensorManager.SENSOR_DELAY_FASTEST;

	/**
	* An arbitrary 'padding' time slot to wait for events after batching latency expires.
	* This allows for the test to wait for event arrivals after batching was expected.
	*/
	private static final int BATCHING_PADDING_TIME_S = (int) Math.ceil(BATCHING_PERIOD * 0.1f + 2);

	public void testAccelerometer_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testAccelerometer_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testAccelerometer_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_ACCELEROMETER, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testAccelerometer_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_ACCELEROMETER, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testAccelerometerUncalibrated_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED,
	RATE_FASTEST,
	BATCHING_PERIOD);
	}

	public void testAccelUncalibrated() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED,
	RATE_FASTEST,
	BATCHING_PERIOD);
	}

	public void testAccelUncalibrated_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testAccelUncalibrated_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testAccelUncalibrated_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testAccelerometerLimitedAxes_fastest_batching() throws Throwable {
	runBatchingSensorTest(
	Sensor.TYPE_ACCELEROMETER_LIMITED_AXES,
	RATE_FASTEST,
	BATCHING_PERIOD);
	}

	public void testAccelerometerLimitedAxes_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testAccelerometerLimitedAxes_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testAccelerometerLimitedAxes_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testAccelerometerLimitedAxesUncalibrated_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED,
	RATE_FASTEST,
	BATCHING_PERIOD);
	}

	public void testAccelerometerLimitedAxesUncalibrated() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED,
	RATE_FASTEST,
	BATCHING_PERIOD);
	}

	public void testAccelerometerLimitedAxesUncalibrated_50hz_batching() throws Throwable {
	runBatchingSensorTest(
	Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED,
	RATE_50HZ,
	BATCHING_PERIOD);
	}

	public void testAccelerometerLimitedAxesUncalibrated_fastest_flush() throws Throwable {
	runFlushSensorTest(
	Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED,
	RATE_FASTEST,
	BATCHING_PERIOD);
	}

	public void testAccelerometerLimitedAxesUncalibrated_50hz_flush() throws Throwable {
	runFlushSensorTest(
	Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED,
	RATE_50HZ,
	BATCHING_PERIOD);
	}

	public void testMagneticField_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_MAGNETIC_FIELD, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testMagneticField_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_MAGNETIC_FIELD, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testMagneticField_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_MAGNETIC_FIELD, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testMagneticField_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_MAGNETIC_FIELD, RATE_50HZ, BATCHING_PERIOD);
	}

	@SuppressWarnings("deprecation")
	public void testOrientation_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ORIENTATION, RATE_FASTEST, BATCHING_PERIOD);
	}

	@SuppressWarnings("deprecation")
	public void testOrientation_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ORIENTATION, RATE_50HZ, BATCHING_PERIOD);
	}

	@SuppressWarnings("deprecation")
	public void testOrientation_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_ORIENTATION, RATE_FASTEST, BATCHING_PERIOD);
	}

	@SuppressWarnings("deprecation")
	public void testOrientation_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_ORIENTATION, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGyroscope_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GYROSCOPE, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testGyroscope_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GYROSCOPE, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGyroscope_fastest_flush() throws Throwable {
	runFlushSensorTest(
	Sensor.TYPE_GYROSCOPE,
	SensorManager.SENSOR_DELAY_FASTEST,
	BATCHING_PERIOD);
	}

	public void testGyroscope_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_GYROSCOPE, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGyroscopeLimitedAxes_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GYROSCOPE_LIMITED_AXES, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testGyroscopeLimitedAxes_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GYROSCOPE_LIMITED_AXES, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGyroscopeLimitedAxes_fastest_flush() throws Throwable {
	runFlushSensorTest(
	Sensor.TYPE_GYROSCOPE_LIMITED_AXES,
	SensorManager.SENSOR_DELAY_FASTEST,
	BATCHING_PERIOD);
	}

	public void testGyroscopeLimitedAxes_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_GYROSCOPE_LIMITED_AXES, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testPressure_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_PRESSURE, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testPressure_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_PRESSURE, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testPressure_fastest_flush() throws Throwable {
	runFlushSensorTest(
	Sensor.TYPE_PRESSURE,
	SensorManager.SENSOR_DELAY_FASTEST,
	BATCHING_PERIOD);
	}

	public void testPressure_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_PRESSURE, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGravity_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GRAVITY, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testGravity_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GRAVITY, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGravity_fastest_flush() throws Throwable {
	runFlushSensorTest(
	Sensor.TYPE_GRAVITY,
	SensorManager.SENSOR_DELAY_FASTEST,
	BATCHING_PERIOD);
	}

	public void testGravity_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_GRAVITY, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testRotationVector_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ROTATION_VECTOR, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testRotationVector_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testRotationVector_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_ROTATION_VECTOR, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testRotationVector_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testMagneticFieldUncalibrated_fastest_batching() throws Throwable {
	runBatchingSensorTest(
	Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED,
	RATE_FASTEST,
	BATCHING_PERIOD);
	}

	public void testMagneticFieldUncalibrated_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testMagneticFieldUncalibrated_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testMagneticFieldUncalibrated_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGameRotationVector_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GAME_ROTATION_VECTOR, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testGameRotationVector_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GAME_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGameRotationVector_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_GAME_ROTATION_VECTOR, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testGameRotationVector_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_GAME_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGyroscopeUncalibrated_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GYROSCOPE_UNCALIBRATED, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testGyroscopeUncalibrated_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GYROSCOPE_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGyroscopeUncalibrated_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_GYROSCOPE_UNCALIBRATED, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testGyroscopeUncalibrated_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_GYROSCOPE_UNCALIBRATED, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGyroscopeLimitedAxesUncalibrated_fastest_batching() throws Throwable {
	runBatchingSensorTest(
	Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED,
	RATE_FASTEST,
	BATCHING_PERIOD);
	}

	public void testGyroscopeLimitedAxesUncalibrated_50hz_batching() throws Throwable {
	runBatchingSensorTest(
	Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED,
	RATE_50HZ,
	BATCHING_PERIOD);
	}

	public void testGyroscopeLimitedAxesUncalibrated_fastest_flush() throws Throwable {
	runFlushSensorTest(
	Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED,
	RATE_FASTEST,
	BATCHING_PERIOD);
	}

	public void testGyroscopeLimitedAxesUncalibrated_50hz_flush() throws Throwable {
	runFlushSensorTest(
	Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED,
	RATE_50HZ,
	BATCHING_PERIOD);
	}

	public void testLinearAcceleration_fastest_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_LINEAR_ACCELERATION, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testLinearAcceleration_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_LINEAR_ACCELERATION, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testLinearAcceleration_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_LINEAR_ACCELERATION, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testLinearAcceleration_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_LINEAR_ACCELERATION, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGeomagneticRotationVector_fastest_batching() throws Throwable {
	runBatchingSensorTest(
	Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR,
	RATE_FASTEST,
	BATCHING_PERIOD);
	}

	public void testGeomagneticRotationVector_50hz_batching() throws Throwable {
	runBatchingSensorTest(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
	}

	public void testGeomagneticRotationVector_fastest_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR, RATE_FASTEST, BATCHING_PERIOD);
	}

	public void testGeomagneticRotationVector_50hz_flush() throws Throwable {
	runFlushSensorTest(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR, RATE_50HZ, BATCHING_PERIOD);
	}

	private void runBatchingSensorTest(int sensorType, int rateUs, int maxBatchReportLatencySec)
	throws Throwable {
	int maxBatchReportLatencyUs = (int) TimeUnit.SECONDS.toMicros(maxBatchReportLatencySec);
	int testDurationSec = maxBatchReportLatencySec + BATCHING_PADDING_TIME_S;

	TestSensorEnvironment environment = new TestSensorEnvironment(
	getContext(),
	sensorType,
	shouldEmulateSensorUnderLoad(),
	rateUs,
	maxBatchReportLatencyUs);
	TestSensorOperation operation =
	TestSensorOperation.createOperation(environment, testDurationSec, TimeUnit.SECONDS);

	operation.addVerification(
	EventBasicVerification.getDefault(
	environment, TimeUnit.SECONDS.toMicros(testDurationSec)
	)
	);
	if (sensorType == Sensor.TYPE_GYROSCOPE_UNCALIBRATED) {
	// Checks gyroscope uncalibrated should not have high pass filter.
	operation.addVerification(
	MeanLargerThanVerification.getDefault(environment)
	);
	}
	executeTest(environment, operation, false /* flushExpected */);
	}

	private void runFlushSensorTest(int sensorType, int rateUs, int maxBatchReportLatencySec)
	throws Throwable {
	int maxBatchReportLatencyUs = (int) TimeUnit.SECONDS.toMicros(maxBatchReportLatencySec);
	int flushDurationSec = maxBatchReportLatencySec / 2;

	TestSensorEnvironment environment = new TestSensorEnvironment(
	getContext(),
	sensorType,
	shouldEmulateSensorUnderLoad(),
	rateUs,
	maxBatchReportLatencyUs);
	TestSensorOperation operation = TestSensorOperation
	.createFlushOperation(environment, flushDurationSec, TimeUnit.SECONDS);

	executeTest(environment, operation, true /* flushExpected */);
	}

	private void executeTest(
	TestSensorEnvironment environment,
	TestSensorOperation operation,
	boolean flushExpected) throws Throwable {
	SensorCtsHelper.sleep(3, TimeUnit.SECONDS);
	operation.addDefaultVerifications();

	try {
	operation.execute(getCurrentTestNode());
	} finally {
	SensorStats stats = operation.getStats();
	stats.log(TAG);

	String sensorRate;
	if (environment.getRequestedSamplingPeriodUs() == SensorManager.SENSOR_DELAY_FASTEST) {
	sensorRate = "fastest";
	} else {
	sensorRate = String.format("%.0fhz", environment.getFrequencyHz());
	}
	String batching = environment.getMaxReportLatencyUs() > 0 ? "_batching" : "";
	String flush = flushExpected ? "_flush" : "";
	String fileName = String.format(
	"batching_%s_%s%s%s.txt",
	SensorStats.getSanitizedSensorName(environment.getSensor()),
	sensorRate,
	batching,
	flush);
	stats.logToFile(environment.getContext(), fileName);
	}
	}
	}