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