• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 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 <thread>
17 #include <cinttypes>
18 #include <vector>
19 #include <gtest/gtest.h>
20 #include <gmock/gmock.h>
21 
22 #include "audio_service_log.h"
23 #include "audio_errors.h"
24 #include "ring_buffer_wrapper.h"
25 
26 using namespace testing::ext;
27 using namespace testing;
28 
29 namespace OHOS {
30 namespace AudioStandard {
31 namespace {
32 } // namespace
33 
34 class RingBufferWrapperUnitTest : public testing::Test {
35 public:
SetUpTestCase(void)36     static void SetUpTestCase(void) {}
TearDownTestCase(void)37     static void TearDownTestCase(void) {}
SetUp()38     void SetUp() {}
TearDown()39     void TearDown() {}
40 };
41 
42 /**
43  * @tc.name  : Test RingBufferWrapper API
44  * @tc.type  : FUNC
45  * @tc.number: RingBufferWrapper_001
46  * @tc.desc  : Test RingBufferWrapper interface.
47  */
48 HWTEST_F(RingBufferWrapperUnitTest, RingBufferWrapper_001, TestSize.Level0)
49 {
50     std::vector<uint8_t> vecU8 = {0};
51     BasicBufferDesc illegalBasicBuffer1 = {.buffer = nullptr, .bufLength = 1};
52     EXPECT_EQ(illegalBasicBuffer1.IsLegal(), false);
53 
54     BasicBufferDesc illegalBasicBuffer2 = {.buffer = vecU8.data(), .bufLength = 0};
55     EXPECT_EQ(illegalBasicBuffer2.IsLegal(), false);
56 
57     BasicBufferDesc legalBasicBuffer = {.buffer = vecU8.data(), .bufLength = 1};
58     EXPECT_EQ(legalBasicBuffer.IsLegal(), true);
59 
60     RingBufferWrapper illegalRingBuffer1 = {
61         .basicBufferDescs = {{
62             illegalBasicBuffer1,
63             legalBasicBuffer
64         }},
65         .dataLength = 1
66     };
67     EXPECT_EQ(illegalRingBuffer1.IsLegal(), false);
68 
69     RingBufferWrapper illegalRingBuffer2 = {
70         .basicBufferDescs = {{
71             legalBasicBuffer,
72             illegalBasicBuffer1
73         }},
74         .dataLength = 1
75     };
76     EXPECT_EQ(illegalRingBuffer2.IsLegal(), false);
77 }
78 
79 /**
80  * @tc.name  : Test RingBufferWrapper API
81  * @tc.type  : FUNC
82  * @tc.number: RingBufferWrapper_002
83  * @tc.desc  : Test RingBufferWrapper interface.
84  */
85 HWTEST_F(RingBufferWrapperUnitTest, RingBufferWrapper_002, TestSize.Level0)
86 {
87     // size 10, value = 0
88     std::vector<uint8_t> vecU8(10, 0);
89     // [0, 5)
90     BasicBufferDesc legalBasicBuffer1 = {.buffer = vecU8.data(), .bufLength = 5};
91     EXPECT_EQ(legalBasicBuffer1.IsLegal(), true);
92 
93     // [5, 10)
94     BasicBufferDesc legalBasicBuffer2 = {.buffer = (vecU8.data() + 5), .bufLength = 5};
95     EXPECT_EQ(legalBasicBuffer2.IsLegal(), true);
96 
97     // [4, 10)
98     BasicBufferDesc legalBasicBuffer3 = {.buffer = (vecU8.data() + 4), .bufLength = 6};
99     EXPECT_EQ(legalBasicBuffer3.IsLegal(), true);
100 
101     BasicBufferDesc legalBasicBuffer4 = {.buffer = nullptr, .bufLength = 0};
102     EXPECT_EQ(legalBasicBuffer4.IsLegal(), true);
103 
104     RingBufferWrapper illegalRingBuffer1 = {
105         .basicBufferDescs = {{
106             legalBasicBuffer4,
107             legalBasicBuffer1
108         }},
109         .dataLength = 0
110     };
111     EXPECT_EQ(illegalRingBuffer1.IsLegal(), false);
112 
113     RingBufferWrapper illegalRingBuffer2 = {
114         .basicBufferDescs = {{
115             legalBasicBuffer1,
116             legalBasicBuffer3
117         }},
118         .dataLength = 0
119     };
120     EXPECT_EQ(illegalRingBuffer2.IsLegal(), false);
121 
122     RingBufferWrapper illegalRingBuffer3 = {
123         .basicBufferDescs = {{
124             legalBasicBuffer1,
125             legalBasicBuffer2
126         }},
127         // len of buffer1 is 5, len of buffer2 is 5; datalenth > buffer1 + buffer2
128         .dataLength = 11
129     };
130     EXPECT_EQ(illegalRingBuffer3.IsLegal(), false);
131 }
132 
133 /**
134  * @tc.name  : Test RingBufferWrapper API
135  * @tc.type  : FUNC
136  * @tc.number: RingBufferWrapper_003
137  * @tc.desc  : Test RingBufferWrapper interface.
138  */
139 HWTEST_F(RingBufferWrapperUnitTest, RingBufferWrapper_003, TestSize.Level0)
140 {
141     // size 10, value = 0
142     std::vector<uint8_t> vecU8(10, 0);
143     // [0, 5)
144     BasicBufferDesc legalBasicBuffer1 = {.buffer = vecU8.data(), .bufLength = 5};
145     EXPECT_EQ(legalBasicBuffer1.IsLegal(), true);
146 
147     // [5, 10)
148     BasicBufferDesc legalBasicBuffer2 = {.buffer = (vecU8.data() + 5), .bufLength = 5};
149     EXPECT_EQ(legalBasicBuffer2.IsLegal(), true);
150 
151     // [4, 10)
152     BasicBufferDesc legalBasicBuffer3 = {.buffer = (vecU8.data() + 4), .bufLength = 6};
153     EXPECT_EQ(legalBasicBuffer3.IsLegal(), true);
154 
155     BasicBufferDesc legalBasicBuffer4 = {.buffer = nullptr, .bufLength = 0};
156     EXPECT_EQ(legalBasicBuffer4.IsLegal(), true);
157 
158     RingBufferWrapper legalRingBuffer1 = {
159         .basicBufferDescs = {{
160             legalBasicBuffer1,
161             legalBasicBuffer2
162         }},
163         .dataLength = 0
164     };
165     EXPECT_EQ(legalRingBuffer1.IsLegal(), true);
166 
167     RingBufferWrapper legalRingBuffer2 = {
168         .basicBufferDescs = {{
169             legalBasicBuffer1,
170             legalBasicBuffer4
171         }},
172         .dataLength = 0
173     };
174     EXPECT_EQ(legalRingBuffer2.IsLegal(), true);
175 
176     RingBufferWrapper legalRingBuffer3 = {
177         .basicBufferDescs = {{
178             legalBasicBuffer4,
179             legalBasicBuffer4
180         }},
181         .dataLength = 0
182     };
183     EXPECT_EQ(legalRingBuffer3.IsLegal(), true);
184 }
185 
186 /**
187  * @tc.name  : Test RingBufferWrapper API
188  * @tc.type  : FUNC
189  * @tc.number: RingBufferWrapper_004
190  * @tc.desc  : Test RingBufferWrapper interface.
191  */
192 HWTEST_F(RingBufferWrapperUnitTest, RingBufferWrapper_004, TestSize.Level0)
193 {
194     // size 2, value = 0
195     std::vector<uint8_t> vecU8(2, 0);
196     RingBufferWrapper buffer1 = {
197         .basicBufferDescs = {{
198             {vecU8.data(), 2},
199             {nullptr, 0}
200         }},
201         .dataLength = 2
202     };
203 
204     // size 2, value = 1
205     std::vector<uint8_t> vecU82(2, 1);
206     RingBufferWrapper buffer2 = {
207         .basicBufferDescs = {{
208             {vecU82.data(), 2},
209             {nullptr, 0}
210         }},
211         .dataLength = 1
212     };
213 
214     buffer1.CopyInputBufferValueToCurBuffer(buffer2);
215     EXPECT_THAT(vecU8, ElementsAre(1, 0));
216 }
217 } // namespace AudioStandard
218 } // namespace OHOS