1 /* 2 * Copyright (C) 2012 The Guava Authors 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 package com.google.common.testing; 18 19 import com.google.common.base.CharMatcher; 20 import com.google.common.base.Equivalence; 21 import com.google.common.base.Function; 22 import com.google.common.base.Joiner; 23 import com.google.common.base.Predicate; 24 import com.google.common.base.Splitter; 25 import com.google.common.base.Ticker; 26 import com.google.common.collect.ArrayListMultimap; 27 import com.google.common.collect.BiMap; 28 import com.google.common.collect.HashBasedTable; 29 import com.google.common.collect.HashBiMap; 30 import com.google.common.collect.HashMultimap; 31 import com.google.common.collect.HashMultiset; 32 import com.google.common.collect.ImmutableBiMap; 33 import com.google.common.collect.ImmutableCollection; 34 import com.google.common.collect.ImmutableList; 35 import com.google.common.collect.ImmutableListMultimap; 36 import com.google.common.collect.ImmutableMap; 37 import com.google.common.collect.ImmutableMultimap; 38 import com.google.common.collect.ImmutableMultiset; 39 import com.google.common.collect.ImmutableSet; 40 import com.google.common.collect.ImmutableSetMultimap; 41 import com.google.common.collect.ImmutableSortedMap; 42 import com.google.common.collect.ImmutableSortedMultiset; 43 import com.google.common.collect.ImmutableSortedSet; 44 import com.google.common.collect.ImmutableTable; 45 import com.google.common.collect.LinkedHashMultimap; 46 import com.google.common.collect.LinkedHashMultiset; 47 import com.google.common.collect.ListMultimap; 48 import com.google.common.collect.Maps; 49 import com.google.common.collect.Multimap; 50 import com.google.common.collect.Multiset; 51 import com.google.common.collect.Ordering; 52 import com.google.common.collect.Range; 53 import com.google.common.collect.RowSortedTable; 54 import com.google.common.collect.SetMultimap; 55 import com.google.common.collect.SortedMultiset; 56 import com.google.common.collect.Table; 57 import com.google.common.collect.TreeBasedTable; 58 import com.google.common.collect.TreeMultiset; 59 import com.google.common.primitives.UnsignedInteger; 60 import com.google.common.primitives.UnsignedLong; 61 import com.google.common.reflect.TypeToken; 62 import java.io.ByteArrayInputStream; 63 import java.io.ByteArrayOutputStream; 64 import java.io.File; 65 import java.io.InputStream; 66 import java.io.OutputStream; 67 import java.io.Reader; 68 import java.io.StringReader; 69 import java.io.StringWriter; 70 import java.io.Writer; 71 import java.lang.reflect.Method; 72 import java.lang.reflect.Type; 73 import java.math.BigDecimal; 74 import java.math.BigInteger; 75 import java.nio.Buffer; 76 import java.nio.ByteBuffer; 77 import java.nio.CharBuffer; 78 import java.nio.DoubleBuffer; 79 import java.nio.FloatBuffer; 80 import java.nio.IntBuffer; 81 import java.nio.LongBuffer; 82 import java.nio.ShortBuffer; 83 import java.nio.charset.Charset; 84 import java.util.ArrayList; 85 import java.util.Collection; 86 import java.util.Comparator; 87 import java.util.Currency; 88 import java.util.HashMap; 89 import java.util.HashSet; 90 import java.util.LinkedHashMap; 91 import java.util.LinkedHashSet; 92 import java.util.LinkedList; 93 import java.util.List; 94 import java.util.Locale; 95 import java.util.Map; 96 import java.util.Map.Entry; 97 import java.util.NavigableMap; 98 import java.util.NavigableSet; 99 import java.util.Optional; 100 import java.util.OptionalDouble; 101 import java.util.OptionalInt; 102 import java.util.OptionalLong; 103 import java.util.Set; 104 import java.util.SortedMap; 105 import java.util.SortedSet; 106 import java.util.TreeMap; 107 import java.util.TreeSet; 108 import java.util.concurrent.ConcurrentMap; 109 import java.util.concurrent.TimeUnit; 110 import java.util.regex.MatchResult; 111 import java.util.regex.Pattern; 112 import junit.framework.TestCase; 113 114 /** 115 * Tests for {@link FreshValueGenerator}. 116 * 117 * @author Ben Yu 118 */ 119 public class FreshValueGeneratorTest extends TestCase { 120 121 @AndroidIncompatible // problem with equality of Type objects? testFreshInstance()122 public void testFreshInstance() { 123 assertFreshInstances( 124 String.class, 125 CharSequence.class, 126 Appendable.class, 127 StringBuffer.class, 128 StringBuilder.class, 129 Pattern.class, 130 MatchResult.class, 131 Number.class, 132 int.class, 133 Integer.class, 134 long.class, 135 Long.class, 136 short.class, 137 Short.class, 138 byte.class, 139 Byte.class, 140 boolean.class, 141 Boolean.class, 142 char.class, 143 Character.class, 144 int[].class, 145 Object[].class, 146 UnsignedInteger.class, 147 UnsignedLong.class, 148 BigInteger.class, 149 BigDecimal.class, 150 Throwable.class, 151 Error.class, 152 Exception.class, 153 RuntimeException.class, 154 Charset.class, 155 Locale.class, 156 Currency.class, 157 List.class, 158 Entry.class, 159 Object.class, 160 Equivalence.class, 161 Predicate.class, 162 Function.class, 163 Comparable.class, 164 Comparator.class, 165 Ordering.class, 166 Class.class, 167 Type.class, 168 TypeToken.class, 169 TimeUnit.class, 170 Ticker.class, 171 Joiner.class, 172 Splitter.class, 173 CharMatcher.class, 174 InputStream.class, 175 ByteArrayInputStream.class, 176 Reader.class, 177 Readable.class, 178 StringReader.class, 179 OutputStream.class, 180 ByteArrayOutputStream.class, 181 Writer.class, 182 StringWriter.class, 183 File.class, 184 Buffer.class, 185 ByteBuffer.class, 186 CharBuffer.class, 187 ShortBuffer.class, 188 IntBuffer.class, 189 LongBuffer.class, 190 FloatBuffer.class, 191 DoubleBuffer.class, 192 String[].class, 193 Object[].class, 194 int[].class); 195 } 196 testStringArray()197 public void testStringArray() { 198 FreshValueGenerator generator = new FreshValueGenerator(); 199 String[] a1 = generator.generateFresh(String[].class); 200 String[] a2 = generator.generateFresh(String[].class); 201 assertFalse(a1[0].equals(a2[0])); 202 } 203 testPrimitiveArray()204 public void testPrimitiveArray() { 205 FreshValueGenerator generator = new FreshValueGenerator(); 206 int[] a1 = generator.generateFresh(int[].class); 207 int[] a2 = generator.generateFresh(int[].class); 208 assertTrue(a1[0] != a2[0]); 209 } 210 testRange()211 public void testRange() { 212 assertFreshInstance(new TypeToken<Range<String>>() {}); 213 } 214 testImmutableList()215 public void testImmutableList() { 216 assertFreshInstance(new TypeToken<ImmutableList<String>>() {}); 217 } 218 testImmutableSet()219 public void testImmutableSet() { 220 assertFreshInstance(new TypeToken<ImmutableSet<String>>() {}); 221 } 222 testImmutableSortedSet()223 public void testImmutableSortedSet() { 224 assertFreshInstance(new TypeToken<ImmutableSortedSet<String>>() {}); 225 } 226 testImmutableMultiset()227 public void testImmutableMultiset() { 228 assertFreshInstance(new TypeToken<ImmutableSortedSet<String>>() {}); 229 assertNotInstantiable(new TypeToken<ImmutableMultiset<EmptyEnum>>() {}); 230 } 231 testImmutableCollection()232 public void testImmutableCollection() { 233 assertFreshInstance(new TypeToken<ImmutableCollection<String>>() {}); 234 assertNotInstantiable(new TypeToken<ImmutableCollection<EmptyEnum>>() {}); 235 } 236 testImmutableMap()237 public void testImmutableMap() { 238 assertFreshInstance(new TypeToken<ImmutableMap<String, Integer>>() {}); 239 } 240 testImmutableSortedMap()241 public void testImmutableSortedMap() { 242 assertFreshInstance(new TypeToken<ImmutableSortedMap<String, Integer>>() {}); 243 } 244 testImmutableMultimap()245 public void testImmutableMultimap() { 246 assertFreshInstance(new TypeToken<ImmutableMultimap<String, Integer>>() {}); 247 assertNotInstantiable(new TypeToken<ImmutableMultimap<EmptyEnum, String>>() {}); 248 } 249 testImmutableListMultimap()250 public void testImmutableListMultimap() { 251 assertFreshInstance(new TypeToken<ImmutableListMultimap<String, Integer>>() {}); 252 } 253 testImmutableSetMultimap()254 public void testImmutableSetMultimap() { 255 assertFreshInstance(new TypeToken<ImmutableSetMultimap<String, Integer>>() {}); 256 } 257 testImmutableBiMap()258 public void testImmutableBiMap() { 259 assertFreshInstance(new TypeToken<ImmutableBiMap<String, Integer>>() {}); 260 } 261 testImmutableTable()262 public void testImmutableTable() { 263 assertFreshInstance(new TypeToken<ImmutableTable<String, Integer, ImmutableList<String>>>() {}); 264 } 265 testList()266 public void testList() { 267 assertFreshInstance(new TypeToken<List<String>>() {}); 268 assertNotInstantiable(new TypeToken<List<EmptyEnum>>() {}); 269 } 270 testArrayList()271 public void testArrayList() { 272 assertFreshInstance(new TypeToken<ArrayList<String>>() {}); 273 assertNotInstantiable(new TypeToken<ArrayList<EmptyEnum>>() {}); 274 } 275 testLinkedList()276 public void testLinkedList() { 277 assertFreshInstance(new TypeToken<LinkedList<String>>() {}); 278 } 279 testSet()280 public void testSet() { 281 assertFreshInstance(new TypeToken<Set<String>>() {}); 282 assertNotInstantiable(new TypeToken<Set<EmptyEnum>>() {}); 283 } 284 testHashSet()285 public void testHashSet() { 286 assertFreshInstance(new TypeToken<HashSet<String>>() {}); 287 } 288 testLinkedHashSet()289 public void testLinkedHashSet() { 290 assertFreshInstance(new TypeToken<LinkedHashSet<String>>() {}); 291 } 292 testTreeSet()293 public void testTreeSet() { 294 assertFreshInstance(new TypeToken<TreeSet<String>>() {}); 295 } 296 testSortedSet()297 public void testSortedSet() { 298 assertFreshInstance(new TypeToken<SortedSet<String>>() {}); 299 } 300 testNavigableSet()301 public void testNavigableSet() { 302 assertFreshInstance(new TypeToken<NavigableSet<String>>() {}); 303 } 304 testMultiset()305 public void testMultiset() { 306 assertFreshInstance(new TypeToken<Multiset<String>>() {}); 307 } 308 testSortedMultiset()309 public void testSortedMultiset() { 310 assertFreshInstance(new TypeToken<SortedMultiset<String>>() {}); 311 } 312 testHashMultiset()313 public void testHashMultiset() { 314 assertFreshInstance(new TypeToken<HashMultiset<String>>() {}); 315 } 316 testLinkedHashMultiset()317 public void testLinkedHashMultiset() { 318 assertFreshInstance(new TypeToken<LinkedHashMultiset<String>>() {}); 319 } 320 testTreeMultiset()321 public void testTreeMultiset() { 322 assertFreshInstance(new TypeToken<TreeMultiset<String>>() {}); 323 } 324 testImmutableSortedMultiset()325 public void testImmutableSortedMultiset() { 326 assertFreshInstance(new TypeToken<ImmutableSortedMultiset<String>>() {}); 327 } 328 testCollection()329 public void testCollection() { 330 assertFreshInstance(new TypeToken<Collection<String>>() {}); 331 } 332 testIterable()333 public void testIterable() { 334 assertFreshInstance(new TypeToken<Iterable<String>>() {}); 335 } 336 testMap()337 public void testMap() { 338 assertFreshInstance(new TypeToken<Map<String, ?>>() {}); 339 } 340 testHashMap()341 public void testHashMap() { 342 assertFreshInstance(new TypeToken<HashMap<String, ?>>() {}); 343 } 344 testLinkedHashMap()345 public void testLinkedHashMap() { 346 assertFreshInstance(new TypeToken<LinkedHashMap<String, ?>>() {}); 347 } 348 testTreeMap()349 public void testTreeMap() { 350 assertFreshInstance(new TypeToken<TreeMap<String, ?>>() {}); 351 } 352 testSortedMap()353 public void testSortedMap() { 354 assertFreshInstance(new TypeToken<SortedMap<?, String>>() {}); 355 } 356 testNavigableMap()357 public void testNavigableMap() { 358 assertFreshInstance(new TypeToken<NavigableMap<?, ?>>() {}); 359 } 360 testConcurrentMap()361 public void testConcurrentMap() { 362 assertFreshInstance(new TypeToken<ConcurrentMap<String, ?>>() {}); 363 assertCanGenerateOnly( 364 new TypeToken<ConcurrentMap<EmptyEnum, String>>() {}, Maps.newConcurrentMap()); 365 } 366 testMultimap()367 public void testMultimap() { 368 assertFreshInstance(new TypeToken<Multimap<String, ?>>() {}); 369 } 370 testHashMultimap()371 public void testHashMultimap() { 372 assertFreshInstance(new TypeToken<HashMultimap<String, ?>>() {}); 373 } 374 testLinkedHashMultimap()375 public void testLinkedHashMultimap() { 376 assertFreshInstance(new TypeToken<LinkedHashMultimap<String, ?>>() {}); 377 } 378 testListMultimap()379 public void testListMultimap() { 380 assertFreshInstance(new TypeToken<ListMultimap<String, ?>>() {}); 381 } 382 testArrayListMultimap()383 public void testArrayListMultimap() { 384 assertFreshInstance(new TypeToken<ArrayListMultimap<String, ?>>() {}); 385 } 386 testSetMultimap()387 public void testSetMultimap() { 388 assertFreshInstance(new TypeToken<SetMultimap<String, ?>>() {}); 389 } 390 testBiMap()391 public void testBiMap() { 392 assertFreshInstance(new TypeToken<BiMap<String, ?>>() {}); 393 assertNotInstantiable(new TypeToken<BiMap<EmptyEnum, String>>() {}); 394 } 395 testHashBiMap()396 public void testHashBiMap() { 397 assertFreshInstance(new TypeToken<HashBiMap<String, ?>>() {}); 398 } 399 testTable()400 public void testTable() { 401 assertFreshInstance(new TypeToken<Table<String, ?, ?>>() {}); 402 assertNotInstantiable(new TypeToken<Table<EmptyEnum, String, Integer>>() {}); 403 } 404 testHashBasedTable()405 public void testHashBasedTable() { 406 assertFreshInstance(new TypeToken<HashBasedTable<String, ?, ?>>() {}); 407 } 408 testRowSortedTable()409 public void testRowSortedTable() { 410 assertFreshInstance(new TypeToken<RowSortedTable<String, ?, ?>>() {}); 411 } 412 testTreeBasedTable()413 public void testTreeBasedTable() { 414 assertFreshInstance(new TypeToken<TreeBasedTable<String, ?, ?>>() {}); 415 } 416 testObject()417 public void testObject() { 418 assertEquals( 419 new FreshValueGenerator().generateFresh(String.class), 420 new FreshValueGenerator().generateFresh(Object.class)); 421 } 422 testEnums()423 public void testEnums() { 424 assertEqualInstance(EmptyEnum.class, null); 425 assertEqualInstance(OneConstantEnum.class, OneConstantEnum.CONSTANT1); 426 assertFreshInstance(TwoConstantEnum.class, 2); 427 assertFreshInstance(new TypeToken<com.google.common.base.Optional<OneConstantEnum>>() {}, 2); 428 assertFreshInstance(new TypeToken<List<OneConstantEnum>>() {}, 1); 429 assertFreshInstance(new TypeToken<List<TwoConstantEnum>>() {}, 2); 430 } 431 432 @AndroidIncompatible // problem with equality of Type objects? testGoogleOptional()433 public void testGoogleOptional() { 434 FreshValueGenerator generator = new FreshValueGenerator(); 435 assertEquals( 436 com.google.common.base.Optional.absent(), 437 generator.generateFresh(new TypeToken<com.google.common.base.Optional<String>>() {})); 438 assertEquals( 439 com.google.common.base.Optional.of("2"), 440 generator.generateFresh(new TypeToken<com.google.common.base.Optional<String>>() {})); 441 // Test that the first generated instance for different cgcb.Optional<T> is always absent(). 442 // Having generated cgcb.Optional<String> instances doesn't prevent absent() from being 443 // generated for other cgcb.Optional types. 444 assertEquals( 445 com.google.common.base.Optional.absent(), 446 generator.generateFresh( 447 new TypeToken<com.google.common.base.Optional<OneConstantEnum>>() {})); 448 assertEquals( 449 com.google.common.base.Optional.of(OneConstantEnum.CONSTANT1), 450 generator.generateFresh( 451 new TypeToken<com.google.common.base.Optional<OneConstantEnum>>() {})); 452 } 453 454 @AndroidIncompatible testJavaOptional()455 public void testJavaOptional() { 456 FreshValueGenerator generator = new FreshValueGenerator(); 457 assertEquals(Optional.empty(), generator.generateFresh(new TypeToken<Optional<String>>() {})); 458 assertEquals(Optional.of("2"), generator.generateFresh(new TypeToken<Optional<String>>() {})); 459 // Test that the first generated instance for different Optional<T> is always empty(). Having 460 // generated Optional<String> instances doesn't prevent empty() from being generated for other 461 // Optional types. 462 assertEquals( 463 Optional.empty(), generator.generateFresh(new TypeToken<Optional<OneConstantEnum>>() {})); 464 assertEquals( 465 Optional.of(OneConstantEnum.CONSTANT1), 466 generator.generateFresh(new TypeToken<Optional<OneConstantEnum>>() {})); 467 } 468 testOptionalInt()469 public void testOptionalInt() { 470 assertFreshInstance(new TypeToken<OptionalInt>() {}); 471 } 472 testOptionalLong()473 public void testOptionalLong() { 474 assertFreshInstance(new TypeToken<OptionalLong>() {}); 475 } 476 testOptionalDouble()477 public void testOptionalDouble() { 478 assertFreshInstance(new TypeToken<OptionalDouble>() {}); 479 } 480 testAddSampleInstances_twoInstances()481 public void testAddSampleInstances_twoInstances() { 482 FreshValueGenerator generator = new FreshValueGenerator(); 483 generator.addSampleInstances(String.class, ImmutableList.of("a", "b")); 484 assertEquals("a", generator.generateFresh(String.class)); 485 assertEquals("b", generator.generateFresh(String.class)); 486 assertEquals("a", generator.generateFresh(String.class)); 487 } 488 testAddSampleInstances_oneInstance()489 public void testAddSampleInstances_oneInstance() { 490 FreshValueGenerator generator = new FreshValueGenerator(); 491 generator.addSampleInstances(String.class, ImmutableList.of("a")); 492 assertEquals("a", generator.generateFresh(String.class)); 493 assertEquals("a", generator.generateFresh(String.class)); 494 } 495 testAddSampleInstances_noInstance()496 public void testAddSampleInstances_noInstance() { 497 FreshValueGenerator generator = new FreshValueGenerator(); 498 generator.addSampleInstances(String.class, ImmutableList.<String>of()); 499 assertEquals( 500 new FreshValueGenerator().generateFresh(String.class), 501 generator.generateFresh(String.class)); 502 } 503 testFreshCurrency()504 public void testFreshCurrency() { 505 FreshValueGenerator generator = new FreshValueGenerator(); 506 // repeat a few times to make sure we don't stumble upon a bad Locale 507 assertNotNull(generator.generateFresh(Currency.class)); 508 assertNotNull(generator.generateFresh(Currency.class)); 509 assertNotNull(generator.generateFresh(Currency.class)); 510 } 511 testNulls()512 public void testNulls() throws Exception { 513 new ClassSanityTester() 514 .setDefault(Method.class, FreshValueGeneratorTest.class.getDeclaredMethod("testNulls")) 515 .testNulls(FreshValueGenerator.class); 516 } 517 assertFreshInstances(Class<?>.... types)518 private static void assertFreshInstances(Class<?>... types) { 519 for (Class<?> type : types) { 520 assertFreshInstance(type, 2); 521 } 522 } 523 assertFreshInstance(TypeToken<?> type)524 private static void assertFreshInstance(TypeToken<?> type) { 525 assertFreshInstance(type, 3); 526 } 527 assertFreshInstance(Class<?> type, int instances)528 private static void assertFreshInstance(Class<?> type, int instances) { 529 assertFreshInstance(TypeToken.of(type), instances); 530 } 531 assertFreshInstance(TypeToken<?> type, int instances)532 private static void assertFreshInstance(TypeToken<?> type, int instances) { 533 FreshValueGenerator generator = new FreshValueGenerator(); 534 EqualsTester tester = new EqualsTester(); 535 for (int i = 0; i < instances; i++) { 536 tester.addEqualityGroup(generator.generateFresh(type)); 537 } 538 tester.testEquals(); 539 } 540 assertEqualInstance(Class<T> type, T value)541 private static <T> void assertEqualInstance(Class<T> type, T value) { 542 FreshValueGenerator generator = new FreshValueGenerator(); 543 assertEquals(value, generator.generateFresh(type)); 544 assertEquals(value, generator.generateFresh(type)); 545 } 546 547 private enum EmptyEnum {} 548 549 private enum OneConstantEnum { 550 CONSTANT1 551 } 552 553 private enum TwoConstantEnum { 554 CONSTANT1, 555 CONSTANT2 556 } 557 assertCanGenerateOnly(TypeToken<?> type, Object expected)558 private static void assertCanGenerateOnly(TypeToken<?> type, Object expected) { 559 FreshValueGenerator generator = new FreshValueGenerator(); 560 assertValueAndTypeEquals(expected, generator.generateFresh(type)); 561 assertNull(generator.generateFresh(type)); 562 } 563 assertNotInstantiable(TypeToken<?> type)564 private static void assertNotInstantiable(TypeToken<?> type) { 565 assertNull(new FreshValueGenerator().generateFresh(type)); 566 } 567 assertValueAndTypeEquals(Object expected, Object actual)568 private static void assertValueAndTypeEquals(Object expected, Object actual) { 569 assertEquals(expected, actual); 570 assertEquals(expected.getClass(), actual.getClass()); 571 } 572 } 573