Java

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

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

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

211
  public void testRange() {
212
    assertFreshInstance(new TypeToken<Range<String>>() {});
213
  }
214

215
  public void testImmutableList() {
216
    assertFreshInstance(new TypeToken<ImmutableList<String>>() {});
217
  }
218

219
  public void testImmutableSet() {
220
    assertFreshInstance(new TypeToken<ImmutableSet<String>>() {});
221
  }
222

223
  public void testImmutableSortedSet() {
224
    assertFreshInstance(new TypeToken<ImmutableSortedSet<String>>() {});
225
  }
226

227
  public void testImmutableMultiset() {
228
    assertFreshInstance(new TypeToken<ImmutableSortedSet<String>>() {});
229
    assertNotInstantiable(new TypeToken<ImmutableMultiset<EmptyEnum>>() {});
230
  }
231

232
  public void testImmutableCollection() {
233
    assertFreshInstance(new TypeToken<ImmutableCollection<String>>() {});
234
    assertNotInstantiable(new TypeToken<ImmutableCollection<EmptyEnum>>() {});
235
  }
236

237
  public void testImmutableMap() {
238
    assertFreshInstance(new TypeToken<ImmutableMap<String, Integer>>() {});
239
  }
240

241
  public void testImmutableSortedMap() {
242
    assertFreshInstance(new TypeToken<ImmutableSortedMap<String, Integer>>() {});
243
  }
244

245
  public void testImmutableMultimap() {
246
    assertFreshInstance(new TypeToken<ImmutableMultimap<String, Integer>>() {});
247
    assertNotInstantiable(new TypeToken<ImmutableMultimap<EmptyEnum, String>>() {});
248
  }
249

250
  public void testImmutableListMultimap() {
251
    assertFreshInstance(new TypeToken<ImmutableListMultimap<String, Integer>>() {});
252
  }
253

254
  public void testImmutableSetMultimap() {
255
    assertFreshInstance(new TypeToken<ImmutableSetMultimap<String, Integer>>() {});
256
  }
257

258
  public void testImmutableBiMap() {
259
    assertFreshInstance(new TypeToken<ImmutableBiMap<String, Integer>>() {});
260
  }
261

262
  public void testImmutableTable() {
263
    assertFreshInstance(new TypeToken<ImmutableTable<String, Integer, ImmutableList<String>>>() {});
264
  }
265

266
  public void testList() {
267
    assertFreshInstance(new TypeToken<List<String>>() {});
268
    assertNotInstantiable(new TypeToken<List<EmptyEnum>>() {});
269
  }
270

271
  public void testArrayList() {
272
    assertFreshInstance(new TypeToken<ArrayList<String>>() {});
273
    assertNotInstantiable(new TypeToken<ArrayList<EmptyEnum>>() {});
274
  }
275

276
  public void testLinkedList() {
277
    assertFreshInstance(new TypeToken<LinkedList<String>>() {});
278
  }
279

280
  public void testSet() {
281
    assertFreshInstance(new TypeToken<Set<String>>() {});
282
    assertNotInstantiable(new TypeToken<Set<EmptyEnum>>() {});
283
  }
284

285
  public void testHashSet() {
286
    assertFreshInstance(new TypeToken<HashSet<String>>() {});
287
  }
288

289
  public void testLinkedHashSet() {
290
    assertFreshInstance(new TypeToken<LinkedHashSet<String>>() {});
291
  }
292

293
  public void testTreeSet() {
294
    assertFreshInstance(new TypeToken<TreeSet<String>>() {});
295
  }
296

297
  public void testSortedSet() {
298
    assertFreshInstance(new TypeToken<SortedSet<String>>() {});
299
  }
300

301
  public void testNavigableSet() {
302
    assertFreshInstance(new TypeToken<NavigableSet<String>>() {});
303
  }
304

305
  public void testMultiset() {
306
    assertFreshInstance(new TypeToken<Multiset<String>>() {});
307
  }
308

309
  public void testSortedMultiset() {
310
    assertFreshInstance(new TypeToken<SortedMultiset<String>>() {});
311
  }
312

313
  public void testHashMultiset() {
314
    assertFreshInstance(new TypeToken<HashMultiset<String>>() {});
315
  }
316

317
  public void testLinkedHashMultiset() {
318
    assertFreshInstance(new TypeToken<LinkedHashMultiset<String>>() {});
319
  }
320

321
  public void testTreeMultiset() {
322
    assertFreshInstance(new TypeToken<TreeMultiset<String>>() {});
323
  }
324

325
  public void testImmutableSortedMultiset() {
326
    assertFreshInstance(new TypeToken<ImmutableSortedMultiset<String>>() {});
327
  }
328

329
  public void testCollection() {
330
    assertFreshInstance(new TypeToken<Collection<String>>() {});
331
  }
332

333
  public void testIterable() {
334
    assertFreshInstance(new TypeToken<Iterable<String>>() {});
335
  }
