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