/* * 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; import android.content.Context; import android.hardware.Sensor; import android.hardware.SensorManager; import android.hardware.cts.helpers.SensorCtsHelper; import android.hardware.cts.helpers.SensorNotSupportedException; import android.hardware.cts.helpers.TestSensorEnvironment; import android.hardware.cts.helpers.sensoroperations.ParallelSensorOperation; import android.hardware.cts.helpers.sensoroperations.RepeatingSensorOperation; import android.hardware.cts.helpers.sensoroperations.SequentialSensorOperation; import android.hardware.cts.helpers.sensoroperations.TestSensorOperation; import android.hardware.cts.helpers.sensorverification.EventOrderingVerification; import android.hardware.cts.helpers.sensorverification.FrequencyVerification; import java.util.Random; import java.util.concurrent.TimeUnit; /** * Set of tests that verifies proper interaction of the sensors in the platform. * * To execute these test cases, the following command can be used: * $ adb shell am instrument -e class android.hardware.cts.SensorIntegrationTests \ * -w android.hardware.cts/android.test.InstrumentationCtsTestRunner */ public class SensorIntegrationTests extends SensorTestCase { private static final String TAG = "SensorIntegrationTests"; /** * This test focuses in the interaction of continuous and batching clients for the same Sensor * under test. The verification ensures that sensor clients can interact with the System and * not affect other clients in the way. * * The test verifies for each client that the a set of sampled data arrives in order. However * each client in the test has different set of parameters that represent different types of * clients in the real world. * * A test failure might indicate that the HAL implementation does not respect the assumption * that the sensors must be independent. Activating one sensor should not cause another sensor * to deactivate or to change behavior. * It is however, acceptable that when a client is activated at a higher sampling rate, it would * cause other clients to receive data at a faster sampling rate. A client causing other clients * to receive data at a lower sampling rate is, however, not acceptable. * * The assertion associated with the test failure provides: * - the thread id on which the failure occurred * - the sensor type and sensor handle that caused the failure * - the event that caused the issue * It is important to look at the internals of the Sensor HAL to identify how the interaction * of several clients can lead to the failing state. */ public void testSensorsWithSeveralClients() throws Throwable { SensorCtsHelper.sleep(3, TimeUnit.SECONDS); final int ITERATIONS = 50; final int MAX_REPORTING_LATENCY_US = (int) TimeUnit.SECONDS.toMicros(5); final Context context = getContext(); int sensorTypes[] = { Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_GYROSCOPE }; ParallelSensorOperation operation = new ParallelSensorOperation(); for(int sensorType : sensorTypes) { TestSensorEnvironment environment = new TestSensorEnvironment( context, sensorType, shouldEmulateSensorUnderLoad(), SensorManager.SENSOR_DELAY_FASTEST); TestSensorOperation continuousOperation = TestSensorOperation.createOperation(environment, 100 /* eventCount */); continuousOperation.addVerification(new EventOrderingVerification()); operation.add(new RepeatingSensorOperation(continuousOperation, ITERATIONS)); Sensor sensor = TestSensorEnvironment.getSensor(context, sensorType); TestSensorEnvironment batchingEnvironment = new TestSensorEnvironment( context, sensorType, shouldEmulateSensorUnderLoad(), true, /* isIntegrationTest */ sensor.getMinDelay(), MAX_REPORTING_LATENCY_US); TestSensorOperation batchingOperation = TestSensorOperation.createOperation(batchingEnvironment, 100 /* eventCount */); batchingOperation.addVerification(new EventOrderingVerification()); operation.add(new RepeatingSensorOperation(batchingOperation, ITERATIONS)); } operation.execute(getCurrentTestNode()); operation.getStats().log(TAG); } /** * This test focuses in the interaction of several sensor Clients. The test characterizes by * using clients for different Sensors under Test that vary the sampling rates and report * latencies for the requests. * The verification ensures that the sensor clients can vary the parameters of their requests * without affecting other clients. * * The test verifies for each client that a set of sampled data arrives in order. However each * client in the test has different set of parameters that represent different types of clients * in the real world. * * The test can be susceptible to issues when several clients interacting with the system * actually affect the operation of other clients. * * The assertion associated with the test failure provides: * - the thread id on which the failure occurred * - the sensor type and sensor handle that caused the failure * - the event that caused the issue * It is important to look at the internals of the Sensor HAL to identify how the interaction * of several clients can lead to the failing state. */ public void testSensorsMovingRates() throws Throwable { SensorCtsHelper.sleep(3, TimeUnit.SECONDS); // use at least two instances to ensure more than one client of any given sensor is in play final int INSTANCES_TO_USE = 5; final int ITERATIONS_TO_EXECUTE = 100; ParallelSensorOperation operation = new ParallelSensorOperation(); int sensorTypes[] = { Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_GYROSCOPE }; Context context = getContext(); for(int sensorType : sensorTypes) { for(int instance = 0; instance < INSTANCES_TO_USE; ++instance) { SequentialSensorOperation sequentialOperation = new SequentialSensorOperation(); for(int iteration = 0; iteration < ITERATIONS_TO_EXECUTE; ++iteration) { TestSensorEnvironment environment = new TestSensorEnvironment( context, sensorType, shouldEmulateSensorUnderLoad(), true, /* isIntegrationTest */ generateSamplingRateInUs(sensorType), generateReportLatencyInUs()); TestSensorOperation sensorOperation = TestSensorOperation.createOperation(environment, 100 /* eventCount */); sensorOperation.addVerification(new EventOrderingVerification()); sequentialOperation.add(sensorOperation); } operation.add(sequentialOperation); } } operation.execute(getCurrentTestNode()); operation.getStats().log(TAG); } public void testAccelerometerReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_ACCELEROMETER); } public void testUncalibratedAccelerometerReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_ACCELEROMETER_UNCALIBRATED); } public void testMagneticFieldReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_MAGNETIC_FIELD); } public void testUncalibratedMagneticFieldReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED); } public void testOrientationReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_ORIENTATION); } public void testGyroscopeReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_GYROSCOPE); } public void testUncalibratedGyroscopeReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_GYROSCOPE_UNCALIBRATED); } public void testPressureReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_PRESSURE); } public void testGravityReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_GRAVITY); } public void testLinearAccelerationReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_LINEAR_ACCELERATION); } public void testRotationVectorReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_ROTATION_VECTOR); } public void testGameRotationVectorReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_GAME_ROTATION_VECTOR); } public void testGeomagneticRotationVectorReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR); } public void testAccelerometerLimitedAxesReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES); } public void testAccelerometerLimitedAxesUncalibratedReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES_UNCALIBRATED); } public void testGyroscopeLimitedAxesReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_GYROSCOPE_LIMITED_AXES); } public void testGyroscopeLimitedAxesUncalibratedReconfigureWhileActive() throws Throwable { verifySensorReconfigureWhileActive(Sensor.TYPE_GYROSCOPE_LIMITED_AXES_UNCALIBRATED); } /** * This test focuses on ensuring that an active sensor is able to be reconfigured when a new * client requests a different sampling rate. * * The test verifies that if a sensor is active with a slow sampling rate and a new client * requests a faster sampling rate, the sensor begins returning data at the faster sampling * rate. * * The assertion associated with the test failure provides: * - the thread id on which the failure occurred * - the sensor type and sensor handle that caused the failure * - the event that caused the issue * It is important to look at the internals of the Sensor HAL to identify how the interaction * of several clients can lead to the failing state. */ public void verifySensorReconfigureWhileActive(int sensorType) throws Throwable { SensorCtsHelper.sleep(3, TimeUnit.SECONDS); final int DELAY_BEFORE_CHANGING_RATE_SEC = 2; final int EVENTS_FOR_VERIFICATION = 200; Context context = getContext(); SensorManager sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE); assertNotNull("SensorService is not present in the system", sensorManager); Sensor sensor = sensorManager.getDefaultSensor(sensorType); if(sensor == null) { throw new SensorNotSupportedException(sensorType); } // Request for the sensor rate to be set to the slowest rate. ParallelSensorOperation operation = new ParallelSensorOperation(); TestSensorEnvironment environmentSlow = new TestSensorEnvironment( context, sensor, shouldEmulateSensorUnderLoad(), true, /* isIntegrationTest */ sensor.getMaxDelay(), (int)TimeUnit.SECONDS.toMicros(20)); TestSensorOperation sensorOperationSlow = TestSensorOperation.createOperation( environmentSlow, 2 * DELAY_BEFORE_CHANGING_RATE_SEC, TimeUnit.SECONDS); operation.add(sensorOperationSlow); // Create a second operation that will run in parallel and request the fastest rate after // an initial delay. The delay is to ensure that the first operation has enabled the sensor. // The sensor should begin reporting at the newly requested rate. Execute a flush prior to // the reconfiguration to ensure that the lower frequency events are not received after the // reconfiguration of the sensor. SequentialSensorOperation sequentialSensorOperation = new SequentialSensorOperation(); TestSensorEnvironment environmentFast = new TestSensorEnvironment( context, sensor, shouldEmulateSensorUnderLoad(), true, /* isIntegrationTest */ sensor.getMinDelay(), 0 /* max reporting latency */); // Create the flush operation with a delay to ensure the low frequency configuration was // handled and executed. Use the original environment since the flush operation will // register a new listener and reconfigure the sensor. TestSensorOperation flushOperation = TestSensorOperation.createFlushOperation( environmentSlow, DELAY_BEFORE_CHANGING_RATE_SEC, TimeUnit.SECONDS); sequentialSensorOperation.add(flushOperation); // Create the reconfiguration request and add it after the flush TestSensorOperation sensorOperationFast = TestSensorOperation.createOperation( environmentFast, EVENTS_FOR_VERIFICATION); sensorOperationFast.addVerification(FrequencyVerification.getDefault(environmentFast)); sequentialSensorOperation.add(sensorOperationFast); // Add the sequential operation containing the flush and high frequency request to the // existing parallel operation that already contains the low frequency request. operation.add(sequentialSensorOperation); operation.execute(getCurrentTestNode()); operation.getStats().log(TAG); } /** * Regress: * - b/10641388 */ public void testAccelerometerAccelerometerStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_ACCELEROMETER); } public void testAccelerometerGyroscopeStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_GYROSCOPE); } public void testAccelerometerMagneticFieldStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_MAGNETIC_FIELD); } public void testGyroscopeAccelerometerStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_GYROSCOPE, Sensor.TYPE_ACCELEROMETER); } public void testGyroscopeGyroscopeStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_GYROSCOPE, Sensor.TYPE_GYROSCOPE); } public void testGyroscopeMagneticFieldStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_GYROSCOPE, Sensor.TYPE_MAGNETIC_FIELD); } public void testMagneticFieldAccelerometerStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_ACCELEROMETER); } public void testMagneticFieldGyroscopeStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_GYROSCOPE); } public void testMagneticFieldMagneticFieldStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_MAGNETIC_FIELD); } public void testAccelerometerLimitedAxesAccelerometerLimitedAxesStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES, Sensor.TYPE_ACCELEROMETER_LIMITED_AXES); } public void testAccelerometerLimitedAxesGyroscopeLimitedAxesStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES, Sensor.TYPE_GYROSCOPE_LIMITED_AXES); } public void testAccelerometerLimitedAxesMagneticFieldStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_ACCELEROMETER_LIMITED_AXES, Sensor.TYPE_MAGNETIC_FIELD); } public void testGyroscopeLimitedAxesAccelerometerLimitedAxesStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_GYROSCOPE_LIMITED_AXES, Sensor.TYPE_ACCELEROMETER_LIMITED_AXES); } public void testGyroscopeLimitedAxesGyroscopeLimitedAxesStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_GYROSCOPE_LIMITED_AXES, Sensor.TYPE_GYROSCOPE_LIMITED_AXES); } public void testGyroscopeLimitedAxesMagneticFieldStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_GYROSCOPE_LIMITED_AXES, Sensor.TYPE_MAGNETIC_FIELD); } public void testMagneticFieldAccelerometerLimitedAxesStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_ACCELEROMETER_LIMITED_AXES); } public void testMagneticFieldGyroscopeLimitedAxesStopping() throws Throwable { verifySensorStoppingInteraction(Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_GYROSCOPE_LIMITED_AXES); } /** * This test verifies that starting/stopping a particular Sensor client in the System does not * affect other sensor clients. * the test is used to validate that starting/stopping operations are independent on several * sensor clients. * * The test verifies for each client that the a set of sampled data arrives in order. However * each client in the test has different set of parameters that represent different types of * clients in the real world. * * The test can be susceptible to issues when several clients interacting with the system * actually affect the operation of other clients. * * The assertion associated with the test failure provides: * - the thread id on which the failure occurred * - the sensor type and sensor handle that caused the failure * - the event that caused the issue * It is important to look at the internals of the Sensor HAL to identify how the interaction * of several clients can lead to the failing state. */ public void verifySensorStoppingInteraction( int sensorTypeTestee, int sensorTypeTester) throws Throwable { SensorCtsHelper.sleep(3, TimeUnit.SECONDS); Context context = getContext(); TestSensorEnvironment testerEnvironment = new TestSensorEnvironment( context, sensorTypeTester, shouldEmulateSensorUnderLoad(), SensorManager.SENSOR_DELAY_FASTEST); TestSensorOperation tester = TestSensorOperation.createOperation(testerEnvironment, 100 /* event count */); tester.addVerification(new EventOrderingVerification()); TestSensorEnvironment testeeEnvironment = new TestSensorEnvironment( context, sensorTypeTestee, shouldEmulateSensorUnderLoad(), SensorManager.SENSOR_DELAY_FASTEST); TestSensorOperation testee = TestSensorOperation.createOperation(testeeEnvironment, 100 /* event count */); testee.addVerification(new EventOrderingVerification()); ParallelSensorOperation operation = new ParallelSensorOperation(); operation.add(tester, testee); operation.execute(getCurrentTestNode()); operation.getStats().log(TAG); testee = testee.clone(); testee.execute(getCurrentTestNode()); testee.getStats().log(TAG); } /** * Private helpers. */ private final Random mGenerator = new Random(); private int generateSamplingRateInUs(int sensorType) { int rate; switch(mGenerator.nextInt(5)) { case 0: rate = SensorManager.SENSOR_DELAY_FASTEST; break; default: Sensor sensor = TestSensorEnvironment.getSensor(getContext(), sensorType); int maxSamplingRate = sensor.getMinDelay(); rate = maxSamplingRate * mGenerator.nextInt(10); } return rate; } private int generateReportLatencyInUs() { long reportLatencyUs = TimeUnit.SECONDS.toMicros(mGenerator.nextInt(5) + 1); return (int) reportLatencyUs; } }