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 #include <memory>
16 
17 #include "avcodec_errors.h"
18 #include "avcodec_common.h"
19 #include "meta/format.h"
20 
21 #include "dscreen_constants.h"
22 #include "dscreen_errcode.h"
23 #include "screen_callback_test.h"
24 #include "screentrans_test_utils.h"
25 #include "iimage_source_processor_listener.h"
26 #include "image_source_encoder.h"
27 #include "iscreen_channel_listener.h"
28 #include "screen_data_channel_impl.h"
29 #include "image_sink_decoder.h"
30 #include "image_decoder_callback.h"
31 using namespace testing::ext;
32 
33 namespace OHOS {
34 namespace DistributedHardware {
SetUpTestCase(void)35 void ScreenCallbackTest::SetUpTestCase(void) {}
36 
TearDownTestCase(void)37 void ScreenCallbackTest::TearDownTestCase(void) {}
38 
SetUp(void)39 void ScreenCallbackTest::SetUp(void)
40 {
41     sourceTrans = std::make_shared<ScreenSourceTrans>();
42     sinkTrans = std::make_shared<ScreenSinkTrans>();
43 }
44 
TearDown(void)45 void ScreenCallbackTest::TearDown(void) {}
46 
47 /**
48  * @tc.name: RegisterStateCallback_003
49  * @tc.desc: Verify the RegisterStateCallback function.
50  * @tc.type: FUNC
51  * @tc.require: Issue Number
52  */
53 HWTEST_F(ScreenCallbackTest, RegisterStateCallback_003, TestSize.Level1)
54 {
55     std::shared_ptr<IScreenSourceTransCallback> callback = std::make_shared<MockIScreenSourceTransCallback>();
56     int32_t actual = sourceTrans->RegisterStateCallback(callback);
57 
58     std::string peerDevId = "peerDevId";
59     std::shared_ptr<ScreenDataChannelImpl> screenChannel = std::make_shared<ScreenDataChannelImpl>(peerDevId);
60     std::shared_ptr<IScreenChannelListener> listener = std::make_shared<ScreenSourceTrans>();
61     screenChannel->channelListener_ = listener;
62     int32_t sessionId = 0;
63     const void *data = nullptr;
64     uint32_t dataLen = 0;
65     screenChannel->OnBytesReceived(sessionId, data, dataLen);
66     const StreamData *streamData = nullptr;
67     const StreamData *ext = nullptr;
68     const StreamFrameInfo *param = nullptr;
69     screenChannel->OnStreamReceived(sessionId, streamData, ext, param);
70 
71     EXPECT_EQ(DH_SUCCESS, actual);
72 }
73 
74 /**
75  * @tc.name: RegisterStateCallback_004
76  * @tc.desc: Verify the RegisterStateCallback function.
77  * @tc.type: FUNC
78  * @tc.require: Issue Number
79  */
80 HWTEST_F(ScreenCallbackTest, RegisterStateCallback_004, TestSize.Level1)
81 {
82     std::shared_ptr<IScreenSourceTransCallback> callback = std::make_shared<MockIScreenSourceTransCallback>();
83     int32_t actual = sourceTrans->RegisterStateCallback(callback);
84 
85     std::shared_ptr<IImageSourceProcessorListener> listener = std::make_shared<ScreenSourceTrans>();
86     std::shared_ptr<ImageSourceEncoder> encoder = std::make_shared<ImageSourceEncoder>(listener);
87     std::shared_ptr<ImageEncoderCallback> encoderCallback = std::make_shared<ImageEncoderCallback>(encoder);
88     MediaAVCodec::AVCodecErrorType errorType = MediaAVCodec::AVCODEC_ERROR_INTERNAL;
89     int32_t errorCode = 0;
90     encoderCallback->OnError(errorType, errorCode);
91     uint32_t index = 0;
92     MediaAVCodec::AVCodecBufferInfo info;
93     info.presentationTimeUs = 0;
94     info.size = 0;
95     info.offset = 0;
96     MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_NONE;
97     std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
98     encoderCallback->OnOutputBufferAvailable(index, info, flag, buffer);
99     encoderCallback->OnInputBufferAvailable(index, buffer);
100     Media::Format format;
101     encoderCallback->OnOutputFormatChanged(format);
102 
103     EXPECT_EQ(DH_SUCCESS, actual);
104 }
105 
106 /**
107  * @tc.name: RegisterStateCallback_005
108  * @tc.desc: Verify the RegisterStateCallback function.
109  * @tc.type: FUNC
110  * @tc.require: Issue Number
111  */
112 HWTEST_F(ScreenCallbackTest, RegisterStateCallback_005, TestSize.Level1)
113 {
114     std::shared_ptr<IScreenSinkTransCallback> callback = std::make_shared<MockIScreenSinkTransCallback>();
115     int32_t actual = sinkTrans->RegisterStateCallback(callback);
116 
117     std::shared_ptr<IImageSinkProcessorListener> listener = std::make_shared<ScreenSinkTrans>();
118     std::shared_ptr<ImageSinkDecoder> decoder = std::make_shared<ImageSinkDecoder>(listener);
119     std::shared_ptr<ImageDecoderCallback> decoderCallback = std::make_shared<ImageDecoderCallback>(decoder);
120 
121     MediaAVCodec::AVCodecErrorType errorType = MediaAVCodec::AVCODEC_ERROR_INTERNAL;
122     int32_t errorCode = 0;
123     decoderCallback->OnError(errorType, errorCode);
124     uint32_t index = 0;
125     MediaAVCodec::AVCodecBufferInfo info;
126     info.presentationTimeUs = 0;
127     info.size = 0;
128     info.offset = 0;
129     MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_NONE;
130     std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
131     decoderCallback->OnOutputBufferAvailable(index, info, flag, buffer);
132     decoderCallback->OnInputBufferAvailable(index, buffer);
133     Media::Format format;
134     decoderCallback->OnOutputFormatChanged(format);
135 
136     EXPECT_EQ(DH_SUCCESS, actual);
137 }
138 
139 /**
140  * @tc.name: RegisterStateCallback_006
141  * @tc.desc: Verify the RegisterStateCallback function.
142  * @tc.type: FUNC
143  * @tc.require: Issue Number
144  */
145 HWTEST_F(ScreenCallbackTest, RegisterStateCallback_006, TestSize.Level1)
146 {
147     std::shared_ptr<IScreenSinkTransCallback> callback = std::make_shared<MockIScreenSinkTransCallback>();
148     int32_t actual = sinkTrans->RegisterStateCallback(callback);
149 
150     std::string peerDevId = "peerDevId";
151     std::shared_ptr<ScreenDataChannelImpl> screenChannel = std::make_shared<ScreenDataChannelImpl>(peerDevId);
152     std::shared_ptr<IScreenChannelListener> listener = std::make_shared<ScreenSinkTrans>();
153     screenChannel->channelListener_ = listener;
154     int32_t sessionId = 0;
155     const void *data = nullptr;
156     uint32_t dataLen = 0;
157     screenChannel->OnBytesReceived(sessionId, data, dataLen);
158     const StreamData *streamData = nullptr;
159     const StreamData *ext = nullptr;
160     const StreamFrameInfo *param = nullptr;
161     screenChannel->OnStreamReceived(sessionId, streamData, ext, param);
162 
163     EXPECT_EQ(DH_SUCCESS, actual);
164 }
165 
166 /**
167  * @tc.name: RegisterStateCallback_007
168  * @tc.desc: Verify the RegisterStateCallback function.
169  * @tc.type: FUNC
170  * @tc.require: Issue Number
171  */
172 HWTEST_F(ScreenCallbackTest, RegisterStateCallback_007, TestSize.Level1)
173 {
174     std::shared_ptr<IScreenSinkTransCallback> callback = std::make_shared<MockIScreenSinkTransCallback>();
175     int32_t actual = sinkTrans->RegisterStateCallback(callback);
176     std::shared_ptr<ImageEncoderCallback> encoderCallback = std::make_shared<ImageEncoderCallback>(nullptr);
177     MediaAVCodec::AVCodecErrorType errorType = MediaAVCodec::AVCODEC_ERROR_INTERNAL;
178     int32_t errorCode = 0;
179     encoderCallback->OnError(errorType, errorCode);
180     uint32_t index = 0;
181     MediaAVCodec::AVCodecBufferInfo info;
182     MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_NONE;
183     std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
184     encoderCallback->OnOutputBufferAvailable(index, info, flag, buffer);
185     encoderCallback->OnInputBufferAvailable(index, buffer);
186     Media::Format format;
187     encoderCallback->OnOutputFormatChanged(format);
188     EXPECT_EQ(DH_SUCCESS, actual);
189 }
190 
191 /**
192  * @tc.name: RegisterStateCallback_008
193  * @tc.desc: Verify the RegisterStateCallback function.
194  * @tc.type: FUNC
195  * @tc.require: Issue Number
196  */
197 HWTEST_F(ScreenCallbackTest, RegisterStateCallback_008, TestSize.Level1)
198 {
199     std::shared_ptr<IScreenSinkTransCallback> callback = std::make_shared<MockIScreenSinkTransCallback>();
200     int32_t actual = sinkTrans->RegisterStateCallback(callback);
201     std::shared_ptr<ImageDecoderCallback> decoderCallback = std::make_shared<ImageDecoderCallback>(nullptr);
202     MediaAVCodec::AVCodecErrorType errorType = MediaAVCodec::AVCODEC_ERROR_INTERNAL;
203     int32_t errorCode = 0;
204     decoderCallback->OnError(errorType, errorCode);
205     uint32_t index = 0;
206     MediaAVCodec::AVCodecBufferInfo info;
207     MediaAVCodec::AVCodecBufferFlag flag = MediaAVCodec::AVCODEC_BUFFER_FLAG_NONE;
208     std::shared_ptr<Media::AVSharedMemory> buffer = nullptr;
209     decoderCallback->OnOutputBufferAvailable(index, info, flag, buffer);
210     decoderCallback->OnInputBufferAvailable(index, buffer);
211     Media::Format format;
212     decoderCallback->OnOutputFormatChanged(format);
213     EXPECT_EQ(DH_SUCCESS, actual);
214 }
215 } // namespace DistributedHardware
216 } // namespace OHOS