1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
/*
* 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 com.android.cts.verifier.sensors;
import com.android.cts.verifier.R;
import com.android.cts.verifier.sensors.base.SensorCtsVerifierTestActivity;
import android.hardware.Sensor;
import android.hardware.SensorManager;
import android.hardware.cts.helpers.TestSensorEnvironment;
import android.hardware.cts.helpers.sensoroperations.TestSensorOperation;
import android.hardware.cts.helpers.sensorverification.MeanVerification;
import java.util.concurrent.TimeUnit;
/**
* Semi-automated test that focuses on characteristics associated with Accelerometer measurements.
*/
public class AccelerometerMeasurementTestActivity extends SensorCtsVerifierTestActivity {
public AccelerometerMeasurementTestActivity() {
super(AccelerometerMeasurementTestActivity.class, true);
}
public String testFaceUp() throws Throwable {
return verifyMeasurements(
R.string.snsr_accel_test_face_up,
0, 0, SensorManager.STANDARD_GRAVITY);
}
public String testFaceDown() throws Throwable {
return delayedVerifyMeasurements(
R.string.snsr_accel_test_face_down,
0, 0, -SensorManager.STANDARD_GRAVITY);
}
public String testRightSide() throws Throwable {
return verifyMeasurements(
R.string.snsr_accel_test_right_side,
-SensorManager.STANDARD_GRAVITY, 0, 0);
}
public String testLeftSide() throws Throwable {
return verifyMeasurements(
R.string.snsr_accel_test_left_side,
SensorManager.STANDARD_GRAVITY, 0, 0);
}
public String testTopSide() throws Throwable {
return verifyMeasurements(
R.string.snsr_accel_test_top_side,
0, -SensorManager.STANDARD_GRAVITY, 0);
}
public String testBottomSide() throws Throwable {
return verifyMeasurements(
R.string.snsr_accel_test_bottom_side,
0, SensorManager.STANDARD_GRAVITY, 0);
}
/**
* This test verifies that the Accelerometer measurements are close to the expected reference
* values (range and scale).
*
* The test takes a set of samples from the sensor under test and calculates the mean of each
* axis that the sensor data collects. It then compares it against the test expectations that
* are represented by reference values and a threshold.
* The reference values are coupled to the orientation of the device. The test is susceptible to
* errors when the device is not oriented properly, or the units in which the data are reported
* and the expectations are set are different.
*
* The error message associated with the test provides the required data needed to identify any
* possible issue. It provides:
* - the thread id on which the failure occurred
* - the sensor type and sensor handle that caused the failure
* - the values representing the expectation of the test
* - the mean of values sampled from the sensor
*/
private String verifyMeasurements(float ... expectations) throws Throwable {
Thread.sleep(500 /*ms*/);
TestSensorEnvironment environment = new TestSensorEnvironment(
getApplicationContext(),
Sensor.TYPE_ACCELEROMETER,
SensorManager.SENSOR_DELAY_FASTEST);
TestSensorOperation verifyMeasurements =
TestSensorOperation.createOperation(environment, 100 /* event count */);
verifyMeasurements.addVerification(new MeanVerification(
expectations,
new float[]{1.95f, 1.95f, 1.95f} /* m / s^2 */,
new float[]{1.95f, 1.95f, 1.95f} /* m / s^2 */));
verifyMeasurements.execute(getCurrentTestNode());
return null;
}
private String delayedVerifyMeasurements(int descriptionResId, float ... expectations)
throws Throwable {
setFirstExecutionInstruction(descriptionResId);
getTestLogger().logWaitForSound();
Thread.sleep(TimeUnit.MILLISECONDS.convert(7, TimeUnit.SECONDS));
try {
return verifyMeasurements(expectations);
} finally {
playSound();
}
}
private String verifyMeasurements(int descriptionResId, float ... expectations)
throws Throwable {
setFirstExecutionInstruction(descriptionResId, R.string.snsr_device_steady);
return verifyMeasurements(expectations);
}
}
|
