1 /*
2  * Copyright (c) 2023 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 #include <sys/types.h>
16 #include <sys/stat.h>
17 #include <fcntl.h>
18 #include "camera_hdi_sequenceable_test.h"
19 #include "map_data_sequenceable.h"
20 #include "buffer_handle_sequenceable.h"
21 #include "buffer_producer_sequenceable.h"
22 #include "buffer_util.h"
23 using namespace OHOS;
24 using namespace std;
25 using namespace testing::ext;
26 using namespace OHOS::Camera;
27 using namespace OHOS::HDI::Camera::V1_0;
28 
SetUpTestCase(void)29 void CameraHdiSequenceableTest::SetUpTestCase(void) {}
TearDownTestCase(void)30 void CameraHdiSequenceableTest::TearDownTestCase(void) {}
SetUp(void)31 void CameraHdiSequenceableTest::SetUp(void)
32 {
33     cout << "CameraHdiSequenceableTest::SetUp()" << endl;
34 }
35 
TearDown(void)36 void CameraHdiSequenceableTest::TearDown(void)
37 {
38     cout << "CameraHdiSequenceableTest::TearDown()" << endl;
39 }
40 
41 /**
42  * @tc.name: MapDataSequencebleTest_01
43  * @tc.desc: MapDataSequencebleTest_01
44  * @tc.size: MediumTest
45  * @tc.type: Function
46  */
47 HWTEST_F(CameraHdiSequenceableTest, MapDataSequencebleTest_01, TestSize.Level1)
48 {
49     int32_t ret;
50     cout << "CameraHdiSequenceableTest::MapDataSequencebleTest_01" << endl;
51     auto mapDataSequenceable = make_shared<MapDataSequenceable>();
52     // Get and Set Test
53     int32_t i32Temp0 = 12345678;
54     int32_t i32Temp1 = 0;
55     ret= mapDataSequenceable->Set("i32Temp", i32Temp0);
56     EXPECT_EQ(ret, 0);
57     ret = mapDataSequenceable->Get("i32Temp", i32Temp1);
58     EXPECT_EQ(ret, 0);
59     EXPECT_EQ(i32Temp0, i32Temp1);
60 
61     int64_t i64Temp0 = 12345678;
62     int64_t i64Temp1 = 0;
63     ret = mapDataSequenceable->Set("i64Temp", i64Temp0);
64     EXPECT_EQ(ret, 0);
65     ret = mapDataSequenceable->Get("i64Temp", i64Temp1);
66     EXPECT_EQ(ret, 0);
67     EXPECT_EQ(i64Temp0, i64Temp1);
68 
69     double doubleTemp0 = 1234.5678;
70     double doubleTemp1 = 0;
71     ret = mapDataSequenceable->Set("doubleTemp", doubleTemp0);
72     EXPECT_EQ(ret, 0);
73     ret = mapDataSequenceable->Get("doubleTemp", doubleTemp1);
74     EXPECT_EQ(ret, 0);
75     EXPECT_EQ(doubleTemp1, doubleTemp0);
76 
77     string stringTemp0 = "s1234.5678";
78     string stringTemp1 = "0";
79     ret = mapDataSequenceable->Set("stringTemp", stringTemp0);
80     EXPECT_EQ(ret, 0);
81     ret = mapDataSequenceable->Get("stringTemp", stringTemp1);
82     EXPECT_EQ(ret, 0);
83     EXPECT_EQ(stringTemp1, stringTemp0);
84 
85     // Marshalling and Unmarshalling Test
86     Parcel parcel;
87     ret = mapDataSequenceable->Marshalling(parcel);
88     EXPECT_EQ(ret, true);
89     auto mapDataSequenceable2 = MapDataSequenceable::Unmarshalling(parcel);
90     EXPECT_NE(mapDataSequenceable2, nullptr);
91 
92     int32_t i32Temp2 = 0;
93     ret = mapDataSequenceable2->Get("i32Temp", i32Temp2);
94     EXPECT_EQ(ret, 0);
95     EXPECT_EQ(i32Temp0, i32Temp2);
96 
97     int64_t i64Temp2 = 0;
98     ret = mapDataSequenceable2->Get("i64Temp", i64Temp2);
99     EXPECT_EQ(ret, 0);
100     EXPECT_EQ(i64Temp0, i64Temp2);
101 
102     double doubleTemp2 = 0;
103     ret = mapDataSequenceable2->Get("doubleTemp", doubleTemp2);
104     EXPECT_EQ(ret, 0);
105     EXPECT_EQ(doubleTemp0, doubleTemp2);
106 
107     string stringTemp2= "0";
108     ret = mapDataSequenceable2->Get("stringTemp", stringTemp2);
109     EXPECT_EQ(ret, 0);
110     EXPECT_EQ(stringTemp0, stringTemp2);
111 }
112 
113 /**
114  * @tc.name: BufferHandleSequencebleTest_01
115  * @tc.desc: BufferHandleSequencebleTest_01
116  * @tc.size: MediumTest
117  * @tc.type: Function
118  */
119 HWTEST_F(CameraHdiSequenceableTest, BufferHandleSequencebleTest_01, TestSize.Level1)
120 {
121     constexpr int32_t reserveFds = 1;
122     constexpr int32_t reserveInts = 0;
123     int32_t ret;
124     BufferHandle* handle0 = BufferHandleSequenceable::NewBufferHandle(reserveFds, reserveInts);
125     handle0->fd = open("/dev/null", O_WRONLY);
126     handle0->reserve[0] = dup(handle0->fd);
127     EXPECT_NE(handle0, nullptr);
128     auto bufferHandleSeq0 = make_shared<BufferHandleSequenceable>(handle0);
129     BufferHandle* handle1 = bufferHandleSeq0->GetBufferHandle();
130     EXPECT_NE(handle1, nullptr);
131     Parcel parcel;
132     ret = bufferHandleSeq0->Marshalling(parcel);
133     EXPECT_EQ(ret, true);
134     auto bufferHandleSeq1 = BufferHandleSequenceable::Unmarshalling(parcel);
135     EXPECT_NE(bufferHandleSeq1, nullptr);
136     BufferHandle* handle2 = bufferHandleSeq1->GetBufferHandle();
137     EXPECT_NE(handle2, nullptr);
138     EXPECT_EQ(handle2->reserveFds, reserveFds);
139 }
140 
141 /**
142  * @tc.name: BufferHandleSequencebleTest_02
143  * @tc.desc: BufferHandleSequencebleTest_02
144  * @tc.size: MediumTest
145  * @tc.type: Function
146  */
147 HWTEST_F(CameraHdiSequenceableTest, BufferHandleSequencebleTest_02, TestSize.Level1)
148 {
149     constexpr int32_t reserveFds = 1;
150     constexpr int32_t reserveInts = 0;
151     BufferHandle* handle0 = BufferHandleSequenceable::NewBufferHandle(reserveFds, reserveInts);
152     EXPECT_NE(handle0, nullptr);
153     auto bufferHandleSeq0 = make_shared<BufferHandleSequenceable>(handle0);
154     bufferHandleSeq0->SetBufferHandle(handle0);
155     BufferHandle bufferHandle;
156     bufferHandle.reserveFds = 1;
157     bufferHandle.reserveInts = 2;
158     new BufferHandleSequenceable(bufferHandle);
159 }
160 
161 /**
162  * @tc.name: BufferHandleSequenceTest_03
163  * @tc.desc: BufferHandleSequenceTest_03
164  * @tc.size: MediumTest
165  * @tc.type: Function
166  */
167 HWTEST_F(CameraHdiSequenceableTest, BufferHandleSequenceTest_03, TestSize.Level1)
168 {
169     OHOS::HDI::Camera::V1_0::BufferHandleSequenceable bufferHandleSequenceble01;
170     OHOS::HDI::Camera::V1_0::BufferHandleSequenceable bufferHandleSequenceble02;
171     bufferHandleSequenceble01.operator = (bufferHandleSequenceble02);
172     Parcel parcel;
173     bufferHandleSequenceble01.Marshalling(parcel);
174     BufferHandleSequenceable::Unmarshalling(parcel);
175 }
176 
177 /**
178  * @tc.name: BufferProducerSequenceTest_01
179  * @tc.desc: BufferProducerSequenceTest_01
180  * @tc.size: MediumTest
181  * @tc.type: Function
182  */
183 HWTEST_F(CameraHdiSequenceableTest, BufferProducerSequenceTest_01, TestSize.Level1)
184 {
185     OHOS::HDI::Camera::V1_0::BufferProducerSequenceable bufferProducerSequenceble01;
186     OHOS::HDI::Camera::V1_0::BufferProducerSequenceable bufferProducerSequenceble02;
187     bufferProducerSequenceble01 = bufferProducerSequenceble02;
188     Parcel parcel;
189     bufferProducerSequenceble01.Marshalling(parcel);
190     BufferProducerSequenceable::Unmarshalling(parcel);
191 }