1 /**
2 * Copyright 2021 Huawei Technologies Co., Ltd
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <memory>
18 #include "common/common.h"
19 #include "minddata/dataset/kernels/ir/vision/random_affine_ir.h"
20 #include "minddata/dataset/kernels/ir/vision/random_color_adjust_ir.h"
21 #include "minddata/dataset/kernels/ir/vision/random_color_ir.h"
22 #include "minddata/dataset/kernels/ir/vision/random_crop_decode_resize_ir.h"
23 #include "minddata/dataset/kernels/ir/vision/random_crop_ir.h"
24 #include "minddata/dataset/kernels/ir/vision/random_crop_with_bbox_ir.h"
25 #include "minddata/dataset/kernels/ir/vision/random_horizontal_flip_ir.h"
26 #include "minddata/dataset/kernels/ir/vision/random_horizontal_flip_with_bbox_ir.h"
27 #include "minddata/dataset/kernels/ir/vision/random_posterize_ir.h"
28 #include "minddata/dataset/kernels/ir/vision/random_resized_crop_ir.h"
29 #include "minddata/dataset/kernels/ir/vision/random_resized_crop_with_bbox_ir.h"
30 #include "minddata/dataset/kernels/ir/vision/random_resize_ir.h"
31 #include "minddata/dataset/kernels/ir/vision/random_resize_with_bbox_ir.h"
32 #include "minddata/dataset/kernels/ir/vision/random_rotation_ir.h"
33 #include "minddata/dataset/kernels/ir/vision/random_select_subpolicy_ir.h"
34 #include "minddata/dataset/kernels/ir/vision/random_sharpness_ir.h"
35 #include "minddata/dataset/kernels/ir/vision/random_solarize_ir.h"
36 #include "minddata/dataset/kernels/ir/vision/random_vertical_flip_ir.h"
37 #include "minddata/dataset/kernels/ir/vision/random_vertical_flip_with_bbox_ir.h"
38
39 using namespace mindspore::dataset;
40
41 class MindDataTestIRVision : public UT::DatasetOpTesting {
42 public:
43 MindDataTestIRVision() = default;
44 };
45
TEST_F(MindDataTestIRVision,TestRandomColorIRFail)46 TEST_F(MindDataTestIRVision, TestRandomColorIRFail) {
47 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomColorIRFail.";
48
49 // Testing invalid lower bound > upper bound
50 std::shared_ptr<TensorOperation> random_color1(new vision::RandomColorOperation(1.0, 0.1));
51 Status rc1 = random_color1->ValidateParams();
52 EXPECT_ERROR(rc1);
53
54 // Testing invalid negative lower bound
55 std::shared_ptr<TensorOperation> random_color2(new vision::RandomColorOperation(-0.5, 0.5));
56 Status rc2 = random_color2->ValidateParams();
57 EXPECT_ERROR(rc2);
58 }
59
TEST_F(MindDataTestIRVision,TestRandomColorAdjustIRFail)60 TEST_F(MindDataTestIRVision, TestRandomColorAdjustIRFail) {
61 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomColorAdjustIRFail.";
62
63 // Testing invalid brightness out of range
64 std::shared_ptr<TensorOperation> random_color_adjust1(
65 new vision::RandomColorAdjustOperation({-1.0}, {0.0}, {0.0}, {0.0}));
66 Status rc1 = random_color_adjust1->ValidateParams();
67 EXPECT_ERROR(rc1);
68
69 // Testing invalid contrast out of range
70 std::shared_ptr<TensorOperation> random_color_adjust2(
71 new vision::RandomColorAdjustOperation({1.0}, {-0.1}, {0.0}, {0.0}));
72 Status rc2 = random_color_adjust2->ValidateParams();
73 EXPECT_ERROR(rc2);
74
75 // Testing invalid saturation out of range
76 std::shared_ptr<TensorOperation> random_color_adjust3(
77 new vision::RandomColorAdjustOperation({0.0}, {0.0}, {-0.2}, {0.0}));
78 Status rc3 = random_color_adjust3->ValidateParams();
79 EXPECT_ERROR(rc3);
80
81 // Testing invalid hue out of range
82 std::shared_ptr<TensorOperation> random_color_adjust4(
83 new vision::RandomColorAdjustOperation({0.0}, {0.0}, {0.0}, {-0.6}));
84 Status rc4 = random_color_adjust4->ValidateParams();
85 EXPECT_ERROR(rc4);
86
87 // Testing invalid hue out of range
88 std::shared_ptr<TensorOperation> random_color_adjust5(
89 new vision::RandomColorAdjustOperation({0.0}, {0.0}, {0.0}, {-0.5, 0.6}));
90 Status rc5 = random_color_adjust5->ValidateParams();
91 EXPECT_ERROR(rc5);
92
93 // Testing invalid hue
94 std::shared_ptr<TensorOperation> random_color_adjust6(
95 new vision::RandomColorAdjustOperation({0.0}, {0.0}, {0.0}, {0.51}));
96 Status rc6 = random_color_adjust4->ValidateParams();
97 EXPECT_ERROR(rc6);
98 }
99
TEST_F(MindDataTestIRVision,TestRandomHorizontalFlipIRFail)100 TEST_F(MindDataTestIRVision, TestRandomHorizontalFlipIRFail) {
101 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomHorizontalFlipIRFail.";
102
103 // Testing invalid negative input
104 std::shared_ptr<TensorOperation> random_horizontal_flip1(new vision::RandomHorizontalFlipOperation(-0.5));
105 Status rc1 = random_horizontal_flip1->ValidateParams();
106 EXPECT_ERROR(rc1);
107
108 // Testing invalid >1 input
109 std::shared_ptr<TensorOperation> random_horizontal_flip2(new vision::RandomHorizontalFlipOperation(2));
110 Status rc2 = random_horizontal_flip2->ValidateParams();
111 EXPECT_ERROR(rc2);
112 }
113
TEST_F(MindDataTestIRVision,TestRandomHorizontalFlipWithBBoxIRFail)114 TEST_F(MindDataTestIRVision, TestRandomHorizontalFlipWithBBoxIRFail) {
115 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomHorizontalFlipWithBBoxIRFail.";
116
117 // Testing invalid negative input
118 std::shared_ptr<TensorOperation> random_horizontal_flip_bbox1(
119 new vision::RandomHorizontalFlipWithBBoxOperation(-1.0));
120 Status rc1 = random_horizontal_flip_bbox1->ValidateParams();
121 EXPECT_ERROR(rc1);
122
123 // Testing invalid >1 input
124 std::shared_ptr<TensorOperation> random_horizontal_flip_bbox2(new vision::RandomHorizontalFlipWithBBoxOperation(2.0));
125 Status rc2 = random_horizontal_flip_bbox2->ValidateParams();
126 EXPECT_ERROR(rc2);
127 }
128
TEST_F(MindDataTestIRVision,TestRandomPosterizeIRFail)129 TEST_F(MindDataTestIRVision, TestRandomPosterizeIRFail) {
130 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomPosterizeIRFail.";
131
132 // Testing invalid max > 8
133 std::shared_ptr<TensorOperation> random_posterize1(new vision::RandomPosterizeOperation({1, 9}));
134 Status rc1 = random_posterize1->ValidateParams();
135 EXPECT_ERROR(rc1);
136
137 // Testing invalid min < 1
138 std::shared_ptr<TensorOperation> random_posterize2(new vision::RandomPosterizeOperation({0, 8}));
139 Status rc2 = random_posterize2->ValidateParams();
140 EXPECT_ERROR(rc2);
141
142 // Testing invalid min > max
143 std::shared_ptr<TensorOperation> random_posterize3(new vision::RandomPosterizeOperation({8, 1}));
144 Status rc3 = random_posterize3->ValidateParams();
145 EXPECT_ERROR(rc3);
146
147 // Testing invalid empty input
148 std::shared_ptr<TensorOperation> random_posterize4(new vision::RandomPosterizeOperation({}));
149 Status rc4 = random_posterize4->ValidateParams();
150 EXPECT_ERROR(rc4);
151 }
152
TEST_F(MindDataTestIRVision,TestRandomResizeIRFail)153 TEST_F(MindDataTestIRVision, TestRandomResizeIRFail) {
154 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomResizeIRFail.";
155
156 // Testing invalid: size must only contain positive integers
157 std::shared_ptr<TensorOperation> random_resize1(new vision::RandomResizeOperation({-66, 77}));
158 Status rc1 = random_resize1->ValidateParams();
159 EXPECT_ERROR(rc1);
160
161 // Testing invalid: size must only contain positive integers
162 std::shared_ptr<TensorOperation> random_resize2(new vision::RandomResizeOperation({0, 77}));
163 Status rc2 = random_resize2->ValidateParams();
164 EXPECT_ERROR(rc2);
165
166 // Testing invalid: size must be a vector of one or two values
167 std::shared_ptr<TensorOperation> random_resize3(new vision::RandomResizeOperation({1, 2, 3}));
168 Status rc3 = random_resize3->ValidateParams();
169 EXPECT_ERROR(rc3);
170
171 // Testing invalid: size must be a vector of one or two values
172 std::shared_ptr<TensorOperation> random_resize4(new vision::RandomResizeOperation({}));
173 Status rc4 = random_resize4->ValidateParams();
174 EXPECT_ERROR(rc4);
175 }
176
TEST_F(MindDataTestIRVision,TestRandomResizeWithBBoxIRFail)177 TEST_F(MindDataTestIRVision, TestRandomResizeWithBBoxIRFail) {
178 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomResizeWithBBoxIRFail.";
179
180 // Testing invalid: size must only contain positive integers
181 std::shared_ptr<TensorOperation> random_resize_with_bbox1(new vision::RandomResizeWithBBoxOperation({-66, 77}));
182 Status rc1 = random_resize_with_bbox1->ValidateParams();
183 EXPECT_ERROR(rc1);
184
185 // Testing invalid: size must be a vector of one or two values
186 std::shared_ptr<TensorOperation> random_resize_with_bbox2(new vision::RandomResizeWithBBoxOperation({1, 2, 3}));
187 Status rc2 = random_resize_with_bbox2->ValidateParams();
188 EXPECT_ERROR(rc2);
189
190 // Testing invalid: size must be a vector of one or two values
191 std::shared_ptr<TensorOperation> random_resize_with_bbox3(new vision::RandomResizeWithBBoxOperation({}));
192 Status rc3 = random_resize_with_bbox3->ValidateParams();
193 EXPECT_ERROR(rc3);
194 }
195
TEST_F(MindDataTestIRVision,TestRandomSharpnessIRFail)196 TEST_F(MindDataTestIRVision, TestRandomSharpnessIRFail) {
197 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomSharpnessIRFail.";
198
199 // Testing invalid empty degrees vector
200 std::shared_ptr<TensorOperation> random_sharpness1(new vision::RandomSharpnessOperation({}));
201 Status rc1 = random_sharpness1->ValidateParams();
202 EXPECT_ERROR(rc1);
203
204 // Testing invalid single degree value
205 std::shared_ptr<TensorOperation> random_sharpness2(new vision::RandomSharpnessOperation({0.1}));
206 Status rc2 = random_sharpness2->ValidateParams();
207 EXPECT_ERROR(rc2);
208 }
209
TEST_F(MindDataTestIRVision,TestRandomSolarizeIRFail)210 TEST_F(MindDataTestIRVision, TestRandomSolarizeIRFail) {
211 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomSolarizeIRFail.";
212
213 // Testing invalid lower bound > upper bound
214 std::shared_ptr<TensorOperation> random_solarize1(new vision::RandomSolarizeOperation({13, 1}));
215 Status rc1 = random_solarize1->ValidateParams();
216 EXPECT_ERROR(rc1);
217
218 // Testing invalid threshold must be a vector of two values
219 std::shared_ptr<TensorOperation> random_solarize2(new vision::RandomSolarizeOperation({1, 2, 3}));
220 Status rc2 = random_solarize2->ValidateParams();
221 EXPECT_ERROR(rc2);
222
223 // Testing invalid threshold must be a vector of two values
224 std::shared_ptr<TensorOperation> random_solarize3(new vision::RandomSolarizeOperation({1}));
225 Status rc3 = random_solarize3->ValidateParams();
226 EXPECT_ERROR(rc3);
227
228 // Testing invalid empty threshold
229 std::shared_ptr<TensorOperation> random_solarize4(new vision::RandomSolarizeOperation({}));
230 Status rc4 = random_solarize4->ValidateParams();
231 EXPECT_ERROR(rc4);
232 }
233
TEST_F(MindDataTestIRVision,TestRandomVerticalFlipIRFail)234 TEST_F(MindDataTestIRVision, TestRandomVerticalFlipIRFail) {
235 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomVerticalFlipIRFail.";
236
237 // Testing invalid negative input
238 std::shared_ptr<TensorOperation> random_vertical_flip1(new vision::RandomVerticalFlipOperation(-0.5));
239 Status rc1 = random_vertical_flip1->ValidateParams();
240 EXPECT_ERROR(rc1);
241
242 // Testing invalid >1 input
243 std::shared_ptr<TensorOperation> random_vertical_flip2(new vision::RandomVerticalFlipOperation(1.1));
244 Status rc2 = random_vertical_flip2->ValidateParams();
245 EXPECT_ERROR(rc2);
246 }
247
TEST_F(MindDataTestIRVision,TestRandomVerticalFlipWithBBoxIRFail)248 TEST_F(MindDataTestIRVision, TestRandomVerticalFlipWithBBoxIRFail) {
249 MS_LOG(INFO) << "Doing MindDataTestIRVision-TestRandomVerticalFlipWithBBoxIRFail.";
250
251 // Testing invalid negative input
252 std::shared_ptr<TensorOperation> random_vertical_flip1(new vision::RandomVerticalFlipWithBBoxOperation(-0.5));
253 Status rc1 = random_vertical_flip1->ValidateParams();
254 EXPECT_ERROR(rc1);
255
256 // Testing invalid >1 input
257 std::shared_ptr<TensorOperation> random_vertical_flip2(new vision::RandomVerticalFlipWithBBoxOperation(3.0));
258 Status rc2 = random_vertical_flip2->ValidateParams();
259 EXPECT_ERROR(rc2);
260 }
261