OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 package org.chromium.base.test.util.parameter; |
| 6 |
| 7 import android.app.Activity; |
| 8 import android.test.MoreAsserts; |
| 9 import android.test.suitebuilder.annotation.SmallTest; |
| 10 |
| 11 import org.chromium.base.test.BaseActivityInstrumentationTestCase; |
| 12 import org.chromium.base.test.util.parameter.parameters.MethodParameter; |
| 13 |
| 14 /** |
| 15 * Tester class for the {@link ParameterizedTest} annotation and the {@link Para
meterizedTest.Set} |
| 16 * annotation. |
| 17 * |
| 18 * Also, tests the {@link MethodParameter} parameter. |
| 19 */ |
| 20 public class ParameterizedTestAnnotationTest extends |
| 21 BaseActivityInstrumentationTestCase<Activity> { |
| 22 public ParameterizedTestAnnotationTest() { |
| 23 super(Activity.class); |
| 24 } |
| 25 |
| 26 @SmallTest |
| 27 public void testNoParameterizedTestAnnotation() { |
| 28 assertFalse("This is a parameterized test when it should not be.", getPa
rameterReader() |
| 29 .isParameterizedTest()); |
| 30 assertNull("someParameter should not exist.", getParameterReader() |
| 31 .getParameter("someParameter")); |
| 32 assertNull("someParameterArgument should not exist.", getParameterReader
() |
| 33 .getParameterArgument("someParameter", "someParameterArgument"))
; |
| 34 } |
| 35 |
| 36 @SmallTest |
| 37 @ParameterizedTest() |
| 38 public void testEmptyParameterizedTestAnnotation() { |
| 39 assertTrue("This is not a parameterized test.", getParameterReader() |
| 40 .isParameterizedTest()); |
| 41 assertNull("someParameter should not exist.", getParameterReader() |
| 42 .getParameter("someParameter")); |
| 43 assertNull("someParameterArgument should not exist.", getParameterReader
() |
| 44 .getParameterArgument("someParameter", "someParameterArgument"))
; |
| 45 } |
| 46 |
| 47 @SmallTest |
| 48 @ParameterizedTest(parameters = {}) |
| 49 public void testParameterizedTestWithEmptyParameters() { |
| 50 assertTrue("This is not a parameterized test.", getParameterReader() |
| 51 .isParameterizedTest()); |
| 52 assertNull("someParameter should not exist.", getParameterReader() |
| 53 .getParameter("someParameter")); |
| 54 assertNull("someParameterArgument should not exist.", getParameterReader
() |
| 55 .getParameterArgument("someParameter", "someParameterArgument"))
; |
| 56 } |
| 57 |
| 58 @SmallTest |
| 59 @ParameterizedTest(parameters = {}) |
| 60 public void testParameterDoesNotExist() { |
| 61 Parameter parameter = getParameterReader().getParameter(MethodParameter.
PARAMETER_TAG); |
| 62 assertNull("method-parameter should not exist.", parameter); |
| 63 } |
| 64 |
| 65 @SmallTest |
| 66 @ParameterizedTest(parameters = {@Parameter(tag = MethodParameter.PARAMETER_
TAG)}) |
| 67 public void testGetParameter() { |
| 68 String expected = "method-parameter"; |
| 69 String actual = getParameterReader().getParameter(MethodParameter.PARAME
TER_TAG).tag(); |
| 70 assertEquals("Parameter tag did not match expected.", expected, actual); |
| 71 } |
| 72 |
| 73 @SmallTest |
| 74 @ParameterizedTest(parameters = {@Parameter(tag = MethodParameter.PARAMETER_
TAG)}) |
| 75 public void testParameterArgumentDoesNotExist() { |
| 76 Parameter.Argument actual = getArgument("arg"); |
| 77 assertNull("arg should not exist.", actual); |
| 78 } |
| 79 |
| 80 @SmallTest |
| 81 @ParameterizedTest(parameters = { |
| 82 @Parameter(tag = MethodParameter.PARAMETER_TAG, |
| 83 arguments = {@Parameter.Argument(name = "string", stringVar
= "value")})}) |
| 84 public void testMethodParametersWithOneStringValue() { |
| 85 String expected = "value"; |
| 86 String actual = getArgument("string").stringVar(); |
| 87 assertEquals(mismatchMessage("string"), expected, actual); |
| 88 } |
| 89 |
| 90 @SmallTest |
| 91 @ParameterizedTest(parameters = { |
| 92 @Parameter(tag = MethodParameter.PARAMETER_TAG, |
| 93 arguments = {@Parameter.Argument(name = "int", intVar = 0)})
}) |
| 94 public void testMethodParametersWithOneIntValue() { |
| 95 int expected = 0; |
| 96 int actual = getArgument("int").intVar(); |
| 97 assertEquals(mismatchMessage("int"), expected, actual); |
| 98 } |
| 99 |
| 100 @SmallTest |
| 101 @ParameterizedTest(parameters = { |
| 102 @Parameter(tag = MethodParameter.PARAMETER_TAG, |
| 103 arguments = { |
| 104 @Parameter.Argument(name = "intArray", intArray = {5
, 10, -6, 0, -1})}) |
| 105 }) |
| 106 public void testMethodParametersWithOneIntArrayValue() { |
| 107 int[] expected = new int[] {5, 10, -6, 0, -1}; |
| 108 int[] actual = getArgument("intArray").intArray(); |
| 109 assertEquals("Expected length and actual length are different.", expecte
d.length, |
| 110 actual.length); |
| 111 MoreAsserts.assertEquals(mismatchMessage("intArray"), expected, actual); |
| 112 } |
| 113 |
| 114 @SmallTest |
| 115 @ParameterizedTest(parameters = { |
| 116 @Parameter(tag = MethodParameter.PARAMETER_TAG, |
| 117 arguments = {@Parameter.Argument(name = "stringArray", strin
gArray = { |
| 118 "apple", "banana", "orange", "melon", "lemon"})})}) |
| 119 public void testMethodParametersWithOneStringArrayValue() { |
| 120 String[] expected = new String[] {"apple", "banana", "orange", "melon",
"lemon"}; |
| 121 String[] actual = getArgument("stringArray").stringArray(); |
| 122 assertEquals("Expected length and actual length are different.", expecte
d.length, |
| 123 actual.length); |
| 124 MoreAsserts.assertEquals(mismatchMessage("stringArary"), expected, actua
l); |
| 125 } |
| 126 |
| 127 @SmallTest |
| 128 @ParameterizedTest(parameters = { |
| 129 @Parameter(tag = MethodParameter.PARAMETER_TAG, |
| 130 arguments = { |
| 131 @Parameter.Argument(name = "string1", stringVar = "h
as vowel"), |
| 132 @Parameter.Argument(name = "string2", stringVar = "h
s vwl"), |
| 133 @Parameter.Argument(name = "stringArray1", stringArr
ay = { |
| 134 "apple", "banana", "orange", "melon", "lemon
"}), |
| 135 @Parameter.Argument(name = "stringArray2", stringArr
ay = { |
| 136 "ppl", "bnn", "mln", "lmn"}), |
| 137 @Parameter.Argument(name = "int1", intVar = 2), |
| 138 @Parameter.Argument(name = "int2", intVar = 10), |
| 139 @Parameter.Argument(name = "intArray1", intArray = { |
| 140 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37})
, |
| 141 @Parameter.Argument(name = "intArray2", intArray = {
4})})}) |
| 142 public void testMethodParametersWithMultipleArguments1() { |
| 143 String stringVar = getArgument("string1").stringVar(); |
| 144 assertEquals(mismatchMessage("string1"), "has vowel", stringVar); |
| 145 |
| 146 stringVar = getArgument("string2").stringVar(); |
| 147 assertEquals(mismatchMessage("string2"), "hs vwl", stringVar); |
| 148 |
| 149 int intVar = getArgument("int1").intVar(); |
| 150 assertEquals(mismatchMessage("int1"), 2, intVar); |
| 151 |
| 152 intVar = getArgument("int2").intVar(); |
| 153 assertEquals(mismatchMessage("int2"), 10, intVar); |
| 154 |
| 155 String[] stringArray = getArgument("stringArray1").stringArray(); |
| 156 String[] expectedStringArray = new String[] {"apple", "banana", "orange"
, "melon", "lemon"}; |
| 157 MoreAsserts.assertEquals("stringArray1 did not match", expectedStringArr
ay, stringArray); |
| 158 |
| 159 stringArray = getArgument("stringArray2").stringArray(); |
| 160 expectedStringArray = new String[] {"ppl", "bnn", "mln", "lmn"}; |
| 161 MoreAsserts.assertEquals("stringArray2 did not match", expectedStringArr
ay, stringArray); |
| 162 |
| 163 int[] intArray = getArgument("intArray1").intArray(); |
| 164 int[] expectedIntArray = new int[] {2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
31, 37}; |
| 165 MoreAsserts.assertEquals("intArray1 did not match", expectedIntArray, in
tArray); |
| 166 |
| 167 intArray = getArgument("intArray2").intArray(); |
| 168 expectedIntArray = new int[] {4}; |
| 169 MoreAsserts.assertEquals("intArray2 did not match", expectedIntArray, in
tArray); |
| 170 } |
| 171 |
| 172 @SmallTest |
| 173 @ParameterizedTest(parameters = { |
| 174 @Parameter( |
| 175 tag = MethodParameter.PARAMETER_TAG, |
| 176 arguments = { |
| 177 @Parameter.Argument(name = "string1", stringVar = "t
estvalue"), |
| 178 @Parameter.Argument(name = "string2", stringVar = "b
lahblah"), |
| 179 @Parameter.Argument(name = "int1", intVar = 4), |
| 180 @Parameter.Argument(name = "int2", intVar = 0)})}) |
| 181 public void testMethodParametersWithMultipleArguments2() { |
| 182 assertEquals("bar variable should equals \"testvalue\"", "testvalue", |
| 183 getArgument("string1").stringVar()); |
| 184 assertEquals("foo variable should equals \"blahblah\"", "blahblah", |
| 185 getArgument("string2").stringVar()); |
| 186 assertEquals("intArg1 variable should equals 4", 4, |
| 187 getArgument("int1").intVar()); |
| 188 assertEquals("intArg2 variable should equals 0", 0, |
| 189 getArgument("int2").intVar()); |
| 190 } |
| 191 |
| 192 @SmallTest |
| 193 @ParameterizedTest.Set(tests = { |
| 194 @ParameterizedTest(parameters = { |
| 195 @Parameter( |
| 196 tag = MethodParameter.PARAMETER_TAG, |
| 197 arguments = { |
| 198 @Parameter.Argument(name = "string1", string
Var = "testvalue"), |
| 199 @Parameter.Argument(name = "string2", string
Var = "blahblah"), |
| 200 @Parameter.Argument(name = "int1", intVar =
4), |
| 201 @Parameter.Argument(name = "int2", intVar =
0)})})}) |
| 202 public void testParameterArgumentsWithParameterSetOfOneTest() { |
| 203 assertEquals("bar variable should equals \"testvalue\"", "testvalue", |
| 204 getArgument("string1").stringVar()); |
| 205 assertEquals("foo variable should equals \"blahblah\"", "blahblah", |
| 206 getArgument("string2").stringVar()); |
| 207 assertEquals("intArg1 variable should equals 4", 4, |
| 208 getArgument("int1").intVar()); |
| 209 assertEquals("intArg2 variable should equals 0", 0, |
| 210 getArgument("int2").intVar()); |
| 211 } |
| 212 |
| 213 /** |
| 214 * These next three tests all accomplish the same task but in different way
s. |
| 215 * |
| 216 * testParameterArgumentsWithParameterSetOfMoreThanOneTest tests fib() by h
aving a set for |
| 217 * each possible input. While this is fine, it is rather verbose. |
| 218 * |
| 219 * Continued @ testSingleTestParameterArgumentsWithParameterSet |
| 220 */ |
| 221 @SmallTest |
| 222 @ParameterizedTest.Set(tests = { |
| 223 @ParameterizedTest(parameters = { |
| 224 @Parameter( |
| 225 tag = MethodParameter.PARAMETER_TAG, |
| 226 arguments = { |
| 227 @Parameter.Argument(name = "input", intVar =
1), |
| 228 @Parameter.Argument(name = "output", intVar
= 0)})}), |
| 229 @ParameterizedTest(parameters = { |
| 230 @Parameter( |
| 231 tag = MethodParameter.PARAMETER_TAG, |
| 232 arguments = { |
| 233 @Parameter.Argument(name = "input", intVar =
2), |
| 234 @Parameter.Argument(name = "output", intVar
= 1)})}), |
| 235 @ParameterizedTest(parameters = { |
| 236 @Parameter( |
| 237 tag = MethodParameter.PARAMETER_TAG, |
| 238 arguments = { |
| 239 @Parameter.Argument(name = "input", intVar =
3), |
| 240 @Parameter.Argument(name = "output", intVar
= 1)})}), |
| 241 @ParameterizedTest(parameters = { |
| 242 @Parameter( |
| 243 tag = MethodParameter.PARAMETER_TAG, |
| 244 arguments = { |
| 245 @Parameter.Argument(name = "input", intVar =
4), |
| 246 @Parameter.Argument(name = "output", intVar
= 2)})}), |
| 247 @ParameterizedTest(parameters = { |
| 248 @Parameter( |
| 249 tag = MethodParameter.PARAMETER_TAG, |
| 250 arguments = { |
| 251 @Parameter.Argument(name = "input", intVar =
5), |
| 252 @Parameter.Argument(name = "output", intVar
= 3)})}), |
| 253 @ParameterizedTest(parameters = { |
| 254 @Parameter( |
| 255 tag = MethodParameter.PARAMETER_TAG, |
| 256 arguments = { |
| 257 @Parameter.Argument(name = "input", intVar =
6), |
| 258 @Parameter.Argument(name = "output", intVar
= 5)})}), |
| 259 @ParameterizedTest(parameters = { |
| 260 @Parameter( |
| 261 tag = MethodParameter.PARAMETER_TAG, |
| 262 arguments = { |
| 263 @Parameter.Argument(name = "input", intVar =
7), |
| 264 @Parameter.Argument(name = "output", intVar
= 8)})}), |
| 265 @ParameterizedTest(parameters = { |
| 266 @Parameter( |
| 267 tag = MethodParameter.PARAMETER_TAG, |
| 268 arguments = { |
| 269 @Parameter.Argument(name = "input", intVar =
8), |
| 270 @Parameter.Argument(name = "output", intVar
= 13)})}), |
| 271 @ParameterizedTest(parameters = { |
| 272 @Parameter( |
| 273 tag = MethodParameter.PARAMETER_TAG, |
| 274 arguments = { |
| 275 @Parameter.Argument(name = "input", intVar =
9), |
| 276 @Parameter.Argument(name = "output", intVar
= 21)})}), |
| 277 @ParameterizedTest(parameters = { |
| 278 @Parameter( |
| 279 tag = MethodParameter.PARAMETER_TAG, |
| 280 arguments = { |
| 281 @Parameter.Argument(name = "input", intVar =
10), |
| 282 @Parameter.Argument(name = "output", intVar
= 34)})})}) |
| 283 public void testParameterArgumentsWithParameterSetOfMoreThanOneTest() { |
| 284 int input = getArgument("input").intVar(); |
| 285 int expected = getArgument("output").intVar(); |
| 286 int actual = fib(input); |
| 287 assertEquals("Output should be the fibonacci number at index input.", ex
pected, actual); |
| 288 } |
| 289 |
| 290 /** |
| 291 * This is better than the implementation of |
| 292 * testParameterArgumentsWithParameterSetOfMoreThanOneTest. It reduces the n
umber of |
| 293 * {@link ParameterizedTest} annotations by using an intArray instead of an
intVar. |
| 294 * Computationally, this will be faster too because it only has to set up th
e parameters once |
| 295 * for the single ParameterizedTest. |
| 296 * |
| 297 * Continued @ testSingleTestParameterArgumentsWithParameterSet |
| 298 */ |
| 299 @SmallTest |
| 300 @ParameterizedTest.Set(tests = { |
| 301 @ParameterizedTest(parameters = { |
| 302 @Parameter( |
| 303 tag = MethodParameter.PARAMETER_TAG, |
| 304 arguments = { |
| 305 @Parameter.Argument(name = "input", |
| 306 intArray = {1, 2, 3, 4, 5, 6, 7, 8,
9, 10}), |
| 307 @Parameter.Argument(name = "expected", |
| 308 intArray = {0, 1, 1, 2, 3, 5, 8, 13,
21, 34})})})}) |
| 309 public void testSingleTestParameterArgumentsWithParameterSet() { |
| 310 int[] input = getArgument("input").intArray(); |
| 311 int[] expected = getArgument("expected").intArray(); |
| 312 int[] actual = new int[input.length]; |
| 313 for (int i = 0; i < input.length; i++) { |
| 314 actual[i] = fib(input[i]); |
| 315 } |
| 316 MoreAsserts.assertEquals("Output should be the fibonacci number at each
index input.", |
| 317 expected, actual); |
| 318 } |
| 319 |
| 320 /** |
| 321 * This is the best implementation to test fibonacci. |
| 322 * |
| 323 * It's computationally the same speed at testSingleTestParameterArgumentsWi
thParameterSet. But |
| 324 * we don't need to actually have a ParameterizedTestSet. |
| 325 */ |
| 326 @SmallTest |
| 327 @ParameterizedTest(parameters = { |
| 328 @Parameter( |
| 329 tag = MethodParameter.PARAMETER_TAG, |
| 330 arguments = { |
| 331 @Parameter.Argument(name = "input", |
| 332 intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}), |
| 333 @Parameter.Argument(name = "expected", |
| 334 intArray = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34}
)})}) |
| 335 public void testSingleTestParameterArgumentsWithoutParameterSet() { |
| 336 int[] input = getArgument("input").intArray(); |
| 337 int[] expected = getArgument("expected").intArray(); |
| 338 int[] actual = new int[input.length]; |
| 339 for (int i = 0; i < input.length; i++) { |
| 340 actual[i] = fib(input[i]); |
| 341 } |
| 342 MoreAsserts.assertEquals("Output should be the fibonacci number at each
index input.", |
| 343 expected, actual); |
| 344 } |
| 345 |
| 346 private static String mismatchMessage(String name) { |
| 347 return String.format("The ParameterArgument %s does not match expected v
alue.", name); |
| 348 } |
| 349 |
| 350 private static int fib(int input) { |
| 351 if (input <= 0) { |
| 352 throw new IllegalArgumentException("Input must be greater than 0."); |
| 353 } |
| 354 if (input == 1) { |
| 355 return 0; |
| 356 } |
| 357 if (input == 2) { |
| 358 return 1; |
| 359 } |
| 360 int[] temp = new int[input]; |
| 361 temp[0] = 0; |
| 362 temp[1] = 1; |
| 363 for (int i = 2; i < input; i++) { |
| 364 temp[i] = temp[i - 1] + temp[i - 2]; |
| 365 } |
| 366 return temp[input - 1]; |
| 367 } |
| 368 |
| 369 private Parameter.Argument getArgument(String name) { |
| 370 return getParameterReader().getParameterArgument(MethodParameter.PARAMET
ER_TAG, name); |
| 371 } |
| 372 } |
OLD | NEW |