1/*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file expected 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 "pipeline_test.h"
17
18using namespace OHOS;
19using namespace std;
20using namespace testing::ext;
21using namespace OHOS::Camera;
22
23void PipelineTest::SetUpTestCase(void) {}
24void PipelineTest::TearDownTestCase(void) {}
25void PipelineTest::SetUp(void)
26{
27    Test_ = std::make_shared<OHOS::Camera::Test>();
28    Test_->Init();
29    Test_->Open();
30}
31void PipelineTest::TearDown(void)
32{
33    Test_->Close();
34}
35
36/**
37  * @tc.name: Check ppl
38  * @tc.desc: preview success.
39  * @tc.size: MediumTest
40  * @tc.type: Function
41  */
42HWTEST_F(PipelineTest, Camera_Ppl_0001, TestSize.Level0)
43{
44    std::cout << "==========[test log]Check ppl: preview success." << std::endl;
45    // Start stream
46    Test_->intents = {Camera::PREVIEW};
47    Test_->StartStream(Test_->intents);
48    // Get preview
49    Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
50    // Release stream
51    Test_->captureIds = {Test_->captureId_preview};
52    Test_->streamIds = {Test_->streamId_preview};
53    Test_->StopStream(Test_->captureIds, Test_->streamIds);
54    Test_->StopConsumer(Test_->intents);
55}
56
57/**
58  * @tc.name: Check ppl
59  * @tc.desc: preview + capture success.
60  * @tc.size: MediumTest
61  * @tc.type: Function
62  */
63HWTEST_F(PipelineTest, Camera_Ppl_0002, TestSize.Level1)
64{
65    std::cout << "==========[test log]Check ppl: preview + capture success." << std::endl;
66    // Configure two stream information
67    Test_->intents = {Camera::PREVIEW, Camera::STILL_CAPTURE};
68    Test_->StartStream(Test_->intents);
69    // Capture preview stream
70    Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
71    // Capture camera stream, continuous capture
72    Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
73    // Post-processing
74    Test_->captureIds = {Test_->captureId_preview, Test_->captureId_capture};
75    Test_->streamIds = {Test_->streamId_preview, Test_->streamId_capture};
76    Test_->StopStream(Test_->captureIds, Test_->streamIds);
77}
78
79/**
80  * @tc.name: Check ppl
81  * @tc.desc: preview + video success.
82  * @tc.size: MediumTest
83  * @tc.type: Function
84  */
85HWTEST_F(PipelineTest, Camera_Ppl_0003, TestSize.Level1)
86{
87    std::cout << "==========[test log]Check ppl:Check ppl: preview + video success." << std::endl;
88    // Configure two stream information
89    Test_->intents = {Camera::PREVIEW, Camera::VIDEO};
90    Test_->StartStream(Test_->intents);
91    // Capture preview stream
92    Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
93    // Capture video stream
94    Test_->StartCapture(Test_->streamId_video, Test_->captureId_video, false, true);
95    // Post-processing
96    Test_->captureIds = {Test_->captureId_preview, Test_->captureId_video};
97    Test_->streamIds = {Test_->streamId_preview, Test_->streamId_video};
98    Test_->StopStream(Test_->captureIds, Test_->streamIds);
99}
100
101/**
102  * @tc.name: Check ppl
103  * @tc.desc: video mode without preview, system not support, expected return fail.
104  * @tc.size: MediumTest
105  * @tc.type: Function
106  */
107HWTEST_F(PipelineTest, Camera_Ppl_0004, TestSize.Level2)
108{
109    std::cout << "==========[test log]Check ppl:Video mode no preview, not support, expected fail." << std::endl;
110    EXPECT_EQ(true, Test_->cameraDevice != nullptr);
111    Test_->CreateStreamOperatorCallback();
112    Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
113    EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
114    if (Test_->rc == Camera::NO_ERROR) {
115        std::cout << "==========[test log]Check ppl: GetStreamOperator success." << std::endl;
116    } else {
117        std::cout << "==========[test log]Check ppl: GetStreamOperator fail, rc = " << Test_->rc << std::endl;
118    }
119    Test_->streamInfo = std::make_shared<Camera::StreamInfo>();
120    Test_->streamInfo->streamId_ = Test_->streamId_video;
121    Test_->streamInfo->width_ = 640;
122    Test_->streamInfo->height_ = 480;
123    Test_->StreamInfoFormat();
124    Test_->streamInfo->dataspace_ = 10;
125    Test_->streamInfo->intent_ = Camera::VIDEO;
126    Test_->streamInfo->tunneledMode_ = 5;
127    std::shared_ptr<OHOS::Camera::Test::StreamConsumer> consumer =
128        std::make_shared<OHOS::Camera::Test::StreamConsumer>();
129#ifdef CAMERA_BUILT_ON_OHOS_LITE
130    Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](OHOS::SurfaceBuffer* buffer) {
131        Test_->SaveYUV("preview", buffer->GetVirAddr(), buffer->GetSize());
132    });
133#else
134    Test_->streamInfo->bufferQueue_ = consumer->CreateProducer([this](void* addr, uint32_t size) {
135        Test_->SaveYUV("preview", addr, size);
136    });
137#endif
138    Test_->streamInfo->bufferQueue_->SetQueueSize(8);
139    Test_->consumerMap_[Camera::PREVIEW] = consumer;
140    std::vector<std::shared_ptr<Camera::StreamInfo>>().swap(Test_->streamInfos);
141    Test_->streamInfos.push_back(Test_->streamInfo);
142    Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
143    EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
144    std::cout << "==========[test log]CreateStreams rc = " << Test_->rc << std::endl;
145    Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
146    EXPECT_EQ(Test_->rc, Camera::INVALID_ARGUMENT);
147    std::cout << "==========[test log]CommitStreams rc = " << Test_->rc << std::endl;
148    // Post-processing
149    Test_->streamIds = {Test_->streamId_video};
150    Test_->StopStream(Test_->captureIds, Test_->streamIds);
151}
152
153/**
154  * @tc.name: Only Still_capture stream
155  * @tc.desc: Only Still_capture stream, capture->isStreaming = false.
156  * @tc.size: MediumTest
157  * @tc.type: Function
158  */
159HWTEST_F(PipelineTest, Camera_Ppl_0005, TestSize.Level1)
160{
161    std::cout << "==========[test log]check ppl: Still_capture stream, capture->isStreaming = false." << std::endl;
162    // Start stream
163    Test_->intents = {Camera::STILL_CAPTURE};
164    Test_->StartStream(Test_->intents);
165    // Start capture
166    Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, false);
167    // Post-processing
168    Test_->streamIds = {Test_->streamId_capture};
169    Test_->StopStream(Test_->captureIds, Test_->streamIds);
170}
171
172/**
173  * @tc.name: Only Still_capture stream
174  * @tc.desc: Only Still_capture stream, capture->isStreaming = true.
175  * @tc.size: MediumTest
176  * @tc.type: Function
177  */
178HWTEST_F(PipelineTest, Camera_Ppl_0006, TestSize.Level1)
179{
180    std::cout << "==========[test log]check ppl: Still_capture stream, capture->isStreaming = true." << std::endl;
181    // Start stream
182    Test_->intents = {Camera::STILL_CAPTURE};
183    Test_->StartStream(Test_->intents);
184    // Start capture
185    Test_->StartCapture(Test_->streamId_capture, Test_->captureId_capture, false, true);
186    // Post-processing
187    Test_->captureIds = {Test_->captureId_capture};
188    Test_->streamIds = {Test_->streamId_capture};
189    Test_->StopStream(Test_->captureIds, Test_->streamIds);
190}
191
192#ifndef CAMERA_BUILT_ON_OHOS_LITE
193/**
194  * @tc.name: Check ppl
195  * @tc.desc: double preview streams.
196  * @tc.size: MediumTest
197  * @tc.type: Function
198  */
199HWTEST_F(PipelineTest, Camera_Ppl_0007, TestSize.Level1)
200{
201    std::cout << "==========[test log]Check ppl: double preview streams." << std::endl;
202    // Create and get streamOperator information
203    Test_->streamOperatorCallback = new StreamOperatorCallback();
204    Test_->rc = Test_->cameraDevice->GetStreamOperator(Test_->streamOperatorCallback, Test_->streamOperator);
205    EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
206    // Create data stream 1
207    Test_->streamInfo = std::make_shared<StreamInfo>();
208    Test_->streamInfo->streamId_ = Test_->streamId_preview;
209    Test_->streamInfo->width_ = 1280;
210    Test_->streamInfo->height_ = 960;
211    Test_->streamInfo->dataspace_ = 8;
212    Test_->streamInfo->format_ = PIXEL_FMT_YCRCB_420_SP;
213    Test_->streamInfo->intent_ = Camera::PREVIEW;
214    std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer =
215        std::make_shared<OHOS::Camera::Test::StreamConsumer>();
216    Test_->streamInfo->bufferQueue_ = preview_consumer->CreateProducer([this](void* addr, uint32_t size) {
217        Test_->SaveYUV("preview", addr, size);
218    });
219    Test_->streamInfo->bufferQueue_->SetQueueSize(8);
220    Test_->consumerMap_[Camera::PREVIEW] = preview_consumer;
221    Test_->streamInfo->tunneledMode_ = 5;
222    std::vector<std::shared_ptr<StreamInfo>>().swap(Test_->streamInfos);
223    Test_->streamInfos.push_back(Test_->streamInfo);
224
225    // Create data stream 2
226    Test_->streamInfo2 = std::make_shared<StreamInfo>();
227    Test_->streamInfo2->streamId_ = Test_->streamId_preview_double;
228    Test_->streamInfo2->width_ = 1280;
229    Test_->streamInfo2->height_ = 960;
230    Test_->streamInfo2->dataspace_ = 8;
231    Test_->streamInfo2->format_ = PIXEL_FMT_YCRCB_420_SP;
232    Test_->streamInfo2->intent_ = Camera::PREVIEW;
233    std::shared_ptr<OHOS::Camera::Test::StreamConsumer> preview_consumer2 =
234        std::make_shared<OHOS::Camera::Test::StreamConsumer>();
235    Test_->streamInfo2->bufferQueue_ = preview_consumer2->CreateProducer([this](void* addr, uint32_t size) {
236        Test_->SaveYUV("preview2", addr, size);
237    });
238    Test_->streamInfo2->bufferQueue_->SetQueueSize(8);
239    Test_->consumerMap_[Camera::PREVIEW] = preview_consumer2;
240    Test_->streamInfo2->tunneledMode_ = 5;
241    Test_->streamInfos.push_back(Test_->streamInfo2);
242
243    Test_->rc = Test_->streamOperator->CreateStreams(Test_->streamInfos);
244    EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
245    // Flow distribution
246    Test_->rc = Test_->streamOperator->CommitStreams(Camera::NORMAL, Test_->ability);
247    EXPECT_EQ(Test_->rc, Camera::NO_ERROR);
248    // Get preview
249    Test_->StartCapture(Test_->streamId_preview, Test_->captureId_preview, false, true);
250    Test_->StartCapture(Test_->streamId_preview_double, Test_->captureId_preview_double, false, true);
251    // Release stream
252    Test_->captureIds = {Test_->captureId_preview, Test_->captureId_preview_double};
253    Test_->streamIds = {Test_->streamId_preview, Test_->streamId_preview_double};
254    Test_->StopStream(Test_->captureIds, Test_->streamIds);
255}
256#endif