1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <camera/CameraMetadata.h> 18 #include <gmock/gmock.h> 19 #include <gtest/gtest.h> 20 21 #include "../v4l2_wrapper_mock.h" 22 #include "converter_interface_mock.h" 23 #include "metadata_common.h" 24 #include "partial_metadata_factory.h" 25 #include "test_common.h" 26 27 using testing::AtMost; 28 using testing::Expectation; 29 using testing::Return; 30 using testing::SetArgPointee; 31 using testing::Test; 32 using testing::_; 33 34 namespace v4l2_camera_hal { 35 36 class PartialMetadataFactoryTest : public Test { 37 protected: 38 virtual void SetUp() { 39 mock_device_.reset(new V4L2WrapperMock()); 40 mock_converter_.reset(new ConverterInterfaceMock<uint8_t, int32_t>()); 41 // Nullify control so an error will be thrown 42 // if a test doesn't construct it. 43 control_.reset(); 44 } 45 46 virtual void ExpectControlTags() { 47 ASSERT_EQ(control_->StaticTags().size(), 1u); 48 EXPECT_EQ(control_->StaticTags()[0], options_tag_); 49 ASSERT_EQ(control_->ControlTags().size(), 1u); 50 EXPECT_EQ(control_->ControlTags()[0], delegate_tag_); 51 ASSERT_EQ(control_->DynamicTags().size(), 1u); 52 EXPECT_EQ(control_->DynamicTags()[0], delegate_tag_); 53 } 54 55 virtual void ExpectControlOptions(const std::vector<uint8_t>& options) { 56 // Options should be available. 57 android::CameraMetadata metadata; 58 ASSERT_EQ(control_->PopulateStaticFields(&metadata), 0); 59 EXPECT_EQ(metadata.entryCount(), 1u); 60 ExpectMetadataEq(metadata, options_tag_, options); 61 } 62 63 virtual void ExpectControlValue(uint8_t value) { 64 android::CameraMetadata metadata; 65 ASSERT_EQ(control_->PopulateDynamicFields(&metadata), 0); 66 EXPECT_EQ(metadata.entryCount(), 1u); 67 ExpectMetadataEq(metadata, delegate_tag_, value); 68 } 69 70 std::unique_ptr<Control<uint8_t>> control_; 71 std::shared_ptr<ConverterInterfaceMock<uint8_t, int32_t>> mock_converter_; 72 std::shared_ptr<V4L2WrapperMock> mock_device_; 73 74 // Need tags that match the data type (uint8_t) being passed. 75 const int32_t delegate_tag_ = ANDROID_COLOR_CORRECTION_ABERRATION_MODE; 76 const int32_t options_tag_ = 77 ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES; 78 }; 79 80 class DISABLED_PartialMetadataFactoryTest : public PartialMetadataFactoryTest { 81 }; 82 83 TEST_F(PartialMetadataFactoryTest, FixedState) { 84 uint8_t value = 13; 85 std::unique_ptr<State<uint8_t>> state = FixedState(delegate_tag_, value); 86 87 ASSERT_EQ(state->StaticTags().size(), 0u); 88 ASSERT_EQ(state->ControlTags().size(), 0u); 89 ASSERT_EQ(state->DynamicTags().size(), 1u); 90 EXPECT_EQ(state->DynamicTags()[0], delegate_tag_); 91 92 android::CameraMetadata metadata; 93 ASSERT_EQ(state->PopulateDynamicFields(&metadata), 0); 94 EXPECT_EQ(metadata.entryCount(), 1u); 95 ExpectMetadataEq(metadata, delegate_tag_, value); 96 } 97 98 TEST_F(PartialMetadataFactoryTest, NoEffectMenu) { 99 std::vector<uint8_t> test_options = {9, 8, 12}; 100 control_ = 101 NoEffectMenuControl<uint8_t>(delegate_tag_, options_tag_, test_options); 102 ASSERT_NE(control_, nullptr); 103 104 ExpectControlTags(); 105 106 // Options should be available. 107 ExpectControlOptions(test_options); 108 // Default value should be test_options[0]. 109 ExpectControlValue(test_options[0]); 110 } 111 112 TEST_F(PartialMetadataFactoryTest, NoEffectGenericMenu) { 113 uint8_t default_val = 9; 114 control_ = NoEffectControl<uint8_t>( 115 ControlType::kMenu, delegate_tag_, options_tag_, default_val); 116 ASSERT_NE(control_, nullptr); 117 118 ExpectControlTags(); 119 120 // Options should be available. 121 ExpectControlOptions({default_val}); 122 // |default_val| should be default option. 123 ExpectControlValue(default_val); 124 } 125 126 TEST_F(PartialMetadataFactoryTest, NoEffectSlider) { 127 std::vector<uint8_t> test_range = {9, 12}; 128 control_ = NoEffectSliderControl<uint8_t>( 129 delegate_tag_, options_tag_, test_range[0], test_range[1]); 130 ASSERT_NE(control_, nullptr); 131 132 ExpectControlTags(); 133 134 // Single option should be available. 135 ExpectControlOptions(test_range); 136 // Default value should be the minimum (test_range[0]). 137 ExpectControlValue(test_range[0]); 138 } 139 140 TEST_F(PartialMetadataFactoryTest, NoEffectGenericSlider) { 141 uint8_t default_val = 9; 142 control_ = NoEffectControl<uint8_t>( 143 ControlType::kSlider, delegate_tag_, options_tag_, default_val); 144 ASSERT_NE(control_, nullptr); 145 146 ExpectControlTags(); 147 148 // Range containing only |default_val| should be available. 149 ExpectControlOptions({default_val, default_val}); 150 // |default_val| should be default option. 151 ExpectControlValue(default_val); 152 } 153 154 TEST_F(PartialMetadataFactoryTest, V4L2FactoryQueryFail) { 155 int control_id = 55; 156 // Should query the device. 157 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)).WillOnce(Return(-1)); 158 control_ = V4L2Control<uint8_t>(ControlType::kMenu, 159 delegate_tag_, 160 options_tag_, 161 mock_device_, 162 control_id, 163 mock_converter_); 164 // Failure, should return null. 165 ASSERT_EQ(control_, nullptr); 166 } 167 168 TEST_F(PartialMetadataFactoryTest, V4L2FactoryQueryBadType) { 169 int control_id = 55; 170 v4l2_query_ext_ctrl query_result; 171 query_result.type = V4L2_CTRL_TYPE_CTRL_CLASS; 172 // Should query the device. 173 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)) 174 .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0))); 175 control_ = V4L2Control<uint8_t>(ControlType::kMenu, 176 delegate_tag_, 177 options_tag_, 178 mock_device_, 179 control_id, 180 mock_converter_); 181 // Failure, should return null. 182 ASSERT_EQ(control_, nullptr); 183 } 184 185 TEST_F(PartialMetadataFactoryTest, V4L2FactoryQueryBadRange) { 186 int control_id = 55; 187 v4l2_query_ext_ctrl query_result; 188 query_result.type = V4L2_CTRL_TYPE_MENU; 189 query_result.minimum = 10; 190 query_result.maximum = 1; // Less than minimum. 191 // Should query the device. 192 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)) 193 .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0))); 194 control_ = V4L2Control<uint8_t>(ControlType::kMenu, 195 delegate_tag_, 196 options_tag_, 197 mock_device_, 198 control_id, 199 mock_converter_); 200 // Failure, should return null. 201 ASSERT_EQ(control_, nullptr); 202 } 203 204 TEST_F(PartialMetadataFactoryTest, V4L2FactoryTypeRequestMenuMismatch) { 205 int control_id = 55; 206 v4l2_query_ext_ctrl query_result; 207 query_result.type = V4L2_CTRL_TYPE_INTEGER; 208 query_result.minimum = 1; 209 query_result.maximum = 7; 210 query_result.step = 2; 211 // Have conversions for values 1-5, by step size 2. 212 std::map<int32_t, uint8_t> conversion_map = {{1, 10}, {3, 30}, {5, 50}}; 213 214 // Should query the device. 215 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)) 216 .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0))); 217 218 // If you ask for a Menu, but the V4L2 control is a slider type, that's bad. 219 control_ = V4L2Control<uint8_t>(ControlType::kMenu, 220 delegate_tag_, 221 options_tag_, 222 mock_device_, 223 control_id, 224 mock_converter_); 225 ASSERT_EQ(control_, nullptr); 226 } 227 228 TEST_F(PartialMetadataFactoryTest, V4L2FactoryTypeRequestSliderMismatch) { 229 int control_id = 55; 230 v4l2_query_ext_ctrl query_result; 231 query_result.type = V4L2_CTRL_TYPE_MENU; 232 query_result.minimum = 1; 233 query_result.maximum = 7; 234 query_result.step = 2; 235 // Have conversions for values 1-5, by step size 2. 236 std::map<int32_t, uint8_t> conversion_map = {{1, 10}, {3, 30}, {5, 50}}; 237 238 // Should query the device. 239 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)) 240 .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0))); 241 242 // If you ask for a Slider and get a Menu, that's bad. 243 control_ = V4L2Control<uint8_t>(ControlType::kSlider, 244 delegate_tag_, 245 options_tag_, 246 mock_device_, 247 control_id, 248 mock_converter_); 249 ASSERT_EQ(control_, nullptr); 250 } 251 252 TEST_F(DISABLED_PartialMetadataFactoryTest, V4L2FactoryMenu) { 253 // TODO(b/30921166): Correct Menu support so this can be re-enabled. 254 int control_id = 55; 255 v4l2_query_ext_ctrl query_result; 256 query_result.type = V4L2_CTRL_TYPE_MENU; 257 query_result.minimum = 1; 258 query_result.maximum = 7; 259 query_result.step = 2; 260 // Have conversions for values 1-5, by step size 2. 261 std::map<int32_t, uint8_t> conversion_map = {{1, 10}, {3, 30}, {5, 50}}; 262 263 // Should query the device. 264 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)) 265 .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0))); 266 // Should convert values. 267 std::vector<uint8_t> expected_options; 268 for (auto kv : conversion_map) { 269 EXPECT_CALL(*mock_converter_, V4L2ToMetadata(kv.first, _)) 270 .WillOnce(DoAll(SetArgPointee<1>(kv.second), Return(0))); 271 expected_options.push_back(kv.second); 272 } 273 // Will fail to convert 7 with -EINVAL, shouldn't matter. 274 EXPECT_CALL(*mock_converter_, V4L2ToMetadata(7, _)).WillOnce(Return(-EINVAL)); 275 276 control_ = V4L2Control<uint8_t>(ControlType::kMenu, 277 delegate_tag_, 278 options_tag_, 279 mock_device_, 280 control_id, 281 mock_converter_); 282 ASSERT_NE(control_, nullptr); 283 284 ExpectControlTags(); 285 ExpectControlOptions(expected_options); 286 } 287 288 TEST_F(DISABLED_PartialMetadataFactoryTest, V4L2FactoryMenuConversionFail) { 289 // TODO(b/30921166): Correct Menu support so this can be re-enabled. 290 int control_id = 55; 291 v4l2_query_ext_ctrl query_result; 292 query_result.type = V4L2_CTRL_TYPE_MENU; 293 query_result.minimum = 1; 294 query_result.maximum = 7; 295 query_result.step = 2; 296 297 // Should query the device. 298 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)) 299 .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0))); 300 // Conversion fails with non-EINVAL error. 301 EXPECT_CALL(*mock_converter_, V4L2ToMetadata(_, _)).WillOnce(Return(-1)); 302 303 control_ = V4L2Control<uint8_t>(ControlType::kMenu, 304 delegate_tag_, 305 options_tag_, 306 mock_device_, 307 control_id, 308 mock_converter_); 309 ASSERT_EQ(control_, nullptr); 310 } 311 312 TEST_F(DISABLED_PartialMetadataFactoryTest, V4L2FactoryMenuNoConversions) { 313 // TODO(b/30921166): Correct Menu support so this can be re-enabled. 314 int control_id = 55; 315 v4l2_query_ext_ctrl query_result; 316 query_result.type = V4L2_CTRL_TYPE_MENU; 317 query_result.minimum = 1; 318 query_result.maximum = 1; 319 query_result.step = 1; 320 321 // Should query the device. 322 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)) 323 .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0))); 324 // Conversion fails with -EINVAL error. 325 EXPECT_CALL(*mock_converter_, V4L2ToMetadata(1, _)).WillOnce(Return(-EINVAL)); 326 327 control_ = V4L2Control<uint8_t>(ControlType::kMenu, 328 delegate_tag_, 329 options_tag_, 330 mock_device_, 331 control_id, 332 mock_converter_); 333 // Since there were no convertable options, should fail. 334 ASSERT_EQ(control_, nullptr); 335 } 336 337 TEST_F(PartialMetadataFactoryTest, V4L2FactoryInteger) { 338 int control_id = 55; 339 v4l2_query_ext_ctrl query_result; 340 query_result.type = V4L2_CTRL_TYPE_INTEGER; 341 query_result.minimum = 1; 342 query_result.maximum = 7; 343 query_result.step = 2; 344 // Have conversions for values 1 & 7. 345 std::map<int32_t, uint8_t> conversion_map = {{1, 10}, {7, 70}}; 346 347 // Should query the device. 348 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)) 349 .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0))); 350 // Should convert values. 351 std::vector<uint8_t> expected_options; 352 for (auto kv : conversion_map) { 353 EXPECT_CALL(*mock_converter_, V4L2ToMetadata(kv.first, _)) 354 .WillOnce(DoAll(SetArgPointee<1>(kv.second), Return(0))); 355 expected_options.push_back(kv.second); 356 } 357 358 control_ = V4L2Control<uint8_t>(ControlType::kSlider, 359 delegate_tag_, 360 options_tag_, 361 mock_device_, 362 control_id, 363 mock_converter_); 364 ASSERT_NE(control_, nullptr); 365 366 ExpectControlTags(); 367 ExpectControlOptions(expected_options); 368 369 // Should be fitting converted values to steps. 370 uint8_t set_val = 10; 371 android::CameraMetadata metadata; 372 EXPECT_EQ(UpdateMetadata(&metadata, delegate_tag_, set_val), 0); 373 EXPECT_CALL(*mock_converter_, MetadataToV4L2(set_val, _)) 374 .WillOnce(DoAll(SetArgPointee<1>(4), Return(0))); 375 // When it calls into the device, the 4 returned above should be 376 // rounded down to the step value of 3. 377 EXPECT_CALL(*mock_device_, SetControl(control_id, 3, _)).WillOnce(Return(0)); 378 EXPECT_EQ(control_->SetRequestValues(metadata), 0); 379 } 380 381 TEST_F(PartialMetadataFactoryTest, V4L2FactoryIntegerFailedConversion) { 382 int control_id = 55; 383 v4l2_query_ext_ctrl query_result; 384 query_result.type = V4L2_CTRL_TYPE_INTEGER; 385 query_result.minimum = 1; 386 query_result.maximum = 7; 387 query_result.step = 2; 388 389 // Should query the device. 390 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)) 391 .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0))); 392 // Fail to convert a value. Even -EINVAL is bad in this case. 393 EXPECT_CALL(*mock_converter_, V4L2ToMetadata(1, _)).WillOnce(Return(-EINVAL)); 394 395 control_ = V4L2Control<uint8_t>(ControlType::kSlider, 396 delegate_tag_, 397 options_tag_, 398 mock_device_, 399 control_id, 400 mock_converter_); 401 ASSERT_EQ(control_, nullptr); 402 } 403 404 TEST_F(PartialMetadataFactoryTest, V4L2FallbackMenu) { 405 uint8_t default_val = 9; 406 int control_id = 55; 407 408 // Should query the device. 409 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)).WillOnce(Return(-1)); 410 411 // Shouldn't fail, should fall back to menu control. 412 control_ = V4L2ControlOrDefault<uint8_t>(ControlType::kMenu, 413 delegate_tag_, 414 options_tag_, 415 mock_device_, 416 control_id, 417 mock_converter_, 418 default_val); 419 ASSERT_NE(control_, nullptr); 420 421 ExpectControlTags(); 422 423 // Options should be available. 424 ExpectControlOptions({default_val}); 425 // |default_val| should be default option. 426 ExpectControlValue(default_val); 427 } 428 429 TEST_F(PartialMetadataFactoryTest, V4L2FallbackSlider) { 430 uint8_t default_val = 9; 431 int control_id = 55; 432 433 // Should query the device. 434 EXPECT_CALL(*mock_device_, QueryControl(control_id, _)).WillOnce(Return(-1)); 435 436 // Shouldn't fail, should fall back to slider control. 437 control_ = V4L2ControlOrDefault<uint8_t>(ControlType::kSlider, 438 delegate_tag_, 439 options_tag_, 440 mock_device_, 441 control_id, 442 mock_converter_, 443 default_val); 444 ASSERT_NE(control_, nullptr); 445 446 ExpectControlTags(); 447 448 // Range containing only |default_val| should be available. 449 ExpectControlOptions({default_val, default_val}); 450 // |default_val| should be default option. 451 ExpectControlValue(default_val); 452 } 453 454 } // namespace v4l2_camera_hal 455