336

337
  public void testMap() {
338
    assertFreshInstance(new TypeToken<Map<String, ?>>() {});
339
  }
340

341
  public void testHashMap() {
342
    assertFreshInstance(new TypeToken<HashMap<String, ?>>() {});
343
  }
344

345
  public void testLinkedHashMap() {
346
    assertFreshInstance(new TypeToken<LinkedHashMap<String, ?>>() {});
347
  }
348

349
  public void testTreeMap() {
350
    assertFreshInstance(new TypeToken<TreeMap<String, ?>>() {});
351
  }
352

353
  public void testSortedMap() {
354
    assertFreshInstance(new TypeToken<SortedMap<?, String>>() {});
355
  }
356

357
  public void testNavigableMap() {
358
    assertFreshInstance(new TypeToken<NavigableMap<?, ?>>() {});
359
  }
360

361
  public void testConcurrentMap() {
362
    assertFreshInstance(new TypeToken<ConcurrentMap<String, ?>>() {});
363
    assertCanGenerateOnly(
364
        new TypeToken<ConcurrentMap<EmptyEnum, String>>() {}, Maps.newConcurrentMap());
365
  }
366

367
  public void testMultimap() {
368
    assertFreshInstance(new TypeToken<Multimap<String, ?>>() {});
369
  }
370

371
  public void testHashMultimap() {
372
    assertFreshInstance(new TypeToken<HashMultimap<String, ?>>() {});
373
  }
374

375
  public void testLinkedHashMultimap() {
376
    assertFreshInstance(new TypeToken<LinkedHashMultimap<String, ?>>() {});
377
  }
378

379
  public void testListMultimap() {
380
    assertFreshInstance(new TypeToken<ListMultimap<String, ?>>() {});
381
  }
382

383
  public void testArrayListMultimap() {
384
    assertFreshInstance(new TypeToken<ArrayListMultimap<String, ?>>() {});
385
  }
386

387
  public void testSetMultimap() {
388
    assertFreshInstance(new TypeToken<SetMultimap<String, ?>>() {});
389
  }
390

391
  public void testBiMap() {
392
    assertFreshInstance(new TypeToken<BiMap<String, ?>>() {});
393
    assertNotInstantiable(new TypeToken<BiMap<EmptyEnum, String>>() {});
394
  }
395

396
  public void testHashBiMap() {
397
    assertFreshInstance(new TypeToken<HashBiMap<String, ?>>() {});
398
  }
399

400
  public void testTable() {
401
    assertFreshInstance(new TypeToken<Table<String, ?, ?>>() {});
402
    assertNotInstantiable(new TypeToken<Table<EmptyEnum, String, Integer>>() {});
403
  }
404

405
  public void testHashBasedTable() {
406
    assertFreshInstance(new TypeToken<HashBasedTable<String, ?, ?>>() {});
407
  }
408

409
  public void testRowSortedTable() {
410
    assertFreshInstance(new TypeToken<RowSortedTable<String, ?, ?>>() {});
411
  }
412

413
  public void testTreeBasedTable() {
414
    assertFreshInstance(new TypeToken<TreeBasedTable<String, ?, ?>>() {});
415
  }
416

417
  public void testObject() {
418
    assertEquals(
419
        new FreshValueGenerator().generateFresh(String.class),
420
        new FreshValueGenerator().generateFresh(Object.class));
421
  }
422

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

469
  public void testOptionalInt() {
470
    assertFreshInstance(new TypeToken<OptionalInt>() {});
471
  }
472

473
  public void testOptionalLong() {
474
    assertFreshInstance(new TypeToken<OptionalLong>() {});
475
  }
476

477
  public void testOptionalDouble() {
478
    assertFreshInstance(new TypeToken<OptionalDouble>() {});
479
  }
480

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

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

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

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

512
  public void testNulls() throws Exception {
513
    new ClassSanityTester()
514
        .setDefault(Method.class, FreshValueGeneratorTest.class.getDeclaredMethod("testNulls"))
515
        .testNulls(FreshValueGenerator.class);
516
  }
517

518
  private static void assertFreshInstances(Class<?>... types) {
519
    for (Class<?> type : types) {
520
      assertFreshInstance(type, 2);
521
    }
522
  }
523

524
  private static void assertFreshInstance(TypeToken<?> type) {
525
    assertFreshInstance(type, 3);
526
  }
527

528
  private static void assertFreshInstance(Class<?> type, int instances) {
529
    assertFreshInstance(TypeToken.of(type), instances);
530
  }
531

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

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

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

564
  private static void assertNotInstantiable(TypeToken<?> type) {
565
    assertNull(new FreshValueGenerator().generateFresh(type));
566
  }
567

568
  private static void assertValueAndTypeEquals(Object expected, Object actual) {
569
    assertEquals(expected, actual);
570
    assertEquals(expected.getClass(), actual.getClass());
571
  }
572
}
573