linear_acceleration_fusion_algorithm_using_accelerometer_unittest.cc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293
  1. // Copyright 2017 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "services/device/generic_sensor/linear_acceleration_fusion_algorithm_using_accelerometer.h"
  5. #include "base/memory/raw_ptr.h"
  6. #include "base/memory/ref_counted.h"
  7. #include "base/test/task_environment.h"
  8. #include "services/device/generic_sensor/fake_platform_sensor_fusion.h"
  9. #include "services/device/generic_sensor/generic_sensor_consts.h"
  10. #include "testing/gtest/include/gtest/gtest.h"
  11. namespace device {
  12. namespace {
  13. class LinearAccelerationFusionAlgorithmUsingAccelerometerTest
  14. : public testing::Test {
  15. public:
  16. LinearAccelerationFusionAlgorithmUsingAccelerometerTest() {
  17. auto fusion_algorithm =
  18. std::make_unique<LinearAccelerationFusionAlgorithmUsingAccelerometer>();
  19. fusion_algorithm_ = fusion_algorithm.get();
  20. fake_fusion_sensor_ = base::MakeRefCounted<FakePlatformSensorFusion>(
  21. std::move(fusion_algorithm));
  22. fusion_algorithm_->set_fusion_sensor(fake_fusion_sensor_.get());
  23. EXPECT_EQ(1UL, fusion_algorithm_->source_types().size());
  24. }
  25. void VerifyNoFusedDataOnFirstReading(double acceleration_x,
  26. double acceleration_y,
  27. double acceleration_z,
  28. double timestamp) {
  29. SensorReading reading;
  30. reading.accel.x = acceleration_x;
  31. reading.accel.y = acceleration_y;
  32. reading.accel.z = acceleration_z;
  33. reading.accel.timestamp.value() = timestamp;
  34. fake_fusion_sensor_->SetSensorReading(mojom::SensorType::ACCELEROMETER,
  35. reading,
  36. true /* sensor_reading_success */);
  37. SensorReading fused_reading;
  38. EXPECT_FALSE(fusion_algorithm_->GetFusedData(
  39. mojom::SensorType::ACCELEROMETER, &fused_reading));
  40. }
  41. void VerifyLinearAcceleration(double acceleration_x,
  42. double acceleration_y,
  43. double acceleration_z,
  44. double timestamp,
  45. double expected_linear_acceleration_x,
  46. double expected_linear_acceleration_y,
  47. double expected_linear_acceleration_z) {
  48. SensorReading reading;
  49. reading.accel.x = acceleration_x;
  50. reading.accel.y = acceleration_y;
  51. reading.accel.z = acceleration_z;
  52. reading.accel.timestamp.value() = timestamp;
  53. fake_fusion_sensor_->SetSensorReading(mojom::SensorType::ACCELEROMETER,
  54. reading,
  55. true /* sensor_reading_success */);
  56. SensorReading fused_reading;
  57. EXPECT_TRUE(fusion_algorithm_->GetFusedData(
  58. mojom::SensorType::ACCELEROMETER, &fused_reading));
  59. EXPECT_NEAR(expected_linear_acceleration_x, fused_reading.accel.x,
  60. kEpsilon);
  61. EXPECT_NEAR(expected_linear_acceleration_y, fused_reading.accel.y,
  62. kEpsilon);
  63. EXPECT_NEAR(expected_linear_acceleration_z, fused_reading.accel.z,
  64. kEpsilon);
  65. }
  66. void VerifyLinearAccelerationWhenAccelerometerReadingDifferentNonZeroXYZ(
  67. double timestamp1,
  68. double timestamp2,
  69. double timestamp3) {
  70. double acceleration_x = 1.0;
  71. double acceleration_y = 2.0;
  72. double acceleration_z = 3.0;
  73. VerifyNoFusedDataOnFirstReading(acceleration_x, acceleration_y,
  74. acceleration_z, timestamp1);
  75. acceleration_x = 4.0;
  76. acceleration_y = 5.0;
  77. acceleration_z = 6.0;
  78. double expected_linear_acceleration_x = 0.6666666666;
  79. double expected_linear_acceleration_y = 0.8333333333;
  80. double expected_linear_acceleration_z = 1.0;
  81. VerifyLinearAcceleration(acceleration_x, acceleration_y, acceleration_z,
  82. timestamp2, expected_linear_acceleration_x,
  83. expected_linear_acceleration_y,
  84. expected_linear_acceleration_z);
  85. acceleration_x = 7.0;
  86. acceleration_y = 8.0;
  87. acceleration_z = 9.0;
  88. expected_linear_acceleration_x = 0.4782608695;
  89. expected_linear_acceleration_y = 0.5;
  90. expected_linear_acceleration_z = 0.5217391304;
  91. VerifyLinearAcceleration(acceleration_x, acceleration_y, acceleration_z,
  92. timestamp3, expected_linear_acceleration_x,
  93. expected_linear_acceleration_y,
  94. expected_linear_acceleration_z);
  95. }
  96. protected:
  97. base::test::TaskEnvironment task_environment_;
  98. scoped_refptr<FakePlatformSensorFusion> fake_fusion_sensor_;
  99. raw_ptr<LinearAccelerationFusionAlgorithmUsingAccelerometer>
  100. fusion_algorithm_;
  101. };
  102. } // namespace
  103. TEST_F(LinearAccelerationFusionAlgorithmUsingAccelerometerTest,
  104. NoAccelerometerReading) {
  105. fusion_algorithm_->SetFrequency(10.0);
  106. SensorReading reading;
  107. fake_fusion_sensor_->SetSensorReading(mojom::SensorType::ACCELEROMETER,
  108. reading,
  109. false /* sensor_reading_success */);
  110. SensorReading fused_reading;
  111. EXPECT_FALSE(fusion_algorithm_->GetFusedData(mojom::SensorType::ACCELEROMETER,
  112. &fused_reading));
  113. }
  114. TEST_F(LinearAccelerationFusionAlgorithmUsingAccelerometerTest,
  115. NoFusedDataOnFirstReading) {
  116. fusion_algorithm_->SetFrequency(10.0);
  117. double acceleration_x = 1.0;
  118. double acceleration_y = 2.0;
  119. double acceleration_z = 3.0;
  120. double timestamp = 1.0;
  121. VerifyNoFusedDataOnFirstReading(acceleration_x, acceleration_y,
  122. acceleration_z, timestamp);
  123. }
  124. TEST_F(LinearAccelerationFusionAlgorithmUsingAccelerometerTest,
  125. AccelerometerReadingAllZero) {
  126. fusion_algorithm_->SetFrequency(10.0);
  127. double acceleration_x = 0.0;
  128. double acceleration_y = 0.0;
  129. double acceleration_z = 0.0;
  130. double timestamp = 1.0;
  131. VerifyNoFusedDataOnFirstReading(acceleration_x, acceleration_y,
  132. acceleration_z, timestamp);
  133. timestamp = 2.0;
  134. double expected_linear_acceleration_x = 0.0;
  135. double expected_linear_acceleration_y = 0.0;
  136. double expected_linear_acceleration_z = 0.0;
  137. VerifyLinearAcceleration(acceleration_x, acceleration_y, acceleration_z,
  138. timestamp, expected_linear_acceleration_x,
  139. expected_linear_acceleration_y,
  140. expected_linear_acceleration_z);
  141. }
  142. TEST_F(LinearAccelerationFusionAlgorithmUsingAccelerometerTest,
  143. AccelerometerReadingNonZeroX) {
  144. fusion_algorithm_->SetFrequency(10.0);
  145. double acceleration_x = 1.0;
  146. double acceleration_y = 0.0;
  147. double acceleration_z = 0.0;
  148. double timestamp = 1.0;
  149. VerifyNoFusedDataOnFirstReading(acceleration_x, acceleration_y,
  150. acceleration_z, timestamp);
  151. acceleration_x = 2.0;
  152. timestamp = 2.0;
  153. double expected_linear_acceleration_x = 0.3333333333;
  154. double expected_linear_acceleration_y = 0.0;
  155. double expected_linear_acceleration_z = 0.0;
  156. VerifyLinearAcceleration(acceleration_x, acceleration_y, acceleration_z,
  157. timestamp, expected_linear_acceleration_x,
  158. expected_linear_acceleration_y,
  159. expected_linear_acceleration_z);
  160. }
  161. TEST_F(LinearAccelerationFusionAlgorithmUsingAccelerometerTest,
  162. AccelerometerReadingNonZeroY) {
  163. fusion_algorithm_->SetFrequency(10.0);
  164. double acceleration_x = 0.0;
  165. double acceleration_y = 1.0;
  166. double acceleration_z = 0.0;
  167. double timestamp = 1.0;
  168. VerifyNoFusedDataOnFirstReading(acceleration_x, acceleration_y,
  169. acceleration_z, timestamp);
  170. acceleration_y = 2.0;
  171. timestamp = 2.0;
  172. double expected_linear_acceleration_x = 0.0;
  173. double expected_linear_acceleration_y = 0.3333333333;
  174. double expected_linear_acceleration_z = 0.0;
  175. VerifyLinearAcceleration(acceleration_x, acceleration_y, acceleration_z,
  176. timestamp, expected_linear_acceleration_x,
  177. expected_linear_acceleration_y,
  178. expected_linear_acceleration_z);
  179. }
  180. TEST_F(LinearAccelerationFusionAlgorithmUsingAccelerometerTest,
  181. AccelerometerReadingNonZeroZ) {
  182. fusion_algorithm_->SetFrequency(10.0);
  183. double acceleration_x = 0.0;
  184. double acceleration_y = 0.0;
  185. double acceleration_z = 1.0;
  186. double timestamp = 1.0;
  187. VerifyNoFusedDataOnFirstReading(acceleration_x, acceleration_y,
  188. acceleration_z, timestamp);
  189. acceleration_z = 2.0;
  190. timestamp = 2.0;
  191. double expected_linear_acceleration_x = 0.0;
  192. double expected_linear_acceleration_y = 0.0;
  193. double expected_linear_acceleration_z = 0.3333333333;
  194. VerifyLinearAcceleration(acceleration_x, acceleration_y, acceleration_z,
  195. timestamp, expected_linear_acceleration_x,
  196. expected_linear_acceleration_y,
  197. expected_linear_acceleration_z);
  198. }
  199. TEST_F(LinearAccelerationFusionAlgorithmUsingAccelerometerTest,
  200. AccelerometerReadingSameNonZeroXYZ) {
  201. fusion_algorithm_->SetFrequency(10.0);
  202. double acceleration = 1.0;
  203. double timestamp = 1.0;
  204. VerifyNoFusedDataOnFirstReading(acceleration, acceleration, acceleration,
  205. timestamp);
  206. acceleration = 2.0;
  207. timestamp = 2.0;
  208. double expected_linear_acceleration = 0.3333333333;
  209. VerifyLinearAcceleration(acceleration, acceleration, acceleration, timestamp,
  210. expected_linear_acceleration,
  211. expected_linear_acceleration,
  212. expected_linear_acceleration);
  213. acceleration = 3.0;
  214. timestamp = 3.0;
  215. expected_linear_acceleration = 0.1739130434;
  216. VerifyLinearAcceleration(acceleration, acceleration, acceleration, timestamp,
  217. expected_linear_acceleration,
  218. expected_linear_acceleration,
  219. expected_linear_acceleration);
  220. }
  221. TEST_F(LinearAccelerationFusionAlgorithmUsingAccelerometerTest,
  222. AccelerometerReadingDifferentNonZeroXYZ) {
  223. fusion_algorithm_->SetFrequency(10.0);
  224. double timestamp1 = 1.0;
  225. double timestamp2 = 2.0;
  226. double timestamp3 = 3.0;
  227. VerifyLinearAccelerationWhenAccelerometerReadingDifferentNonZeroXYZ(
  228. timestamp1, timestamp2, timestamp3);
  229. }
  230. TEST_F(LinearAccelerationFusionAlgorithmUsingAccelerometerTest,
  231. StopSensorShouldClearAllInternalStatisticalData) {
  232. fusion_algorithm_->SetFrequency(10.0);
  233. double timestamp1 = 1.0;
  234. double timestamp2 = 2.0;
  235. double timestamp3 = 3.0;
  236. VerifyLinearAccelerationWhenAccelerometerReadingDifferentNonZeroXYZ(
  237. timestamp1, timestamp2, timestamp3);
  238. fusion_algorithm_->Reset();
  239. // After sensor stops, all internal statistical data are reset. When using
  240. // the same accelerometer data but different timestamps, the linear
  241. // acceleration fused data should be the same as before.
  242. fusion_algorithm_->SetFrequency(10.0);
  243. double timestamp4 = 4.0;
  244. double timestamp5 = 5.0;
  245. double timestamp6 = 6.0;
  246. VerifyLinearAccelerationWhenAccelerometerReadingDifferentNonZeroXYZ(
  247. timestamp4, timestamp5, timestamp6);
  248. }
  249. } // namespace device