1 /*
2 * Copyright (c) 2022-2024 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 <chrono>
17 #include <gtest/gtest.h>
18 #include <securec.h>
19 #define private public
20 #include "dcamera_stream_data_process_producer.h"
21 #undef private
22 #include "anonymous_string.h"
23 #include "dcamera_buffer_handle.h"
24 #include "distributed_camera_constants.h"
25 #include "distributed_camera_errno.h"
26 #include "distributed_hardware_log.h"
27 #include "v1_1/dcamera_types.h"
28
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace DistributedHardware {
33 class DCameraStreamDataProcessProducerTest : public testing::Test {
34 public:
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39 };
40
41 namespace {
42 const std::string TEST_DEVICE_ID = "bb536a637105409e904d4da83790a4a7";
43 const std::string TEST_CAMERA_DH_ID_0 = "camera_0";
44 const uint8_t SLEEP_TIME = 1;
45 const int32_t STREAM_ID_1 = 1;
46 const int32_t STREAM_ID_2 = 2;
47 #define DCAMERA_PRODUCER_MAX_BUFFER_SIZE 2
48 }
SetUpTestCase(void)49 void DCameraStreamDataProcessProducerTest::SetUpTestCase(void)
50 {
51 }
52
TearDownTestCase(void)53 void DCameraStreamDataProcessProducerTest::TearDownTestCase(void)
54 {
55 }
56
SetUp(void)57 void DCameraStreamDataProcessProducerTest::SetUp(void)
58 {
59 }
60
TearDown(void)61 void DCameraStreamDataProcessProducerTest::TearDown(void)
62 {
63 }
64
65 /**
66 * @tc.name: dcamera_stream_data_process_producer_test_001
67 * @tc.desc: Verify Start Stop FeedStream func.
68 * @tc.type: FUNC
69 * @tc.require: issue
70 */
71 HWTEST_F(DCameraStreamDataProcessProducerTest, dcamera_stream_data_process_producer_test_001, TestSize.Level1)
72 {
73 DHLOGI("dcamera_stream_data_process_producer_test_001");
74 size_t capacity = 1;
75 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
76 std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess1 =
77 std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_1,
78 DCStreamType::SNAPSHOT_FRAME);
79 streamProcess1->Start();
80 sleep(SLEEP_TIME);
81 streamProcess1->FeedStream(buffer);
82 streamProcess1->Stop();
83 std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess2 =
84 std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_2,
85 DCStreamType::CONTINUOUS_FRAME);
86 streamProcess2->Start();
87 sleep(SLEEP_TIME);
88 streamProcess2->FeedStream(buffer);
89 streamProcess2->Stop();
90 DHBase dhBase;
91 dhBase.deviceId_ = TEST_DEVICE_ID;
92 dhBase.dhId_ = TEST_CAMERA_DH_ID_0;
93 int32_t ret = streamProcess1->FeedStreamToDriver(dhBase, buffer);
94 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
95 ret = streamProcess2->FeedStreamToDriver(dhBase, buffer);
96 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
97 streamProcess1 = nullptr;
98 auto listener = std::make_shared<FeedingSmootherListener>(streamProcess1);
99 buffer = nullptr;
100 EXPECT_EQ(NOTIFY_FAILED, listener->OnSmoothFinished(buffer));
101 }
102
103 /**
104 * @tc.name: dcamera_stream_data_process_producer_test_002
105 * @tc.desc: Verify Start Stop FeedStream func.
106 * @tc.type: FUNC
107 * @tc.require: issue
108 */
109 HWTEST_F(DCameraStreamDataProcessProducerTest, dcamera_stream_data_process_producer_test_002, TestSize.Level1)
110 {
111 DHLOGI("dcamera_stream_data_process_producer_test_002");
112 size_t capacity = 1;
113 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
114 std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess1 =
115 std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_1,
116 DCStreamType::SNAPSHOT_FRAME);
117 std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess2 =
118 std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_2,
119 DCStreamType::CONTINUOUS_FRAME);
120 streamProcess1->Start();
121 sleep(SLEEP_TIME);
122 streamProcess1->Stop();
123
124 streamProcess2->Start();
125 sleep(SLEEP_TIME);
126 streamProcess2->Stop();
127 DHBase dhBase;
128 dhBase.deviceId_ = TEST_DEVICE_ID;
129 dhBase.dhId_ = TEST_CAMERA_DH_ID_0;
130 int32_t ret = streamProcess1->FeedStreamToDriver(dhBase, buffer);
131 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
132 ret = streamProcess2->FeedStreamToDriver(dhBase, buffer);
133 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
134 }
135
136 /**
137 * @tc.name: dcamera_stream_data_process_producer_test_003
138 * @tc.desc: Verify Start Stop FeedStream func.
139 * @tc.type: FUNC
140 * @tc.require: issue
141 */
142 HWTEST_F(DCameraStreamDataProcessProducerTest, dcamera_stream_data_process_producer_test_003, TestSize.Level1)
143 {
144 DHLOGI("dcamera_stream_data_process_producer_test_003");
145 size_t capacity = 1;
146 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
147 std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess1 =
148 std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_1,
149 DCStreamType::SNAPSHOT_FRAME);
150 std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess2 =
151 std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_2,
152 DCStreamType::CONTINUOUS_FRAME);
153 streamProcess1->FeedStream(buffer);
154 streamProcess1->FeedStream(buffer);
155 streamProcess2->Start();
156 sleep(SLEEP_TIME);
157 streamProcess2->FeedStream(buffer);
158 streamProcess2->FeedStream(buffer);
159 DHBase dhBase;
160 dhBase.deviceId_ = TEST_DEVICE_ID;
161 dhBase.dhId_ = TEST_CAMERA_DH_ID_0;
162 int32_t ret = streamProcess1->FeedStreamToDriver(dhBase, buffer);
163 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
164 ret = streamProcess2->FeedStreamToDriver(dhBase, buffer);
165 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
166 streamProcess2->Stop();
167 }
168
169 /**
170 * @tc.name: dcamera_stream_data_process_producer_test_004
171 * @tc.desc: Verify LooperSnapShot func.
172 * @tc.type: FUNC
173 * @tc.require: issue
174 */
175 HWTEST_F(DCameraStreamDataProcessProducerTest, dcamera_stream_data_process_producer_test_004, TestSize.Level1)
176 {
177 DHLOGI("dcamera_stream_data_process_producer_test_004");
178 size_t capacity = 1;
179 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
180 std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess =
181 std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_1,
182 DCStreamType::SNAPSHOT_FRAME);
183 streamProcess->LooperSnapShot();
184 streamProcess->state_ = DCameraStreamDataProcessProducer::DCAMERA_PRODUCER_STATE_STOP;
185 streamProcess->LooperSnapShot();
186 DHBase dhBase;
187 dhBase.deviceId_ = TEST_DEVICE_ID;
188 dhBase.dhId_ = TEST_CAMERA_DH_ID_0;
189 int32_t ret = streamProcess->FeedStreamToDriver(dhBase, buffer);
190 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
191 }
192
193 /**
194 * @tc.name: dcamera_stream_data_process_producer_test_005
195 * @tc.desc: Verify CheckSharedMemory func.
196 * @tc.type: FUNC
197 * @tc.require: issue
198 */
199 HWTEST_F(DCameraStreamDataProcessProducerTest, dcamera_stream_data_process_producer_test_005, TestSize.Level1)
200 {
201 DHLOGI("dcamera_stream_data_process_producer_test_005");
202 size_t capacity = 1;
203 std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
204 std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess1 =
205 std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_1,
206 DCStreamType::SNAPSHOT_FRAME);
207 std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess2 =
208 std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_2,
209 DCStreamType::CONTINUOUS_FRAME);
210 DCameraBuffer sharedMemory;
211 sharedMemory.index_ = 1;
212 sharedMemory.size_ = 1;
213 sharedMemory.bufferHandle_ = nullptr;
214 int32_t ret = streamProcess1->CheckSharedMemory(sharedMemory, buffer);
215 ret = streamProcess2->CheckSharedMemory(sharedMemory, buffer);
216 sharedMemory.bufferHandle_ = sptr<NativeBuffer>(new NativeBuffer());
217 ret = streamProcess1->CheckSharedMemory(sharedMemory, buffer);
218 ret = streamProcess2->CheckSharedMemory(sharedMemory, buffer);
219 BufferHandle *bufferHandle = new BufferHandle();
220 sharedMemory.bufferHandle_ = sptr<NativeBuffer>(new NativeBuffer(bufferHandle));
221 ret = streamProcess1->CheckSharedMemory(sharedMemory, buffer);
222 ret = streamProcess2->CheckSharedMemory(sharedMemory, buffer);
223 DHBase dhBase;
224 dhBase.deviceId_ = TEST_DEVICE_ID;
225 dhBase.dhId_ = TEST_CAMERA_DH_ID_0;
226 ret = streamProcess1->FeedStreamToDriver(dhBase, buffer);
227 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
228 ret = streamProcess2->FeedStreamToDriver(dhBase, buffer);
229 EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
230 }
231 }
232 }
233