1/*
2 * Copyright (c) 2021-2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include <gtest/gtest.h>
17
18#define private public
19#define protected public
20#define UNIT_TEST 1
21#include "foundation/utils/constants.h"
22#include "pipeline/core/compatible_check.h"
23#include "plugin/common/any.h"
24#include "plugin/common/plugin_audio_tags.h"
25#include "plugin/common/plugin_meta.h"
26
27using namespace testing::ext;
28
29using namespace std;
30using namespace OHOS::Media::Plugin;
31
32namespace OHOS::Media::Test {
33HWTEST(TestApplyCapability, mime_Test, TestSize.Level1)
34{
35    Capability wildcard {"*"};
36    Capability audioWildcard {"audio/*"};
37    Capability testWildcard {"test/*"};
38    Capability wrongWildcard {"/audio*"};
39    Capability wrongCapability {"wrong"};
40    Capability rawMimeCapability {"audio/raw"};
41    Capability mpegMimeCapability {"audio/mpeg"};
42
43    Capability out;
44    ASSERT_TRUE(Pipeline::MergeCapability(audioWildcard, wildcard, out));
45    ASSERT_TRUE(out.mime == audioWildcard.mime);
46    ASSERT_TRUE(out.keys.empty());
47
48    ASSERT_FALSE(Pipeline::MergeCapability(wrongWildcard, wildcard, out));
49    ASSERT_TRUE(out.mime.empty());
50    ASSERT_TRUE(out.keys.empty());
51
52    ASSERT_FALSE(Pipeline::MergeCapability(wrongCapability, wildcard, out));
53    ASSERT_TRUE(out.mime.empty());
54    ASSERT_TRUE(out.keys.empty());
55
56    ASSERT_FALSE(Pipeline::MergeCapability(wrongCapability, audioWildcard, out));
57    ASSERT_TRUE(out.mime.empty());
58    ASSERT_TRUE(out.keys.empty());
59
60
61    ASSERT_TRUE(Pipeline::MergeCapability(rawMimeCapability, wildcard, out));
62    ASSERT_TRUE(out.mime == rawMimeCapability.mime);
63    ASSERT_TRUE(out.keys.empty());
64
65    ASSERT_TRUE(Pipeline::MergeCapability(rawMimeCapability, audioWildcard, out));
66    ASSERT_TRUE(out.mime == rawMimeCapability.mime);
67    ASSERT_TRUE(out.keys.empty());
68
69    ASSERT_FALSE(Pipeline::MergeCapability(rawMimeCapability, testWildcard, out));
70    ASSERT_TRUE(out.mime.empty());
71    ASSERT_TRUE(out.keys.empty());
72
73    ASSERT_FALSE(Pipeline::MergeCapability(rawMimeCapability, mpegMimeCapability, out));
74    ASSERT_TRUE(out.mime.empty());
75    ASSERT_TRUE(out.keys.empty());
76
77    ASSERT_FALSE(Pipeline::MergeCapability(rawMimeCapability, wrongWildcard, out));
78    ASSERT_TRUE(out.mime.empty());
79    ASSERT_TRUE(out.keys.empty());
80}
81
82HWTEST(TestMergeCapabilityKeys, SingleType1_Test, TestSize.Level1)
83{
84    Capability wildMimeCapability("*");
85    Capability out;
86
87    Capability rawFixedMimeCapability (MEDIA_MIME_AUDIO_RAW);
88    rawFixedMimeCapability.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000);
89
90    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability, wildMimeCapability, out));
91    ASSERT_TRUE(out.mime.empty());
92    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
93
94    Capability rawFixedMimeCapability2 (MEDIA_MIME_AUDIO_MPEG);
95    rawFixedMimeCapability2.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000);
96
97    // fix apply with fix
98    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability, rawFixedMimeCapability2, out));
99    ASSERT_TRUE(out.mime.empty());
100    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
101
102    // apply failed
103    Capability rawFixedMimeCapability3 (MEDIA_MIME_AUDIO_RAW);
104    rawFixedMimeCapability3.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000);
105    ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability, rawFixedMimeCapability3, out));
106    ASSERT_TRUE(out.mime.empty());
107    ASSERT_TRUE(out.keys.empty());
108
109    Capability rawListMimeCapability {MEDIA_MIME_AUDIO_RAW};
110    rawListMimeCapability.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {8000, 32000, 48000, 44100});
111
112    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawListMimeCapability, wildMimeCapability, out));
113    ASSERT_TRUE(out.mime.empty());
114    auto disCaps = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
115    ASSERT_TRUE(disCaps[0] == 8000);
116    ASSERT_TRUE(disCaps[1] == 32000);
117    ASSERT_TRUE(disCaps[2] == 48000);
118    ASSERT_TRUE(disCaps[3] == 44100);
119
120    // fix apply with discrete
121    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability, rawListMimeCapability, out));
122    ASSERT_TRUE(out.mime.empty());
123    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
124
125    // apply failed
126    Capability rawFixedMimeCapability4 (MEDIA_MIME_AUDIO_RAW);
127    rawFixedMimeCapability4.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000);
128    ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability4, rawListMimeCapability, out));
129    ASSERT_TRUE(out.mime.empty());
130    ASSERT_TRUE(out.keys.empty());
131}
132
133HWTEST(TestMergeCapabilityKeys, SingleType2_Test, TestSize.Level1)
134{
135    Capability wildMimeCapability("*");
136    Capability out;
137    Capability rawFixedMimeCapability (MEDIA_MIME_AUDIO_RAW);
138    rawFixedMimeCapability.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000);
139    Capability rawListMimeCapability {MEDIA_MIME_AUDIO_RAW};
140    rawListMimeCapability.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {8000, 32000, 48000, 44100});
141    // discrete apply with discrete
142    Capability rawListMimeCapability2 {MEDIA_MIME_AUDIO_RAW};
143    rawListMimeCapability2.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 48000, 44100});
144    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawListMimeCapability2, rawListMimeCapability, out));
145    ASSERT_TRUE(out.mime.empty());
146    auto tmp1 = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
147    ASSERT_TRUE(tmp1.size() == 2);
148    ASSERT_TRUE(tmp1[0] == 48000);
149    ASSERT_TRUE(tmp1[1] == 44100);
150    // discrete apply with discrete
151    Capability rawListMimeCapability3 {MEDIA_MIME_AUDIO_RAW};
152    rawListMimeCapability3.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 44100});
153    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawListMimeCapability3, rawListMimeCapability, out));
154    ASSERT_TRUE(out.mime.empty());
155    auto tmp2 = Plugin::AnyCast<Plugin::FixedCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
156    ASSERT_TRUE(tmp2 == 44100);
157    // discrete apply with discrete failed
158    Capability rawListMimeCapability4 {MEDIA_MIME_AUDIO_RAW};
159    rawListMimeCapability4.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 4100});
160    ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawListMimeCapability4, rawListMimeCapability, out));
161    ASSERT_TRUE(out.mime.empty());
162    ASSERT_TRUE(out.keys.empty());
163    Capability rawIntervalMimeCapability {MEDIA_MIME_AUDIO_RAW};
164    rawIntervalMimeCapability.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 48000);
165    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, wildMimeCapability, out));
166    ASSERT_TRUE(out.mime.empty());
167    auto intCaps = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
168    ASSERT_TRUE(intCaps.first == 8000);
169    ASSERT_TRUE(intCaps.second == 48000);
170    // inter apply with fix
171    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability, rawIntervalMimeCapability, out));
172    ASSERT_TRUE(out.mime.empty());
173    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
174    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, rawFixedMimeCapability, out));
175    ASSERT_TRUE(out.mime.empty());
176    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
177    Capability rawFixedMimeCapability5 (MEDIA_MIME_AUDIO_RAW);
178    rawFixedMimeCapability5.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000);
179    ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawFixedMimeCapability5, rawIntervalMimeCapability, out));
180    ASSERT_TRUE(out.mime.empty());
181    ASSERT_TRUE(out.keys.empty());
182}
183
184HWTEST(TestMergeCapabilityKeys, SingleType3_Test, TestSize.Level1)
185{
186    Capability wildMimeCapability("*");
187    Capability out;
188    Capability rawIntervalMimeCapability {MEDIA_MIME_AUDIO_RAW};
189    rawIntervalMimeCapability.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 48000);
190    // inter apply with inter
191    Capability rawIntervalMimeCapability2 {MEDIA_MIME_AUDIO_RAW};
192    rawIntervalMimeCapability2.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 3000, 9000);
193    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability2, rawIntervalMimeCapability, out));
194    ASSERT_TRUE(out.mime.empty());
195    auto intCaps2 = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
196    ASSERT_TRUE(intCaps2.first == 8000);
197    ASSERT_TRUE(intCaps2.second == 9000);
198
199    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, rawIntervalMimeCapability2, out));
200    ASSERT_TRUE(out.mime.empty());
201    auto intCaps3 = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
202    ASSERT_TRUE(intCaps3.first == 8000);
203    ASSERT_TRUE(intCaps3.second == 9000);
204
205    Capability rawIntervalMimeCapability3 {MEDIA_MIME_AUDIO_RAW};
206    rawIntervalMimeCapability3.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 3000, 4000);
207    ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability3, rawIntervalMimeCapability, out));
208    ASSERT_TRUE(out.mime.empty());
209    ASSERT_TRUE(out.keys.empty());
210
211    // inter apply with discrete
212    Capability rawListMimeCapability5 {MEDIA_MIME_AUDIO_RAW};
213    rawListMimeCapability5.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 4100});
214    ASSERT_FALSE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, rawListMimeCapability5, out));
215    ASSERT_TRUE(out.mime.empty());
216    ASSERT_TRUE(out.keys.empty());
217
218    Capability rawListMimeCapability6 {MEDIA_MIME_AUDIO_RAW};
219    rawListMimeCapability6.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 44100});
220    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, rawListMimeCapability6, out));
221    ASSERT_TRUE(out.mime.empty());
222    auto intCaps4 = Plugin::AnyCast<Plugin::FixedCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
223    ASSERT_TRUE(intCaps4 == 44100);
224
225    Capability rawListMimeCapability7 {MEDIA_MIME_AUDIO_RAW};
226    rawListMimeCapability7.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 40000, 44100});
227    ASSERT_TRUE(Pipeline::MergeCapabilityKeys(rawIntervalMimeCapability, rawListMimeCapability7, out));
228    ASSERT_TRUE(out.mime.empty());
229    auto intCaps5 = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
230    ASSERT_TRUE(intCaps5.size() == 2);
231    ASSERT_TRUE(intCaps5[0] == 40000);
232    ASSERT_TRUE(intCaps5[1] == 44100);
233}
234
235HWTEST(TestMergeCapability, SingleType1_Test, TestSize.Level1)
236{
237    Capability wildMimeCapability("*");
238    Capability out;
239
240    Capability rawFixedMimeCapability (MEDIA_MIME_AUDIO_RAW);
241    rawFixedMimeCapability.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000);
242
243    ASSERT_TRUE(Pipeline::MergeCapability(rawFixedMimeCapability, wildMimeCapability, out));
244    ASSERT_TRUE(out.mime == rawFixedMimeCapability.mime);
245    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
246
247    Capability rawFixedMimeCapability2 (MEDIA_MIME_AUDIO_RAW);
248    rawFixedMimeCapability2.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000);
249
250    // fix apply with fix
251    ASSERT_TRUE(Pipeline::MergeCapability(rawFixedMimeCapability, rawFixedMimeCapability2, out));
252    ASSERT_TRUE(out.mime == rawFixedMimeCapability.mime);
253    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
254
255    // apply failed
256    Capability rawFixedMimeCapability3 (MEDIA_MIME_AUDIO_RAW);
257    rawFixedMimeCapability3.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000);
258    ASSERT_FALSE(Pipeline::MergeCapability(rawFixedMimeCapability, rawFixedMimeCapability3, out));
259    ASSERT_TRUE(out.mime.empty());
260    ASSERT_TRUE(out.keys.empty());
261
262    Capability rawListMimeCapability {MEDIA_MIME_AUDIO_RAW};
263    rawListMimeCapability.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {8000, 32000, 48000, 44100});
264
265    ASSERT_TRUE(Pipeline::MergeCapability(rawListMimeCapability, wildMimeCapability, out));
266    ASSERT_TRUE(out.mime == rawListMimeCapability.mime);
267    auto disCaps = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
268    ASSERT_TRUE(disCaps[0] == 8000);
269    ASSERT_TRUE(disCaps[1] == 32000);
270    ASSERT_TRUE(disCaps[2] == 48000);
271    ASSERT_TRUE(disCaps[3] == 44100);
272
273    // fix apply with discrete
274    ASSERT_TRUE(Pipeline::MergeCapability(rawFixedMimeCapability, rawListMimeCapability, out));
275    ASSERT_TRUE(out.mime == rawFixedMimeCapability.mime);
276    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
277
278    // apply failed
279    Capability rawFixedMimeCapability4 (MEDIA_MIME_AUDIO_RAW);
280    rawFixedMimeCapability4.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000);
281    ASSERT_FALSE(Pipeline::MergeCapability(rawFixedMimeCapability4, rawListMimeCapability, out));
282    ASSERT_TRUE(out.mime.empty());
283    ASSERT_TRUE(out.keys.empty());
284}
285
286HWTEST(TestMergeCapability, SingleType2_Test, TestSize.Level1)
287{
288    Capability wildMimeCapability("*");
289    Capability out;
290    Capability rawFixedMimeCapability (MEDIA_MIME_AUDIO_RAW);
291    rawFixedMimeCapability.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000);
292    Capability rawListMimeCapability {MEDIA_MIME_AUDIO_RAW};
293    rawListMimeCapability.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {8000, 32000, 48000, 44100});
294    // discrete apply with discrete
295    Capability rawListMimeCapability2 {MEDIA_MIME_AUDIO_RAW};
296    rawListMimeCapability2.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 48000, 44100});
297    ASSERT_TRUE(Pipeline::MergeCapability(rawListMimeCapability2, rawListMimeCapability, out));
298    ASSERT_TRUE(out.mime == rawListMimeCapability2.mime);
299    auto tmp1 = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
300    ASSERT_TRUE(tmp1.size() == 2);
301    ASSERT_TRUE(tmp1[0] == 48000);
302    ASSERT_TRUE(tmp1[1] == 44100);
303    // discrete apply with discrete
304    Capability rawListMimeCapability3 {MEDIA_MIME_AUDIO_RAW};
305    rawListMimeCapability3.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 44100});
306    ASSERT_TRUE(Pipeline::MergeCapability(rawListMimeCapability3, rawListMimeCapability, out));
307    ASSERT_TRUE(out.mime == rawListMimeCapability3.mime);
308    auto tmp2 = Plugin::AnyCast<Plugin::FixedCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
309    ASSERT_TRUE(tmp2 == 44100);
310    // discrete apply with discrete failed
311    Capability rawListMimeCapability4 {MEDIA_MIME_AUDIO_RAW};
312    rawListMimeCapability4.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 4100});
313    ASSERT_FALSE(Pipeline::MergeCapability(rawListMimeCapability4, rawListMimeCapability, out));
314    ASSERT_TRUE(out.mime.empty());
315    ASSERT_TRUE(out.keys.empty());
316    Capability rawIntervalMimeCapability {MEDIA_MIME_AUDIO_RAW};
317    rawIntervalMimeCapability.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 48000);
318    ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability, wildMimeCapability, out));
319    ASSERT_TRUE(out.mime == rawIntervalMimeCapability.mime);
320    auto intCaps = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
321    ASSERT_TRUE(intCaps.first == 8000);
322    ASSERT_TRUE(intCaps.second == 48000);
323    // inter apply with fix
324    ASSERT_TRUE(Pipeline::MergeCapability(rawFixedMimeCapability, rawIntervalMimeCapability, out));
325    ASSERT_TRUE(out.mime == rawFixedMimeCapability.mime);
326    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
327    ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability, rawFixedMimeCapability, out));
328    ASSERT_TRUE(out.mime == rawIntervalMimeCapability.mime);
329    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
330    Capability rawFixedMimeCapability5 (MEDIA_MIME_AUDIO_RAW);
331    rawFixedMimeCapability5.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 4000);
332    ASSERT_FALSE(Pipeline::MergeCapability(rawFixedMimeCapability5, rawIntervalMimeCapability, out));
333    ASSERT_TRUE(out.mime.empty());
334    ASSERT_TRUE(out.keys.empty());
335}
336
337HWTEST(TestMergeCapability, SingleType3_Test, TestSize.Level1)
338{
339    Capability wildMimeCapability("*");
340    Capability out;
341    Capability rawIntervalMimeCapability {MEDIA_MIME_AUDIO_RAW};
342    rawIntervalMimeCapability.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 48000);
343    // inter apply with inter
344    Capability rawIntervalMimeCapability2 {MEDIA_MIME_AUDIO_RAW};
345    rawIntervalMimeCapability2.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 3000, 9000);
346    ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability2, rawIntervalMimeCapability, out));
347    ASSERT_TRUE(out.mime == rawIntervalMimeCapability2.mime);
348    auto intCaps2 = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
349    ASSERT_TRUE(intCaps2.first == 8000);
350    ASSERT_TRUE(intCaps2.second == 9000);
351
352    ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability, rawIntervalMimeCapability2, out));
353    ASSERT_TRUE(out.mime == rawIntervalMimeCapability.mime);
354    auto intCaps3 = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
355    ASSERT_TRUE(intCaps3.first == 8000);
356    ASSERT_TRUE(intCaps3.second == 9000);
357
358    Capability rawIntervalMimeCapability3 {MEDIA_MIME_AUDIO_RAW};
359    rawIntervalMimeCapability3.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 3000, 4000);
360    ASSERT_FALSE(Pipeline::MergeCapability(rawIntervalMimeCapability3, rawIntervalMimeCapability, out));
361    ASSERT_TRUE(out.mime.empty());
362    ASSERT_TRUE(out.keys.empty());
363
364    // inter apply with discrete
365    Capability rawListMimeCapability5 {MEDIA_MIME_AUDIO_RAW};
366    rawListMimeCapability5.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 4100});
367    ASSERT_FALSE(Pipeline::MergeCapability(rawIntervalMimeCapability, rawListMimeCapability5, out));
368    ASSERT_TRUE(out.mime.empty());
369    ASSERT_TRUE(out.keys.empty());
370
371    Capability rawListMimeCapability6 {MEDIA_MIME_AUDIO_RAW};
372    rawListMimeCapability6.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 4000, 44100});
373    ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability, rawListMimeCapability6, out));
374    ASSERT_TRUE(out.mime == rawIntervalMimeCapability.mime);
375    auto intCaps4 = Plugin::AnyCast<Plugin::FixedCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
376    ASSERT_TRUE(intCaps4 == 44100);
377
378    Capability rawListMimeCapability7 {MEDIA_MIME_AUDIO_RAW};
379    rawListMimeCapability7.AppendDiscreteKeys<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, {1000, 2000, 40000, 44100});
380    ASSERT_TRUE(Pipeline::MergeCapability(rawIntervalMimeCapability, rawListMimeCapability7, out));
381    ASSERT_TRUE(out.mime == rawIntervalMimeCapability.mime);
382    auto intCaps5 = Plugin::AnyCast<Plugin::DiscreteCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]);
383    ASSERT_TRUE(intCaps5.size() == 2);
384    ASSERT_TRUE(intCaps5[0] == 40000);
385    ASSERT_TRUE(intCaps5[1] == 44100);
386}
387
388HWTEST(TestMergeCapability, ComplexType_Test1, TestSize.Level1)
389{
390    Capability wildMimeCapability("*");
391    Capability out;
392
393    Capability cap1 (MEDIA_MIME_AUDIO_RAW);
394    cap1.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000);
395    cap1.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 2, 8);
396    cap1.AppendDiscreteKeys<Plugin::AudioSampleFormat>(CapabilityID::AUDIO_SAMPLE_FORMAT, {
397        Plugin::AudioSampleFormat::S64, Plugin::AudioSampleFormat::S64P, Plugin::AudioSampleFormat::U64,
398        Plugin::AudioSampleFormat::U64P, Plugin::AudioSampleFormat::F64,
399    });
400
401    Capability cap2(MEDIA_MIME_AUDIO_APE);
402
403    ASSERT_FALSE(Pipeline::MergeCapability(cap1, cap2, out));
404    ASSERT_TRUE(out.mime.empty());
405    ASSERT_TRUE(out.keys.empty());
406
407    Capability cap3(MEDIA_MIME_AUDIO_RAW);
408    ASSERT_TRUE(Pipeline::MergeCapability(cap1, cap3, out));
409    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
410    auto intCaps = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_CHANNELS]);
411    ASSERT_TRUE(intCaps.first == 2);
412    ASSERT_TRUE(intCaps.second == 8);
413    auto disCaps = Plugin::AnyCast<Plugin::DiscreteCapability<Plugin::AudioSampleFormat>>(
414            out.keys[CapabilityID::AUDIO_SAMPLE_FORMAT]);
415    ASSERT_TRUE(disCaps.size() == 5);
416    ASSERT_TRUE(disCaps[0] == Plugin::AudioSampleFormat::S64);
417    ASSERT_TRUE(disCaps[1] == Plugin::AudioSampleFormat::S64P);
418    ASSERT_TRUE(disCaps[2] == Plugin::AudioSampleFormat::U64);
419    ASSERT_TRUE(disCaps[3] == Plugin::AudioSampleFormat::U64P);
420    ASSERT_TRUE(disCaps[4] == Plugin::AudioSampleFormat::F64);
421}
422
423HWTEST(TestApplyCapabilitySet, ComplexType_Test3, TestSize.Level1)
424{
425    Capability out;
426
427    Capability cap1 (MEDIA_MIME_AUDIO_RAW);
428    cap1.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000);
429    cap1.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 2, 8);
430    cap1.AppendDiscreteKeys<Plugin::AudioSampleFormat>(CapabilityID::AUDIO_SAMPLE_FORMAT, {
431            Plugin::AudioSampleFormat::S64, Plugin::AudioSampleFormat::S64P, Plugin::AudioSampleFormat::U64,
432            Plugin::AudioSampleFormat::U64P, Plugin::AudioSampleFormat::F64,
433    });
434
435    Capability cap2(MEDIA_MIME_AUDIO_APE);
436    Capability cap3(MEDIA_MIME_AUDIO_RAW);
437
438    Capability cap4(MEDIA_MIME_AUDIO_RAW);
439    cap4.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 96000);
440    cap4.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 4);
441    cap4.AppendDiscreteKeys<Plugin::AudioChannelLayout>(CapabilityID::AUDIO_CHANNEL_LAYOUT, {
442            Plugin::AudioChannelLayout::STEREO, Plugin::AudioChannelLayout::SURROUND,
443            Plugin::AudioChannelLayout::CH_5POINT1, Plugin::AudioChannelLayout::CH_7POINT1,
444    });
445
446    Capability cap5(MEDIA_MIME_AUDIO_RAW);
447    cap5.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 8000, 96000);
448    cap5.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 10);
449    cap5.AppendDiscreteKeys<Plugin::AudioChannelLayout>(CapabilityID::AUDIO_CHANNEL_LAYOUT, {
450            Plugin::AudioChannelLayout::STEREO, Plugin::AudioChannelLayout::SURROUND,
451            Plugin::AudioChannelLayout::CH_5POINT1, Plugin::AudioChannelLayout::CH_7POINT1,
452    });
453
454    CapabilitySet capSet1 = {cap2, cap3};
455    ASSERT_TRUE(Pipeline::ApplyCapabilitySet(cap1, capSet1, out));
456    ASSERT_TRUE(Plugin::AnyCast<uint32_t>(out.keys[CapabilityID::AUDIO_SAMPLE_RATE]) == 8000);
457    auto intCaps = Plugin::AnyCast<Plugin::IntervalCapability<uint32_t>>(out.keys[CapabilityID::AUDIO_CHANNELS]);
458    ASSERT_TRUE(intCaps.first == 2);
459    ASSERT_TRUE(intCaps.second == 8);
460    auto disCaps = Plugin::AnyCast<Plugin::DiscreteCapability<Plugin::AudioSampleFormat>>(
461            out.keys[CapabilityID::AUDIO_SAMPLE_FORMAT]);
462    ASSERT_TRUE(disCaps.size() == 5);
463    ASSERT_TRUE(disCaps[0] == Plugin::AudioSampleFormat::S64);
464    ASSERT_TRUE(disCaps[1] == Plugin::AudioSampleFormat::S64P);
465    ASSERT_TRUE(disCaps[2] == Plugin::AudioSampleFormat::U64);
466    ASSERT_TRUE(disCaps[3] == Plugin::AudioSampleFormat::U64P);
467    ASSERT_TRUE(disCaps[4] == Plugin::AudioSampleFormat::F64);
468
469    CapabilitySet capSet2 = {cap2, cap5};
470    ASSERT_FALSE(Pipeline::ApplyCapabilitySet(cap1, capSet2, out));
471    ASSERT_TRUE(out.mime.empty());
472    ASSERT_TRUE(out.keys.empty());
473}
474
475HWTEST(TestMetaToCap, MetaToCap_Test, TestSize.Level1)
476{
477    Meta meta;
478    meta.Set<Plugin::Tag::MIME>(MEDIA_MIME_AUDIO_RAW);
479    meta.Set<Plugin::Tag::AUDIO_MPEG_VERSION>(1);
480    meta.Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO);
481    meta.Set<Plugin::Tag::AUDIO_CHANNELS>(2);
482    meta.Set<Plugin::Tag::AUDIO_SAMPLE_RATE>(48000);
483    auto cap = Pipeline::MetaToCapability(meta);
484    ASSERT_STREQ(MEDIA_MIME_AUDIO_RAW, cap->mime.c_str());
485    auto mpegVersion = Plugin::AnyCast<uint32_t>(cap->keys[CapabilityID::AUDIO_MPEG_VERSION]);
486    ASSERT_TRUE(mpegVersion == 1);
487
488    auto channelLayout = Plugin::AnyCast<AudioChannelLayout>(cap->keys[CapabilityID::AUDIO_CHANNEL_LAYOUT]);
489    ASSERT_TRUE(channelLayout == AudioChannelLayout::STEREO);
490
491    auto channels = Plugin::AnyCast<uint32_t>(cap->keys[CapabilityID::AUDIO_CHANNELS]);
492    ASSERT_TRUE(channels == 2);
493
494    auto sampleRate = Plugin::AnyCast<uint32_t>(cap->keys[CapabilityID::AUDIO_SAMPLE_RATE]);
495    ASSERT_TRUE(sampleRate == 48000);
496}
497
498HWTEST(TestMergeMetaWithCapability, MergeMetaWithEmptyKeyCapability_Test, TestSize.Level1)
499{
500    Meta meta;
501    meta.Set<Plugin::Tag::MIME>(MEDIA_MIME_AUDIO_MPEG);
502    meta.Set<Plugin::Tag::AUDIO_MPEG_VERSION>(1);
503    meta.Set<Plugin::Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO);
504    meta.Set<Plugin::Tag::AUDIO_CHANNELS>(2);
505    meta.Set<Plugin::Tag::AUDIO_SAMPLE_RATE>(48000);
506    meta.Set<Plugin::Tag::AUDIO_SAMPLE_FORMAT>(AudioSampleFormat::U16P);
507
508    Capability cap0(MEDIA_MIME_AUDIO_RAW);
509    Meta out1;
510    std::string outMime1;
511    uint32_t outMpegVersion1 = 0;
512    AudioChannelLayout outAudioChannelLayout1;
513    uint32_t outChannels1 = 0;
514    uint32_t outSampleRate1 = 0;
515    AudioSampleFormat outSampleFormat1 = AudioSampleFormat::U8;
516    ASSERT_TRUE(Pipeline::MergeMetaWithCapability(meta, cap0, out1));
517    ASSERT_TRUE(out1.Get<Tag::MIME>(outMime1));
518    ASSERT_STREQ(outMime1.c_str(), MEDIA_MIME_AUDIO_RAW);
519    ASSERT_TRUE(out1.Get<Tag::AUDIO_MPEG_VERSION>(outMpegVersion1));
520    ASSERT_TRUE(outMpegVersion1 == 1);
521    ASSERT_TRUE(out1.Get<Tag::AUDIO_CHANNEL_LAYOUT>(outAudioChannelLayout1));
522    ASSERT_TRUE(outAudioChannelLayout1 == AudioChannelLayout::STEREO);
523    ASSERT_TRUE(out1.Get<Tag::AUDIO_CHANNELS>(outChannels1));
524    ASSERT_TRUE(outChannels1 == 2);
525    ASSERT_TRUE(out1.Get<Tag::AUDIO_SAMPLE_RATE>(outSampleRate1));
526    ASSERT_TRUE(outSampleRate1 == 48000);
527    ASSERT_TRUE(out1.Get<Tag::AUDIO_SAMPLE_FORMAT>(outSampleFormat1));
528    ASSERT_TRUE(outSampleFormat1 == AudioSampleFormat::U16P);
529}
530
531HWTEST(TestMergeMetaWithCapability, Merge_meta_contains_meta_ony_key_capability_Test, TestSize.Level1)
532{
533    Meta meta;
534    meta.Set<Plugin::Tag::MIME>(MEDIA_MIME_AUDIO_MPEG);
535    meta.Set<Plugin::Tag::AUDIO_MPEG_VERSION>(1);
536    meta.Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO);
537    meta.Set<Plugin::Tag::AUDIO_CHANNELS>(2);
538    meta.Set<Plugin::Tag::AUDIO_SAMPLE_RATE>(48000);
539    meta.Set<Plugin::Tag::MEDIA_BITRATE>(128000);
540
541    Capability cap0(MEDIA_MIME_AUDIO_RAW);
542    cap0.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_MPEG_VERSION, 1);
543    cap0.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_SAMPLE_RATE, 48000);
544    cap0.AppendDiscreteKeys<AudioChannelLayout>(CapabilityID::AUDIO_CHANNEL_LAYOUT,
545                                                {AudioChannelLayout::STEREO, AudioChannelLayout::SURROUND});
546    cap0.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 1, 8);
547    cap0.AppendDiscreteKeys<AudioSampleFormat>(CapabilityID::AUDIO_SAMPLE_FORMAT,
548                                               {AudioSampleFormat::U16P, AudioSampleFormat::U8});
549    cap0.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_MPEG_LAYER, 3, 7);
550
551    Meta out1;
552    std::string outMime1;
553    uint32_t outMpegVersion1 = 0;
554    AudioChannelLayout outAudioChannelLayout1;
555    uint32_t outChannels1 = 0;
556    uint32_t outSampleRate1 = 0;
557    AudioSampleFormat outSampleFormat1 = AudioSampleFormat::U8;
558    uint32_t outMpegLayer = 0;
559    int64_t  outBitRate = 0;
560
561    ASSERT_TRUE(Pipeline::MergeMetaWithCapability(meta, cap0, out1));
562    ASSERT_TRUE(out1.Get<Tag::MIME>(outMime1));
563    ASSERT_STREQ(outMime1.c_str(), MEDIA_MIME_AUDIO_RAW);
564    ASSERT_TRUE(out1.Get<Tag::AUDIO_MPEG_VERSION>(outMpegVersion1));
565    ASSERT_TRUE(outMpegVersion1 == 1);
566    ASSERT_TRUE(out1.Get<Tag::AUDIO_CHANNEL_LAYOUT>(outAudioChannelLayout1));
567    ASSERT_TRUE(outAudioChannelLayout1 == AudioChannelLayout::STEREO);
568    ASSERT_TRUE(out1.Get<Tag::AUDIO_CHANNELS>(outChannels1));
569    ASSERT_TRUE(outChannels1 == 2);
570    ASSERT_TRUE(out1.Get<Tag::AUDIO_SAMPLE_RATE>(outSampleRate1));
571    ASSERT_TRUE(outSampleRate1 == 48000);
572    ASSERT_TRUE(out1.Get<Tag::AUDIO_SAMPLE_FORMAT>(outSampleFormat1));
573    ASSERT_TRUE(outSampleFormat1 == AudioSampleFormat::U16P);
574    ASSERT_TRUE(out1.Get<Tag::AUDIO_MPEG_LAYER>(outMpegLayer));
575    ASSERT_TRUE(outMpegLayer == 3);
576    ASSERT_TRUE(out1.Get<Tag::MEDIA_BITRATE>(outBitRate));
577    ASSERT_TRUE(outBitRate == 128000);
578}
579
580HWTEST(TestMergeMetaWithCapability, Merge_meta_with_capability_failed_Test, TestSize.Level1)
581{
582    Meta meta;
583    meta.Set<Plugin::Tag::MIME>(MEDIA_MIME_AUDIO_MPEG);
584    meta.Set<Plugin::Tag::AUDIO_MPEG_VERSION>(1);
585    meta.Set<Tag::AUDIO_CHANNEL_LAYOUT>(AudioChannelLayout::STEREO);
586    meta.Set<Plugin::Tag::AUDIO_CHANNELS>(2);
587    meta.Set<Plugin::Tag::AUDIO_SAMPLE_RATE>(48000);
588    meta.Set<Plugin::Tag::MEDIA_BITRATE>(128000);
589
590    Capability cap0(MEDIA_MIME_AUDIO_RAW);
591    cap0.AppendFixedKey<uint32_t>(CapabilityID::AUDIO_MPEG_VERSION, 2);
592    Meta out1;
593    ASSERT_FALSE(Pipeline::MergeMetaWithCapability(meta, cap0, out1));
594
595    Capability cap1(MEDIA_MIME_AUDIO_RAW);
596    cap1.AppendDiscreteKeys<AudioChannelLayout>(CapabilityID::AUDIO_CHANNEL_LAYOUT,
597                                                {AudioChannelLayout::CH_5POINT1, AudioChannelLayout::SURROUND});
598    Meta out2;
599    ASSERT_FALSE(Pipeline::MergeMetaWithCapability(meta, cap1, out2));
600
601
602    Capability cap2(MEDIA_MIME_AUDIO_RAW);
603    cap2.AppendIntervalKey<uint32_t>(CapabilityID::AUDIO_CHANNELS, 3, 8);
604    Meta out3;
605    ASSERT_FALSE(Pipeline::MergeMetaWithCapability(meta, cap2, out3));
606}
607}