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     streamProcess2->FeedStream(buffer);
157     streamProcess2->FeedStream(buffer);
158     streamProcess2->Stop();
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 }
167 
168 /**
169  * @tc.name: dcamera_stream_data_process_producer_test_004
170  * @tc.desc: Verify LooperSnapShot func.
171  * @tc.type: FUNC
172  * @tc.require: issue
173  */
174 HWTEST_F(DCameraStreamDataProcessProducerTest, dcamera_stream_data_process_producer_test_004, TestSize.Level1)
175 {
176     DHLOGI("dcamera_stream_data_process_producer_test_004");
177     size_t capacity = 1;
178     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
179     std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess =
180         std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_1,
181         DCStreamType::SNAPSHOT_FRAME);
182     streamProcess->LooperSnapShot();
183     streamProcess->state_ = DCameraStreamDataProcessProducer::DCAMERA_PRODUCER_STATE_STOP;
184     streamProcess->LooperSnapShot();
185     DHBase dhBase;
186     dhBase.deviceId_ = TEST_DEVICE_ID;
187     dhBase.dhId_ = TEST_CAMERA_DH_ID_0;
188     int32_t ret = streamProcess->FeedStreamToDriver(dhBase, buffer);
189     EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
190 }
191 
192 /**
193  * @tc.name: dcamera_stream_data_process_producer_test_005
194  * @tc.desc: Verify CheckSharedMemory func.
195  * @tc.type: FUNC
196  * @tc.require: issue
197  */
198 HWTEST_F(DCameraStreamDataProcessProducerTest, dcamera_stream_data_process_producer_test_005, TestSize.Level1)
199 {
200     DHLOGI("dcamera_stream_data_process_producer_test_005");
201     size_t capacity = 1;
202     std::shared_ptr<DataBuffer> buffer = std::make_shared<DataBuffer>(capacity);
203     std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess1 =
204         std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_1,
205         DCStreamType::SNAPSHOT_FRAME);
206     std::shared_ptr<DCameraStreamDataProcessProducer> streamProcess2 =
207         std::make_shared<DCameraStreamDataProcessProducer>(TEST_DEVICE_ID, TEST_CAMERA_DH_ID_0, STREAM_ID_2,
208         DCStreamType::CONTINUOUS_FRAME);
209     DCameraBuffer sharedMemory;
210     sharedMemory.index_ = 1;
211     sharedMemory.size_ = 1;
212     sharedMemory.bufferHandle_ = nullptr;
213     int32_t ret = streamProcess1->CheckSharedMemory(sharedMemory, buffer);
214     ret = streamProcess2->CheckSharedMemory(sharedMemory, buffer);
215     sharedMemory.bufferHandle_ = sptr<NativeBuffer>(new NativeBuffer());
216     ret = streamProcess1->CheckSharedMemory(sharedMemory, buffer);
217     ret = streamProcess2->CheckSharedMemory(sharedMemory, buffer);
218     BufferHandle *bufferHandle = new BufferHandle();
219     sharedMemory.bufferHandle_ = sptr<NativeBuffer>(new NativeBuffer(bufferHandle));
220     ret = streamProcess1->CheckSharedMemory(sharedMemory, buffer);
221     ret = streamProcess2->CheckSharedMemory(sharedMemory, buffer);
222     DHBase dhBase;
223     dhBase.deviceId_ = TEST_DEVICE_ID;
224     dhBase.dhId_ = TEST_CAMERA_DH_ID_0;
225     ret = streamProcess1->FeedStreamToDriver(dhBase, buffer);
226     EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
227     ret = streamProcess2->FeedStreamToDriver(dhBase, buffer);
228     EXPECT_EQ(DCAMERA_BAD_VALUE, ret);
229 }
230 }
231 }