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 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 #define private public
18 #include "print_range.h"
19 #undef private
20 #include "printer_capability.h"
21 #include "print_margin.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Print {
27 class PrintRangeTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33 };
34
SetUpTestCase(void)35 void PrintRangeTest::SetUpTestCase(void) {}
36
TearDownTestCase(void)37 void PrintRangeTest::TearDownTestCase(void) {}
38
SetUp(void)39 void PrintRangeTest::SetUp(void) {}
40
TearDown(void)41 void PrintRangeTest::TearDown(void) {}
42
43 /**
44 * @tc.name: PrintRangeTest_0002
45 * @tc.desc: Verify the reset function.
46 * @tc.type: FUNC
47 * @tc.require:
48 */
49 HWTEST_F(PrintRangeTest, PrintRangeTest_0002, TestSize.Level1)
50 {
51 OHOS::Print::PrintRange range;
52 range.Reset();
53 EXPECT_FALSE(range.HasStartPage());
54 }
55
56 /**
57 * @tc.name: PrintRangeTest_0003
58 * @tc.desc: Verify the getStartPage function.
59 * @tc.type: FUNC
60 * @tc.require:
61 */
62 HWTEST_F(PrintRangeTest, PrintRangeTest_0003, TestSize.Level1)
63 {
64 OHOS::Print::PrintRange range;
65 range.SetStartPage(6);
66 EXPECT_EQ((uint32_t)6, range.GetStartPage());
67 }
68
69 /**
70 * @tc.name: PrintRangeTest_0004
71 * @tc.desc: Verify the hasEndPage function.
72 * @tc.type: FUNC
73 * @tc.require:
74 */
75 HWTEST_F(PrintRangeTest, PrintRangeTest_0004, TestSize.Level1)
76 {
77 OHOS::Print::PrintRange range;
78 range.SetEndPage(6);
79 EXPECT_TRUE(range.HasEndPage());
80 }
81
82 /**
83 * @tc.name: PrintRangeTest_0005
84 * @tc.desc: Verify the getEndPage function.
85 * @tc.type: FUNC
86 * @tc.require:
87 */
88 HWTEST_F(PrintRangeTest, PrintRangeTest_0005, TestSize.Level1)
89 {
90 OHOS::Print::PrintRange range;
91 range.SetEndPage(6);
92 EXPECT_EQ((uint32_t)6, range.GetEndPage());
93 }
94
95 /**
96 * @tc.name: PrintRangeTest_0006
97 * @tc.desc: Verify the hasPages function.
98 * @tc.type: FUNC
99 * @tc.require:
100 */
101 HWTEST_F(PrintRangeTest, PrintRangeTest_0006, TestSize.Level1)
102 {
103 OHOS::Print::PrintRange range;
104 std::vector<uint32_t> pages = {1, 2, 3};
105 range.SetPages(pages);
106 EXPECT_TRUE(range.HasPages());
107 }
108
109 /**
110 * @tc.name: PrintRangeTest_0007
111 * @tc.desc: Verify the getPages function.
112 * @tc.type: FUNC
113 * @tc.require:
114 */
115 HWTEST_F(PrintRangeTest, PrintRangeTest_0007, TestSize.Level1)
116 {
117 OHOS::Print::PrintRange range;
118 std::vector<uint32_t> pages = {1, 2, 3};
119 range.SetPages(pages);
120 std::vector<uint32_t> getPages;
121 range.GetPages(getPages);
122 EXPECT_EQ((uint32_t)1, getPages[0]);
123 }
124
125 /**
126 * @tc.name: PrintRangeTest_0008
127 * @tc.desc: Verify the marshalling function.
128 * @tc.type: FUNC
129 * @tc.require:
130 */
131 HWTEST_F(PrintRangeTest, PrintRangeTest_0008, TestSize.Level1)
132 {
133 OHOS::Print::PrintRange range;
134 std::vector<uint32_t> pages = {1, 2, 3};
135 range.SetPages(pages);
136 range.SetEndPage(6);
137 range.SetStartPage(6);
138 Parcel parcel;
139 EXPECT_TRUE(range.Marshalling(parcel));
140 }
141
142 /**
143 * @tc.name: PrintRangeTest_0009
144 * @tc.desc: Verify the marshalling function.
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(PrintRangeTest, PrintRangeTest_0009, TestSize.Level1)
149 {
150 OHOS::Print::PrintRange range;
151 std::vector<uint32_t> pages = {1, 2, 3};
152 range.SetPages(pages);
153 range.SetEndPage(6);
154 range.SetStartPage(6);
155 Parcel parcel;
156 EXPECT_TRUE(range.Marshalling(parcel));
157 }
158
159 /**
160 * @tc.name: PrintRangeTest_0010
161 * @tc.desc: Verify the marshalling function.
162 * @tc.type: FUNC
163 * @tc.require:
164 */
165 HWTEST_F(PrintRangeTest, PrintRangeTest_0010, TestSize.Level1)
166 {
167 OHOS::Print::PrintRange range;
168 std::vector<uint32_t> pages = {1, 2, 3};
169 range.SetPages(pages);
170 range.SetEndPage(6);
171 Parcel parcel;
172 EXPECT_TRUE(range.Marshalling(parcel));
173 }
174
175 /**
176 * @tc.name: PrintRangeTest_0011
177 * @tc.desc: Verify the marshalling function.
178 * @tc.type: FUNC
179 * @tc.require:
180 */
181 HWTEST_F(PrintRangeTest, PrintRangeTest_0011, TestSize.Level1)
182 {
183 OHOS::Print::PrintRange range;
184 std::vector<uint32_t> pages = {1, 2, 3};
185 range.SetPages(pages);
186 range.SetStartPage(6);
187 Parcel parcel;
188 EXPECT_TRUE(range.Marshalling(parcel));
189 }
190
191 /**
192 * @tc.name: PrintRangeTest_0012
193 * @tc.desc: Verify the marshalling function.
194 * @tc.type: FUNC
195 * @tc.require:
196 */
197 HWTEST_F(PrintRangeTest, PrintRangeTest_0012, TestSize.Level1)
198 {
199 OHOS::Print::PrintRange range;
200 range.SetEndPage(6);
201 range.SetStartPage(6);
202 Parcel parcel;
203 EXPECT_TRUE(range.Marshalling(parcel));
204 }
205
206 /**
207 * @tc.name: PrintRangeTest_0013
208 * @tc.desc: Verify the unmarshalling function.
209 * @tc.type: FUNC
210 * @tc.require:
211 */
212 HWTEST_F(PrintRangeTest, PrintRangeTest_0013, TestSize.Level1)
213 {
214 OHOS::Print::PrintRange range;
215 std::vector<uint32_t> pages = {1, 2, 3};
216 range.SetPages(pages);
217 range.SetEndPage(6);
218 range.SetStartPage(6);
219 Parcel parcel;
220 range.Marshalling(parcel);
221 auto result = OHOS::Print::PrintRange::Unmarshalling(parcel);
222 EXPECT_NE(nullptr, result);
223 }
224
225 /**
226 * @tc.name: PrintRangeTest_0014
227 * @tc.desc: Verify the copy constructor function.
228 * @tc.type: FUNC
229 * @tc.require:
230 */
231 HWTEST_F(PrintRangeTest, PrintRangeTest_0014, TestSize.Level1)
232 {
233 OHOS::Print::PrintRange range;
234 range.SetEndPage(6);
235 OHOS::Print::PrintRange copyRange(range);
236 EXPECT_EQ(copyRange.GetEndPage(), range.GetEndPage());
237 }
238
239 /**
240 * @tc.name: PrintRangeTest_0015
241 * @tc.desc: Verify the assignment construction function.
242 * @tc.type: FUNC
243 * @tc.require:
244 */
245 HWTEST_F(PrintRangeTest, PrintRangeTest_0015, TestSize.Level1)
246 {
247 OHOS::Print::PrintRange range;
248 range.SetEndPage(6);
249 OHOS::Print::PrintRange copyRange = range;
250 EXPECT_EQ(copyRange.GetEndPage(), range.GetEndPage());
251 }
252
253 /**
254 * @tc.name: PrintRangeTest_0016
255 * @tc.desc: Verify the constructor function.
256 * @tc.type: FUNC
257 * @tc.require:
258 */
259 HWTEST_F(PrintRangeTest, PrintRangeTest_0016, TestSize.Level1)
260 {
261 OHOS::Print::PrintRange range;
262 range.SetStartPage(0);
263 range.SetEndPage(5);
264 range.SetPages({0, 1, 2, 3, 4, 5});
265 range.Dump();
266
267 EXPECT_EQ(range.GetStartPage(), 0);
268 EXPECT_EQ(range.GetEndPage(), 5);
269 EXPECT_EQ(range.hasPages_, true);
270 }
271
272 } // namespace Print
273 } // namespace OHOS