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 "control.h"
18
19 #include <camera/CameraMetadata.h>
20 #include <gmock/gmock.h>
21 #include <gtest/gtest.h>
22
23 #include "control_delegate_interface_mock.h"
24 #include "control_options_interface_mock.h"
25 #include "metadata_common.h"
26 #include "test_common.h"
27
28 using testing::AtMost;
29 using testing::DoAll;
30 using testing::Expectation;
31 using testing::Return;
32 using testing::SetArgPointee;
33 using testing::Test;
34 using testing::_;
35
36 namespace v4l2_camera_hal {
37
38 class ControlTest : public Test {
39 protected:
SetUp()40 virtual void SetUp() {
41 mock_delegate_.reset(new ControlDelegateInterfaceMock<uint8_t>());
42 mock_options_.reset(new ControlOptionsInterfaceMock<uint8_t>());
43 // Nullify control so an error will be thrown if a test doesn't call
44 // PrepareControl.
45 control_.reset();
46 }
47
PrepareControl()48 virtual void PrepareControl() {
49 // Use this method after all the EXPECT_CALLs to pass ownership of the mocks
50 // to the device.
51 std::unique_ptr<TaggedControlDelegate<uint8_t>> delegate =
52 std::make_unique<TaggedControlDelegate<uint8_t>>(
53 delegate_tag_, std::move(mock_delegate_));
54 std::unique_ptr<TaggedControlOptions<uint8_t>> options =
55 std::make_unique<TaggedControlOptions<uint8_t>>(
56 report_options_ ? options_tag_ : DO_NOT_REPORT_OPTIONS,
57 std::move(mock_options_));
58 if (use_options_) {
59 control_.reset(
60 new Control<uint8_t>(std::move(delegate), std::move(options)));
61 } else {
62 control_.reset(new Control<uint8_t>(std::move(delegate)));
63 }
64 }
65
ExpectTags()66 virtual void ExpectTags() {
67 if (use_options_ && report_options_) {
68 ASSERT_EQ(control_->StaticTags().size(), 1u);
69 EXPECT_EQ(control_->StaticTags()[0], options_tag_);
70 } else {
71 EXPECT_TRUE(control_->StaticTags().empty());
72 }
73 // Controls use the same delgate, and thus tag, for getting and setting.
74 ASSERT_EQ(control_->ControlTags().size(), 1u);
75 EXPECT_EQ(control_->ControlTags()[0], delegate_tag_);
76 ASSERT_EQ(control_->DynamicTags().size(), 1u);
77 EXPECT_EQ(control_->DynamicTags()[0], delegate_tag_);
78 }
79
ExpectOptions(const std::vector<uint8_t> & options)80 virtual void ExpectOptions(const std::vector<uint8_t>& options) {
81 // Options should be available.
82 android::CameraMetadata metadata;
83 ASSERT_EQ(control_->PopulateStaticFields(&metadata), 0);
84 if (use_options_ && report_options_) {
85 EXPECT_EQ(metadata.entryCount(), 1u);
86 ExpectMetadataEq(metadata, options_tag_, options);
87 } else {
88 EXPECT_EQ(metadata.entryCount(), 0u);
89 // Shouldn't be expecting any options.
90 EXPECT_TRUE(options.empty());
91 }
92 }
93
ExpectValue(uint8_t value)94 virtual void ExpectValue(uint8_t value) {
95 android::CameraMetadata metadata;
96 ASSERT_EQ(control_->PopulateDynamicFields(&metadata), 0);
97 EXPECT_EQ(metadata.entryCount(), 1u);
98 ExpectMetadataEq(metadata, delegate_tag_, value);
99 }
100
101 std::unique_ptr<Control<uint8_t>> control_;
102 std::unique_ptr<ControlDelegateInterfaceMock<uint8_t>> mock_delegate_;
103 std::unique_ptr<ControlOptionsInterfaceMock<uint8_t>> mock_options_;
104 bool use_options_ = true;
105 bool report_options_ = true;
106
107 // Need tags that match the data type (uint8_t) being passed.
108 const int32_t delegate_tag_ = ANDROID_COLOR_CORRECTION_ABERRATION_MODE;
109 const int32_t options_tag_ =
110 ANDROID_COLOR_CORRECTION_AVAILABLE_ABERRATION_MODES;
111 };
112
TEST_F(ControlTest,Tags)113 TEST_F(ControlTest, Tags) {
114 PrepareControl();
115 ExpectTags();
116 }
117
TEST_F(ControlTest,TagsNoOptions)118 TEST_F(ControlTest, TagsNoOptions) {
119 use_options_ = false;
120 PrepareControl();
121 ExpectTags();
122 }
123
TEST_F(ControlTest,TagsUnreportedOptions)124 TEST_F(ControlTest, TagsUnreportedOptions) {
125 report_options_ = false;
126 PrepareControl();
127 ExpectTags();
128 }
129
TEST_F(ControlTest,PopulateStatic)130 TEST_F(ControlTest, PopulateStatic) {
131 std::vector<uint8_t> expected{1, 10, 20};
132 EXPECT_CALL(*mock_options_, MetadataRepresentation())
133 .WillOnce(Return(expected));
134 PrepareControl();
135 ExpectOptions(expected);
136 }
137
TEST_F(ControlTest,PopulateStaticNoOptions)138 TEST_F(ControlTest, PopulateStaticNoOptions) {
139 use_options_ = false;
140 PrepareControl();
141 ExpectOptions({});
142 }
143
TEST_F(ControlTest,PopulateStaticUnreportedOptions)144 TEST_F(ControlTest, PopulateStaticUnreportedOptions) {
145 report_options_ = false;
146 PrepareControl();
147 ExpectOptions({});
148 }
149
TEST_F(ControlTest,PopulateDynamic)150 TEST_F(ControlTest, PopulateDynamic) {
151 uint8_t test_option = 99;
152 EXPECT_CALL(*mock_delegate_, GetValue(_))
153 .WillOnce(DoAll(SetArgPointee<0>(test_option), Return(0)));
154 PrepareControl();
155 ExpectValue(test_option);
156 }
157
TEST_F(ControlTest,PopulateDynamicNoOptions)158 TEST_F(ControlTest, PopulateDynamicNoOptions) {
159 // Lack of options shouldn't change anything for PopulateDynamic.
160 use_options_ = false;
161 uint8_t test_option = 99;
162 EXPECT_CALL(*mock_delegate_, GetValue(_))
163 .WillOnce(DoAll(SetArgPointee<0>(test_option), Return(0)));
164 PrepareControl();
165 ExpectValue(test_option);
166 }
167
TEST_F(ControlTest,PopulateDynamicUnreportedOptions)168 TEST_F(ControlTest, PopulateDynamicUnreportedOptions) {
169 // Lack of reported options shouldn't change anything for PopulateDynamic.
170 report_options_ = false;
171 uint8_t test_option = 99;
172 EXPECT_CALL(*mock_delegate_, GetValue(_))
173 .WillOnce(DoAll(SetArgPointee<0>(test_option), Return(0)));
174 PrepareControl();
175 ExpectValue(test_option);
176 }
177
TEST_F(ControlTest,PopulateDynamicFail)178 TEST_F(ControlTest, PopulateDynamicFail) {
179 int err = -99;
180 EXPECT_CALL(*mock_delegate_, GetValue(_)).WillOnce(Return(err));
181 PrepareControl();
182
183 android::CameraMetadata metadata;
184 EXPECT_EQ(control_->PopulateDynamicFields(&metadata), err);
185
186 // Should not have added an entry.
187 EXPECT_TRUE(metadata.isEmpty());
188 }
189
TEST_F(ControlTest,PopulateTemplate)190 TEST_F(ControlTest, PopulateTemplate) {
191 int template_type = 3;
192 uint8_t default_value = 123;
193 EXPECT_CALL(*mock_options_, DefaultValueForTemplate(template_type, _))
194 .WillOnce(DoAll(SetArgPointee<1>(default_value), Return(0)));
195 PrepareControl();
196
197 android::CameraMetadata metadata;
198 EXPECT_EQ(control_->PopulateTemplateRequest(template_type, &metadata), 0);
199 ExpectMetadataEq(metadata, delegate_tag_, default_value);
200 }
201
TEST_F(ControlTest,PopulateTemplateFail)202 TEST_F(ControlTest, PopulateTemplateFail) {
203 int template_type = 3;
204 int err = 10;
205 EXPECT_CALL(*mock_options_, DefaultValueForTemplate(template_type, _))
206 .WillOnce(Return(err));
207 PrepareControl();
208
209 android::CameraMetadata metadata;
210 EXPECT_EQ(control_->PopulateTemplateRequest(template_type, &metadata), err);
211 }
212
TEST_F(ControlTest,PopulateTemplateOptionless)213 TEST_F(ControlTest, PopulateTemplateOptionless) {
214 use_options_ = false;
215 int template_type = 3;
216 uint8_t value = 12;
217 // Should use delegate instead of options if no options.
218 EXPECT_CALL(*mock_delegate_, GetValue(_))
219 .WillOnce(DoAll(SetArgPointee<0>(value), Return(0)));
220 PrepareControl();
221
222 android::CameraMetadata metadata;
223 EXPECT_EQ(control_->PopulateTemplateRequest(template_type, &metadata), 0);
224 ExpectMetadataEq(metadata, delegate_tag_, value);
225 }
226
TEST_F(ControlTest,PopulateTemplateOptionlessFail)227 TEST_F(ControlTest, PopulateTemplateOptionlessFail) {
228 use_options_ = false;
229 int template_type = 3;
230 int err = 10;
231 // Should use delegate instead of options if no options.
232 EXPECT_CALL(*mock_delegate_, GetValue(_)).WillOnce(Return(err));
233 PrepareControl();
234
235 android::CameraMetadata metadata;
236 EXPECT_EQ(control_->PopulateTemplateRequest(template_type, &metadata), err);
237 }
238
TEST_F(ControlTest,PopulateTemplateUnreportedOptions)239 TEST_F(ControlTest, PopulateTemplateUnreportedOptions) {
240 report_options_ = false;
241 int template_type = 3;
242 uint8_t default_value = 123;
243 // Unreported options should behave just like reported ones for templating.
244 EXPECT_CALL(*mock_options_, DefaultValueForTemplate(template_type, _))
245 .WillOnce(DoAll(SetArgPointee<1>(default_value), Return(0)));
246 PrepareControl();
247
248 android::CameraMetadata metadata;
249 EXPECT_EQ(control_->PopulateTemplateRequest(template_type, &metadata), 0);
250 ExpectMetadataEq(metadata, delegate_tag_, default_value);
251 }
252
TEST_F(ControlTest,PopulateTemplateUnreportedOptionsFail)253 TEST_F(ControlTest, PopulateTemplateUnreportedOptionsFail) {
254 report_options_ = false;
255 int template_type = 3;
256 int err = 10;
257 // Unreported options should behave just like reported ones for templating.
258 EXPECT_CALL(*mock_options_, DefaultValueForTemplate(template_type, _))
259 .WillOnce(Return(err));
260 PrepareControl();
261
262 android::CameraMetadata metadata;
263 EXPECT_EQ(control_->PopulateTemplateRequest(template_type, &metadata), err);
264 }
265
TEST_F(ControlTest,SupportsRequest)266 TEST_F(ControlTest, SupportsRequest) {
267 android::CameraMetadata metadata;
268 uint8_t test_option = 123;
269 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_option), 0);
270
271 EXPECT_CALL(*mock_options_, IsSupported(test_option)).WillOnce(Return(true));
272 PrepareControl();
273
274 EXPECT_EQ(control_->SupportsRequestValues(metadata), true);
275 }
276
TEST_F(ControlTest,SupportsRequestNoOptions)277 TEST_F(ControlTest, SupportsRequestNoOptions) {
278 use_options_ = false;
279 android::CameraMetadata metadata;
280 uint8_t test_option = 123;
281 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_option), 0);
282 PrepareControl();
283
284 EXPECT_EQ(control_->SupportsRequestValues(metadata), true);
285 }
286
TEST_F(ControlTest,SupportsRequestUnreportedOptions)287 TEST_F(ControlTest, SupportsRequestUnreportedOptions) {
288 report_options_ = false;
289 android::CameraMetadata metadata;
290 uint8_t test_option = 123;
291 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_option), 0);
292
293 EXPECT_CALL(*mock_options_, IsSupported(test_option)).WillOnce(Return(true));
294 PrepareControl();
295
296 EXPECT_EQ(control_->SupportsRequestValues(metadata), true);
297 }
298
TEST_F(ControlTest,SupportsRequestFail)299 TEST_F(ControlTest, SupportsRequestFail) {
300 android::CameraMetadata metadata;
301 uint8_t test_option = 123;
302 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_option), 0);
303
304 EXPECT_CALL(*mock_options_, IsSupported(test_option)).WillOnce(Return(false));
305 PrepareControl();
306
307 EXPECT_EQ(control_->SupportsRequestValues(metadata), false);
308 }
309
TEST_F(ControlTest,SupportsRequestUnreportedOptionsFail)310 TEST_F(ControlTest, SupportsRequestUnreportedOptionsFail) {
311 report_options_ = false;
312 android::CameraMetadata metadata;
313 uint8_t test_option = 123;
314 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_option), 0);
315
316 // Unreported options should still be checked against.
317 EXPECT_CALL(*mock_options_, IsSupported(test_option)).WillOnce(Return(false));
318 PrepareControl();
319
320 EXPECT_EQ(control_->SupportsRequestValues(metadata), false);
321 }
322
TEST_F(ControlTest,SupportsRequestInvalidNumber)323 TEST_F(ControlTest, SupportsRequestInvalidNumber) {
324 // Start with a request for multiple values.
325 android::CameraMetadata metadata;
326 std::vector<uint8_t> test_data = {1, 2, 3};
327 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_data), 0);
328 PrepareControl();
329 EXPECT_EQ(control_->SupportsRequestValues(metadata), false);
330 }
331
TEST_F(ControlTest,SupportsRequestInvalidNumberNoOptions)332 TEST_F(ControlTest, SupportsRequestInvalidNumberNoOptions) {
333 use_options_ = false;
334 // Start with a request for multiple values.
335 android::CameraMetadata metadata;
336 std::vector<uint8_t> test_data = {1, 2, 3};
337 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_data), 0);
338 PrepareControl();
339 // Not having any explicit options does not exempt a control
340 // from requiring the right number of values.
341 EXPECT_EQ(control_->SupportsRequestValues(metadata), false);
342 }
343
TEST_F(ControlTest,SupportsRequestEmpty)344 TEST_F(ControlTest, SupportsRequestEmpty) {
345 android::CameraMetadata metadata;
346 PrepareControl();
347 EXPECT_EQ(control_->SupportsRequestValues(metadata), true);
348 }
349
TEST_F(ControlTest,SetRequest)350 TEST_F(ControlTest, SetRequest) {
351 android::CameraMetadata metadata;
352 uint8_t test_option = 123;
353 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_option), 0);
354
355 Expectation validation_check =
356 EXPECT_CALL(*mock_options_, IsSupported(test_option))
357 .WillOnce(Return(true));
358 EXPECT_CALL(*mock_delegate_, SetValue(test_option))
359 .After(validation_check)
360 .WillOnce(Return(0));
361 PrepareControl();
362
363 // Make the request.
364 ASSERT_EQ(control_->SetRequestValues(metadata), 0);
365 }
366
TEST_F(ControlTest,SetRequestNoOptions)367 TEST_F(ControlTest, SetRequestNoOptions) {
368 use_options_ = false;
369 android::CameraMetadata metadata;
370 uint8_t test_option = 123;
371 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_option), 0);
372
373 // No options, no validation check.
374 EXPECT_CALL(*mock_delegate_, SetValue(test_option)).WillOnce(Return(0));
375 PrepareControl();
376
377 // Make the request.
378 ASSERT_EQ(control_->SetRequestValues(metadata), 0);
379 }
380
TEST_F(ControlTest,SetRequestUnreportedOptions)381 TEST_F(ControlTest, SetRequestUnreportedOptions) {
382 report_options_ = false;
383 android::CameraMetadata metadata;
384 uint8_t test_option = 123;
385 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_option), 0);
386
387 // Unreported options still get a validation check.
388 Expectation validation_check =
389 EXPECT_CALL(*mock_options_, IsSupported(test_option))
390 .WillOnce(Return(true));
391 EXPECT_CALL(*mock_delegate_, SetValue(test_option))
392 .After(validation_check)
393 .WillOnce(Return(0));
394 PrepareControl();
395
396 // Make the request.
397 ASSERT_EQ(control_->SetRequestValues(metadata), 0);
398 }
399
TEST_F(ControlTest,SetRequestSettingFail)400 TEST_F(ControlTest, SetRequestSettingFail) {
401 android::CameraMetadata metadata;
402 uint8_t test_option = 123;
403 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_option), 0);
404
405 int err = 99;
406 Expectation validation_check =
407 EXPECT_CALL(*mock_options_, IsSupported(test_option))
408 .WillOnce(Return(true));
409 EXPECT_CALL(*mock_delegate_, SetValue(test_option))
410 .After(validation_check)
411 .WillOnce(Return(err));
412 PrepareControl();
413
414 EXPECT_EQ(control_->SetRequestValues(metadata), err);
415 }
416
TEST_F(ControlTest,SetRequestValidationFail)417 TEST_F(ControlTest, SetRequestValidationFail) {
418 android::CameraMetadata metadata;
419 uint8_t test_option = 123;
420 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_option), 0);
421
422 EXPECT_CALL(*mock_options_, IsSupported(test_option)).WillOnce(Return(false));
423 PrepareControl();
424
425 EXPECT_EQ(control_->SetRequestValues(metadata), -EINVAL);
426 }
427
TEST_F(ControlTest,SetRequestInvalidNumber)428 TEST_F(ControlTest, SetRequestInvalidNumber) {
429 // Start with a request for multiple values.
430 android::CameraMetadata metadata;
431 std::vector<uint8_t> test_data = {1, 2, 3};
432 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_data), 0);
433
434 PrepareControl();
435 EXPECT_EQ(control_->SetRequestValues(metadata), -EINVAL);
436 }
437
TEST_F(ControlTest,SetRequestInvalidNumberNoOptions)438 TEST_F(ControlTest, SetRequestInvalidNumberNoOptions) {
439 use_options_ = false;
440 // Start with a request for multiple values.
441 android::CameraMetadata metadata;
442 std::vector<uint8_t> test_data = {1, 2, 3};
443 ASSERT_EQ(UpdateMetadata(&metadata, delegate_tag_, test_data), 0);
444
445 PrepareControl();
446 // Not having explicit options does not change that an incorrect
447 // number of values is invalid.
448 EXPECT_EQ(control_->SetRequestValues(metadata), -EINVAL);
449 }
450
TEST_F(ControlTest,SetRequestEmpty)451 TEST_F(ControlTest, SetRequestEmpty) {
452 // Should do nothing.
453 android::CameraMetadata metadata;
454 PrepareControl();
455 EXPECT_EQ(control_->SetRequestValues(metadata), 0);
456 }
457
458 } // namespace v4l2_camera_hal
459