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 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 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 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 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 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 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 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 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 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 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 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