1/*
2 * Copyright (C) 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 "gtest/gtest.h"
17
18#include "pipeline_core.h"
19#include "efilter_factory.h"
20#include "test_common.h"
21#include "filter_base.h"
22#include "transfer.h"
23
24using namespace testing::ext;
25
26namespace OHOS {
27namespace Media {
28namespace Effect {
29namespace Test {
30
31class TestEffectPipeline : public testing::Test {
32public:
33    TestEffectPipeline() = default;
34
35    ~TestEffectPipeline() override = default;
36    static void SetUpTestCase() {}
37
38    static void TearDownTestCase() {}
39
40    void SetUp() override{}
41
42    void TearDown() override{}
43};
44
45HWTEST_F(TestEffectPipeline, EffectPipelineStandard001, TestSize.Level1) {
46    std::shared_ptr<PipelineCore> pipeline = std::make_shared<PipelineCore>();
47    pipeline->Init(nullptr);
48
49    std::vector<Filter *> filtersToPipeline;
50    std::shared_ptr<EFilter> eFilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
51    filtersToPipeline.push_back(eFilter.get());
52
53    ErrorCode result = pipeline->AddFilters(filtersToPipeline);
54    EXPECT_EQ(result, ErrorCode::SUCCESS);
55
56    std::shared_ptr<EFilter> contrastEFilter = EFilterFactory::Instance()->Create(CONTRAST_EFILTER);
57    result = pipeline->AddFilter(contrastEFilter.get());
58    EXPECT_EQ(result, ErrorCode::SUCCESS);
59
60    result = pipeline->LinkFilters(filtersToPipeline);
61    EXPECT_EQ(result, ErrorCode::SUCCESS);
62
63    result = pipeline->RemoveFilter(eFilter.get());
64    EXPECT_EQ(result, ErrorCode::SUCCESS);
65
66    result = pipeline->RemoveFilterChain(contrastEFilter.get());
67    EXPECT_EQ(result, ErrorCode::SUCCESS);
68}
69
70HWTEST_F(TestEffectPipeline, FilterBaseNamePort001, TestSize.Level1)
71{
72    FilterBase filterBase("testName_");
73    std::string mime = "image/png";
74    std::string expectedPortName = "image_1";
75    std::string portName = filterBase.NamePort(mime);
76
77    EXPECT_EQ(portName, expectedPortName);
78    EXPECT_EQ(filterBase.portTypeCntMap_["testName_image"], 1);
79
80    mime = "";
81    expectedPortName = "default_1";
82    portName = filterBase.NamePort(mime);
83    EXPECT_EQ(portName, expectedPortName);
84    EXPECT_EQ(filterBase.portTypeCntMap_["testName_default"], 1);
85}
86
87HWTEST_F(TestEffectPipeline, FilterBaseGetRouteInPort001, TestSize.Level1)
88{
89    FilterBase filterBase("testNmae_");
90    PInPort result = filterBase.GetRouteInPort("test");
91    EXPECT_EQ(result, nullptr);
92
93    filterBase.routeMap_.emplace_back("test", "test");
94    result = filterBase.GetRouteInPort("test");
95    EXPECT_EQ(result, nullptr);
96}
97
98HWTEST_F(TestEffectPipeline, FilterBaseGetRouteOutPort001, TestSize.Level1)
99{
100    FilterBase filterBase("testNmae_");
101    POutPort result = filterBase.GetRouteOutPort("test");
102    EXPECT_EQ(result, nullptr);
103
104    filterBase.routeMap_.emplace_back("test", "test");
105    result = filterBase.GetRouteOutPort("test");
106    EXPECT_EQ(result, nullptr);
107}
108
109HWTEST_F(TestEffectPipeline, FilterBaseOnEvent001, TestSize.Level1)
110{
111    FilterBase filterBase("testNmae_");
112    const Event &event = Event{ "name_", EventType::EVENT_COMPLETE, { nullptr } };
113    filterBase.OnEvent(event);
114
115    EventReceiver *eventReceiver{ nullptr };
116    filterBase.eventReceiver_ = eventReceiver;
117    filterBase.OnEvent(event);
118}
119
120HWTEST_F(TestEffectPipeline, FilterBaseGetNextFilters001, TestSize.Level1)
121{
122    FilterBase filterBase("testNmae_");
123    InfoTransfer *filterPtr = nullptr;
124    OutPort port(filterPtr);
125    auto outPort = std::make_shared<OutPort>(port);
126    filterBase.outPorts_.push_back(outPort);
127    std::vector<Filter *> filters = filterBase.GetNextFilters();
128    EXPECT_TRUE(filters.empty());
129}
130
131HWTEST_F(TestEffectPipeline, FilterBaseGetPreFilters001, TestSize.Level1)
132{
133    FilterBase filterBase("testNmae_");
134    InfoTransfer *filterPtr = nullptr;
135    InPort port(filterPtr);
136    auto inPort = std::make_shared<InPort>(port);
137    filterBase.inPorts_.push_back(inPort);
138    std::vector<Filter *> filters = filterBase.GetPreFilters();
139    EXPECT_TRUE(filters.empty());
140
141    filterBase.UnlinkPrevFilters();
142
143    auto result = filterBase.FindPort(filterBase.inPorts_, "test");
144    EXPECT_EQ(result, nullptr);
145}
146
147HWTEST_F(TestEffectPipeline, InPortPullData001, TestSize.Level1)
148{
149    std::shared_ptr<BufferInfo> bufferInfo = std::make_unique<BufferInfo>();
150    void *add = nullptr;
151    std::shared_ptr<ExtraInfo> extraInfo = std::make_unique<ExtraInfo>();
152    std::shared_ptr<EffectBuffer> data = std::make_shared<EffectBuffer>(bufferInfo, add, extraInfo);
153
154    InfoTransfer *filterPtr = nullptr;
155    InPort port(filterPtr);
156    auto inPort = std::make_shared<InPort>(port);
157
158    std::shared_ptr<InPort> prevPort = std::make_shared<InPort>(nullptr);
159    inPort->prevPort_ = prevPort;
160
161    ErrorCode result = inPort->PullData(data);
162    ASSERT_EQ(result, ErrorCode::ERR_PIPELINE_INVALID_FILTER_PORT);
163}
164
165HWTEST_F(TestEffectPipeline, InPortActivate001, TestSize.Level1)
166{
167    std::shared_ptr<EFilter> eFilter = EFilterFactory::Instance()->Create(BRIGHTNESS_EFILTER);
168    InPort port(eFilter.get());
169    auto inPort = std::make_shared<InPort>(port);
170
171    std::shared_ptr<InPort> prevPort = std::make_shared<InPort>(port);
172    inPort->prevPort_ = prevPort;
173
174    std::vector<WorkMode> modes;
175    WorkMode outMode;
176    ErrorCode result = inPort->Activate(modes, outMode);
177    ASSERT_EQ(result, ErrorCode::ERR_INVALID_PARAMETER_VALUE);
178}
179}
180}
181}
182}