Java

ArbitraryInstancesTest.java
528 строк · 22.2 Кб
Перенос по словам
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 static com.google.common.truth.Truth.assertThat;
20
import static java.nio.charset.StandardCharsets.UTF_8;
21
import static org.junit.Assert.assertThrows;
22

23
import com.google.common.base.CharMatcher;
24
import com.google.common.base.Equivalence;
25
import com.google.common.base.Joiner;
26
import com.google.common.base.Predicate;
27
import com.google.common.base.Splitter;
28
import com.google.common.base.Stopwatch;
29
import com.google.common.base.Ticker;
30
import com.google.common.collect.BiMap;
31
import com.google.common.collect.ClassToInstanceMap;
32
import com.google.common.collect.ImmutableBiMap;
33
import com.google.common.collect.ImmutableClassToInstanceMap;
34
import com.google.common.collect.ImmutableCollection;
35
import com.google.common.collect.ImmutableList;
36
import com.google.common.collect.ImmutableListMultimap;
37
import com.google.common.collect.ImmutableMap;
38
import com.google.common.collect.ImmutableMultimap;
39
import com.google.common.collect.ImmutableMultiset;
40
import com.google.common.collect.ImmutableSet;
41
import com.google.common.collect.ImmutableSetMultimap;
42
import com.google.common.collect.ImmutableSortedMap;
43
import com.google.common.collect.ImmutableSortedSet;
44
import com.google.common.collect.ImmutableTable;
45
import com.google.common.collect.ListMultimap;
46
import com.google.common.collect.MapDifference;
47
import com.google.common.collect.Multimap;
48
import com.google.common.collect.Multiset;
49
import com.google.common.collect.PeekingIterator;
50
import com.google.common.collect.Range;
51
import com.google.common.collect.RowSortedTable;
52
import com.google.common.collect.SetMultimap;
53
import com.google.common.collect.SortedMapDifference;
54
import com.google.common.collect.SortedMultiset;
55
import com.google.common.collect.SortedSetMultimap;
56
import com.google.common.collect.Table;
57
import com.google.common.io.ByteSink;
58
import com.google.common.io.ByteSource;
59
import com.google.common.io.CharSink;
60
import com.google.common.io.CharSource;
61
import com.google.common.primitives.UnsignedInteger;
62
import com.google.common.primitives.UnsignedLong;
63
import com.google.common.util.concurrent.AtomicDouble;
64
import java.io.ByteArrayInputStream;
65
import java.io.ByteArrayOutputStream;
66
import java.io.File;
67
import java.io.IOException;
68
import java.io.InputStream;
69
import java.io.OutputStream;
70
import java.io.PrintStream;
71
import java.io.PrintWriter;
72
import java.io.Reader;
73
import java.io.StringReader;
74
import java.io.StringWriter;
75
import java.io.Writer;
76
import java.lang.reflect.AnnotatedElement;
77
import java.lang.reflect.GenericDeclaration;
78
import java.lang.reflect.Type;
79
import java.math.BigDecimal;
80
import java.math.BigInteger;
81
import java.nio.Buffer;
82
import java.nio.ByteBuffer;
83
import java.nio.CharBuffer;
84
import java.nio.DoubleBuffer;
85
import java.nio.FloatBuffer;
86
import java.nio.IntBuffer;
87
import java.nio.LongBuffer;
88
import java.nio.ShortBuffer;
89
import java.nio.charset.Charset;
90
import java.util.ArrayList;
91
import java.util.BitSet;
92
import java.util.Collection;
93
import java.util.Comparator;
94
import java.util.Currency;
95
import java.util.Deque;
96
import java.util.HashMap;
97
import java.util.Iterator;
98
import java.util.LinkedList;
99
import java.util.List;
100
import java.util.ListIterator;
101
import java.util.Locale;
102
import java.util.Map;
103
import java.util.NavigableMap;
104
import java.util.NavigableSet;
105
import java.util.Optional;
106
import java.util.OptionalDouble;
107
import java.util.OptionalInt;
108
import java.util.OptionalLong;
109
import java.util.PriorityQueue;
110
import java.util.Queue;
111
import java.util.Random;
112
import java.util.Set;
113
import java.util.SortedMap;
114
import java.util.SortedSet;
115
import java.util.TreeMap;
116
import java.util.TreeSet;
117
import java.util.UUID;
118
import java.util.concurrent.BlockingDeque;
119
import java.util.concurrent.BlockingQueue;
120
import java.util.concurrent.ConcurrentMap;
121
import java.util.concurrent.ConcurrentNavigableMap;
122
import java.util.concurrent.DelayQueue;
123
import java.util.concurrent.Executor;
124
import java.util.concurrent.PriorityBlockingQueue;
125
import java.util.concurrent.SynchronousQueue;
126
import java.util.concurrent.ThreadFactory;
127
import java.util.concurrent.TimeUnit;
128
import java.util.concurrent.atomic.AtomicBoolean;
129
import java.util.concurrent.atomic.AtomicInteger;
130
import java.util.concurrent.atomic.AtomicLong;
131
import java.util.concurrent.atomic.AtomicReference;
132
import java.util.regex.MatchResult;
133
import java.util.regex.Pattern;
134
import junit.framework.TestCase;
135
import org.checkerframework.checker.nullness.qual.Nullable;
136

137
/**
138
 * Unit test for {@link ArbitraryInstances}.
139
 *
140
 * @author Ben Yu
141
 */
142
public class ArbitraryInstancesTest extends TestCase {
143

144
  public void testGet_primitives() {
145
    assertNull(ArbitraryInstances.get(void.class));
146
    assertNull(ArbitraryInstances.get(Void.class));
147
    assertEquals(Boolean.FALSE, ArbitraryInstances.get(boolean.class));
148
    assertEquals(Boolean.FALSE, ArbitraryInstances.get(Boolean.class));
149
    assertEquals(Character.valueOf('\0'), ArbitraryInstances.get(char.class));
150
    assertEquals(Character.valueOf('\0'), ArbitraryInstances.get(Character.class));
151
    assertEquals(Byte.valueOf((byte) 0), ArbitraryInstances.get(byte.class));
152
    assertEquals(Byte.valueOf((byte) 0), ArbitraryInstances.get(Byte.class));
153
    assertEquals(Short.valueOf((short) 0), ArbitraryInstances.get(short.class));
154
    assertEquals(Short.valueOf((short) 0), ArbitraryInstances.get(Short.class));
155
    assertEquals(Integer.valueOf(0), ArbitraryInstances.get(int.class));
156
    assertEquals(Integer.valueOf(0), ArbitraryInstances.get(Integer.class));
157
    assertEquals(Long.valueOf(0), ArbitraryInstances.get(long.class));
158
    assertEquals(Long.valueOf(0), ArbitraryInstances.get(Long.class));
159
    assertEquals(Float.valueOf(0), ArbitraryInstances.get(float.class));
160
    assertEquals(Float.valueOf(0), ArbitraryInstances.get(Float.class));
161
    assertThat(ArbitraryInstances.get(double.class)).isEqualTo(Double.valueOf(0));
162
    assertThat(ArbitraryInstances.get(Double.class)).isEqualTo(Double.valueOf(0));
163
    assertEquals(UnsignedInteger.ZERO, ArbitraryInstances.get(UnsignedInteger.class));
164
    assertEquals(UnsignedLong.ZERO, ArbitraryInstances.get(UnsignedLong.class));
165
    assertEquals(0, ArbitraryInstances.get(BigDecimal.class).intValue());
166
    assertEquals(0, ArbitraryInstances.get(BigInteger.class).intValue());
167
    assertEquals("", ArbitraryInstances.get(String.class));
168
    assertEquals("", ArbitraryInstances.get(CharSequence.class));
169
    assertEquals(TimeUnit.SECONDS, ArbitraryInstances.get(TimeUnit.class));
170
    assertNotNull(ArbitraryInstances.get(Object.class));
171
    assertEquals(0, ArbitraryInstances.get(Number.class));
172
    assertEquals(UTF_8, ArbitraryInstances.get(Charset.class));
173
    assertEquals(Optional.empty(), ArbitraryInstances.get(Optional.class));
174
    assertEquals(OptionalInt.empty(), ArbitraryInstances.get(OptionalInt.class));
175
    assertEquals(OptionalLong.empty(), ArbitraryInstances.get(OptionalLong.class));
176
    assertEquals(OptionalDouble.empty(), ArbitraryInstances.get(OptionalDouble.class));
177
    assertNotNull(ArbitraryInstances.get(UUID.class));
178
  }
179

180
  public void testGet_collections() {
181
    assertEquals(ImmutableSet.of().iterator(), ArbitraryInstances.get(Iterator.class));
182
    assertFalse(ArbitraryInstances.get(PeekingIterator.class).hasNext());
183
    assertFalse(ArbitraryInstances.get(ListIterator.class).hasNext());
184
    assertEquals(ImmutableSet.of(), ArbitraryInstances.get(Iterable.class));
185
    assertEquals(ImmutableSet.of(), ArbitraryInstances.get(Set.class));
186
    assertEquals(ImmutableSet.of(), ArbitraryInstances.get(ImmutableSet.class));
187
    assertEquals(ImmutableSortedSet.of(), ArbitraryInstances.get(SortedSet.class));
188
    assertEquals(ImmutableSortedSet.of(), ArbitraryInstances.get(ImmutableSortedSet.class));
189
    assertEquals(ImmutableList.of(), ArbitraryInstances.get(Collection.class));
190
    assertEquals(ImmutableList.of(), ArbitraryInstances.get(ImmutableCollection.class));
191
    assertEquals(ImmutableList.of(), ArbitraryInstances.get(List.class));
192
    assertEquals(ImmutableList.of(), ArbitraryInstances.get(ImmutableList.class));
193
    assertEquals(ImmutableMap.of(), ArbitraryInstances.get(Map.class));
194
    assertEquals(ImmutableMap.of(), ArbitraryInstances.get(ImmutableMap.class));
195
    assertEquals(ImmutableSortedMap.of(), ArbitraryInstances.get(SortedMap.class));
196
    assertEquals(ImmutableSortedMap.of(), ArbitraryInstances.get(ImmutableSortedMap.class));
197
    assertEquals(ImmutableMultiset.of(), ArbitraryInstances.get(Multiset.class));
198
    assertEquals(ImmutableMultiset.of(), ArbitraryInstances.get(ImmutableMultiset.class));
199
    assertTrue(ArbitraryInstances.get(SortedMultiset.class).isEmpty());
200
    assertEquals(ImmutableMultimap.of(), ArbitraryInstances.get(Multimap.class));
201
    assertEquals(ImmutableMultimap.of(), ArbitraryInstances.get(ImmutableMultimap.class));
202
    assertTrue(ArbitraryInstances.get(SortedSetMultimap.class).isEmpty());
203
    assertEquals(ImmutableTable.of(), ArbitraryInstances.get(Table.class));
204
    assertEquals(ImmutableTable.of(), ArbitraryInstances.get(ImmutableTable.class));
205
    assertTrue(ArbitraryInstances.get(RowSortedTable.class).isEmpty());
206
    assertEquals(ImmutableBiMap.of(), ArbitraryInstances.get(BiMap.class));
207
    assertEquals(ImmutableBiMap.of(), ArbitraryInstances.get(ImmutableBiMap.class));
208
    assertTrue(ArbitraryInstances.get(ImmutableClassToInstanceMap.class).isEmpty());
209
    assertTrue(ArbitraryInstances.get(ClassToInstanceMap.class).isEmpty());
210
    assertTrue(ArbitraryInstances.get(ListMultimap.class).isEmpty());
211
    assertTrue(ArbitraryInstances.get(ImmutableListMultimap.class).isEmpty());
212
    assertTrue(ArbitraryInstances.get(SetMultimap.class).isEmpty());
213
    assertTrue(ArbitraryInstances.get(ImmutableSetMultimap.class).isEmpty());
214
    assertTrue(ArbitraryInstances.get(MapDifference.class).areEqual());
215
    assertTrue(ArbitraryInstances.get(SortedMapDifference.class).areEqual());
216
    assertEquals(Range.all(), ArbitraryInstances.get(Range.class));
217
    assertTrue(ArbitraryInstances.get(NavigableSet.class).isEmpty());
218
    assertTrue(ArbitraryInstances.get(NavigableMap.class).isEmpty());
219
    assertTrue(ArbitraryInstances.get(LinkedList.class).isEmpty());
220
    assertTrue(ArbitraryInstances.get(Deque.class).isEmpty());
221
    assertTrue(ArbitraryInstances.get(Queue.class).isEmpty());
222
    assertTrue(ArbitraryInstances.get(PriorityQueue.class).isEmpty());
223
    assertTrue(ArbitraryInstances.get(BitSet.class).isEmpty());
224
    assertTrue(ArbitraryInstances.get(TreeSet.class).isEmpty());
225
    assertTrue(ArbitraryInstances.get(TreeMap.class).isEmpty());
226
    assertFreshInstanceReturned(
227
        LinkedList.class,
228
        Deque.class,
229
        Queue.class,
230
        PriorityQueue.class,
231
        BitSet.class,
232
        TreeSet.class,
233
        TreeMap.class);
234
  }
235

236
  public void testGet_misc() {
237
    assertNotNull(ArbitraryInstances.get(CharMatcher.class));
238
    assertNotNull(ArbitraryInstances.get(Currency.class).getCurrencyCode());
239
    assertNotNull(ArbitraryInstances.get(Locale.class));
240
    assertNotNull(ArbitraryInstances.get(Joiner.class).join(ImmutableList.of("a")));
241
    assertNotNull(ArbitraryInstances.get(Splitter.class).split("a,b"));
242
    assertThat(ArbitraryInstances.get(com.google.common.base.Optional.class)).isAbsent();
243
    ArbitraryInstances.get(Stopwatch.class).start();
244
    assertNotNull(ArbitraryInstances.get(Ticker.class));
245
    assertFreshInstanceReturned(Random.class);
246
    assertEquals(
247
        ArbitraryInstances.get(Random.class).nextInt(),
248
        ArbitraryInstances.get(Random.class).nextInt());
249
  }
250

251
  public void testGet_concurrent() {
252
    assertTrue(ArbitraryInstances.get(BlockingDeque.class).isEmpty());
253
    assertTrue(ArbitraryInstances.get(BlockingQueue.class).isEmpty());
254
    assertTrue(ArbitraryInstances.get(DelayQueue.class).isEmpty());
255
    assertTrue(ArbitraryInstances.get(SynchronousQueue.class).isEmpty());
256
    assertTrue(ArbitraryInstances.get(PriorityBlockingQueue.class).isEmpty());
257
    assertTrue(ArbitraryInstances.get(ConcurrentMap.class).isEmpty());
258
    assertTrue(ArbitraryInstances.get(ConcurrentNavigableMap.class).isEmpty());
259
    ArbitraryInstances.get(Executor.class).execute(ArbitraryInstances.get(Runnable.class));
260
    assertNotNull(ArbitraryInstances.get(ThreadFactory.class));
261
    assertFreshInstanceReturned(
262
        BlockingQueue.class,
263
        BlockingDeque.class,
264
        PriorityBlockingQueue.class,
265
        DelayQueue.class,
266
        SynchronousQueue.class,
267
        ConcurrentMap.class,
268
        ConcurrentNavigableMap.class,
269
        AtomicReference.class,
270
        AtomicBoolean.class,
271
        AtomicInteger.class,
272
        AtomicLong.class,
273
        AtomicDouble.class);
274
  }
275

276
  @SuppressWarnings("unchecked") // functor classes have no type parameters
277
  public void testGet_functors() {
278
    assertEquals(0, ArbitraryInstances.get(Comparator.class).compare("abc", 123));
279
    assertTrue(ArbitraryInstances.get(Predicate.class).apply("abc"));
280
    assertTrue(ArbitraryInstances.get(Equivalence.class).equivalent(1, 1));
281
    assertFalse(ArbitraryInstances.get(Equivalence.class).equivalent(1, 2));
282
  }
283

284
  @SuppressWarnings("SelfComparison")
285
  public void testGet_comparable() {
286
    @SuppressWarnings("unchecked") // The null value can compare with any Object
287
    Comparable<Object> comparable = ArbitraryInstances.get(Comparable.class);
288
    assertEquals(0, comparable.compareTo(comparable));
289
    assertTrue(comparable.compareTo("") > 0);
290
    assertThrows(NullPointerException.class, () -> comparable.compareTo(null));
291
  }
292

293
  public void testGet_array() {
294
    assertThat(ArbitraryInstances.get(int[].class)).isEmpty();
295
    assertThat(ArbitraryInstances.get(Object[].class)).isEmpty();
296
    assertThat(ArbitraryInstances.get(String[].class)).isEmpty();
297
  }
298

299
  public void testGet_enum() {
300
    assertNull(ArbitraryInstances.get(EmptyEnum.class));
301
    assertEquals(Direction.UP, ArbitraryInstances.get(Direction.class));
302
  }
303

304
  public void testGet_interface() {
305
    assertNull(ArbitraryInstances.get(SomeInterface.class));
306
  }
307

308
  public void testGet_runnable() {
309
    ArbitraryInstances.get(Runnable.class).run();
310
  }
311

312
  public void testGet_class() {
313
    assertSame(SomeAbstractClass.INSTANCE, ArbitraryInstances.get(SomeAbstractClass.class));
314
    assertSame(
315
        WithPrivateConstructor.INSTANCE, ArbitraryInstances.get(WithPrivateConstructor.class));
316
    assertNull(ArbitraryInstances.get(NoDefaultConstructor.class));
317
    assertSame(
318
        WithExceptionalConstructor.INSTANCE,
319
        ArbitraryInstances.get(WithExceptionalConstructor.class));
320
    assertNull(ArbitraryInstances.get(NonPublicClass.class));
321
  }
322

323
  public void testGet_mutable() {
324
    assertEquals(0, ArbitraryInstances.get(ArrayList.class).size());
325
    assertEquals(0, ArbitraryInstances.get(HashMap.class).size());
326
    assertThat(ArbitraryInstances.get(Appendable.class).toString()).isEmpty();
327
    assertThat(ArbitraryInstances.get(StringBuilder.class).toString()).isEmpty();
328
    assertThat(ArbitraryInstances.get(StringBuffer.class).toString()).isEmpty();
329
    assertFreshInstanceReturned(
330
        ArrayList.class,
331
        HashMap.class,
332
        Appendable.class,
333
        StringBuilder.class,
334
        StringBuffer.class,
335
        Throwable.class,
336
        Exception.class);
337
  }
338

339
  public void testGet_io() throws IOException {
340
    assertEquals(-1, ArbitraryInstances.get(InputStream.class).read());
341
    assertEquals(-1, ArbitraryInstances.get(ByteArrayInputStream.class).read());
342
    assertEquals(-1, ArbitraryInstances.get(Readable.class).read(CharBuffer.allocate(1)));
343
    assertEquals(-1, ArbitraryInstances.get(Reader.class).read());
344
    assertEquals(-1, ArbitraryInstances.get(StringReader.class).read());
345
    assertEquals(0, ArbitraryInstances.get(Buffer.class).capacity());
346
    assertEquals(0, ArbitraryInstances.get(CharBuffer.class).capacity());
347
    assertEquals(0, ArbitraryInstances.get(ByteBuffer.class).capacity());
348
    assertEquals(0, ArbitraryInstances.get(ShortBuffer.class).capacity());
349
    assertEquals(0, ArbitraryInstances.get(IntBuffer.class).capacity());
350
    assertEquals(0, ArbitraryInstances.get(LongBuffer.class).capacity());
351
    assertEquals(0, ArbitraryInstances.get(FloatBuffer.class).capacity());
352
    assertEquals(0, ArbitraryInstances.get(DoubleBuffer.class).capacity());
353
    ArbitraryInstances.get(PrintStream.class).println("test");
354
    ArbitraryInstances.get(PrintWriter.class).println("test");
355
    assertNotNull(ArbitraryInstances.get(File.class));
356
    assertFreshInstanceReturned(
357
        ByteArrayOutputStream.class, OutputStream.class,
358
        Writer.class, StringWriter.class,
359
        PrintStream.class, PrintWriter.class);
360
    assertEquals(ByteSource.empty(), ArbitraryInstances.get(ByteSource.class));
361
    assertEquals(CharSource.empty(), ArbitraryInstances.get(CharSource.class));
362
    assertNotNull(ArbitraryInstances.get(ByteSink.class));
363
    assertNotNull(ArbitraryInstances.get(CharSink.class));
364
  }
365

366
  public void testGet_reflect() {
367
    assertNotNull(ArbitraryInstances.get(Type.class));
368
    assertNotNull(ArbitraryInstances.get(AnnotatedElement.class));
369
    assertNotNull(ArbitraryInstances.get(GenericDeclaration.class));
370
  }
371

372
  public void testGet_regex() {
373
    assertEquals(Pattern.compile("").pattern(), ArbitraryInstances.get(Pattern.class).pattern());
374
    assertEquals(0, ArbitraryInstances.get(MatchResult.class).groupCount());
375
  }
376

377
  public void testGet_usePublicConstant() {
378
    assertSame(WithPublicConstant.INSTANCE, ArbitraryInstances.get(WithPublicConstant.class));
379
  }
380

381
  public void testGet_useFirstPublicConstant() {
382
    assertSame(WithPublicConstants.FIRST, ArbitraryInstances.get(WithPublicConstants.class));
383
  }
384

385
  public void testGet_nullConstantIgnored() {
386
    assertSame(FirstConstantIsNull.SECOND, ArbitraryInstances.get(FirstConstantIsNull.class));
387
  }
388

389
  public void testGet_constantWithGenericsNotUsed() {
390
    assertNull(ArbitraryInstances.get(WithGenericConstant.class));
391
  }
392

393
  public void testGet_nullConstant() {
394
    assertNull(ArbitraryInstances.get(WithNullConstant.class));
395
  }
396

397
  public void testGet_constantTypeDoesNotMatch() {
398
    assertNull(ArbitraryInstances.get(ParentClassHasConstant.class));
399
  }
400

401
  public void testGet_nonPublicConstantNotUsed() {
402
    assertNull(ArbitraryInstances.get(NonPublicConstantIgnored.class));
403
  }
404

405
  public void testGet_nonStaticFieldNotUsed() {
406
    assertNull(ArbitraryInstances.get(NonStaticFieldIgnored.class));
407
  }
408

409
  public void testGet_constructorPreferredOverConstants() {
410
    assertNotNull(ArbitraryInstances.get(WithPublicConstructorAndConstant.class));
411
    assertTrue(
412
        ArbitraryInstances.get(WithPublicConstructorAndConstant.class)
413
            != ArbitraryInstances.get(WithPublicConstructorAndConstant.class));
414
  }
415

416
  public void testGet_nonFinalFieldNotUsed() {
417
    assertNull(ArbitraryInstances.get(NonFinalFieldIgnored.class));
418
  }
419

420
  private static void assertFreshInstanceReturned(Class<?>... mutableClasses) {
421
    for (Class<?> mutableClass : mutableClasses) {
422
      Object instance = ArbitraryInstances.get(mutableClass);
423
      assertNotNull("Expected to return non-null for: " + mutableClass, instance);
424
      assertNotSame(
425
          "Expected to return fresh instance for: " + mutableClass,
426
          instance,
427
          ArbitraryInstances.get(mutableClass));
428
    }
429
  }
430

431
  private enum EmptyEnum {}
432

433
  private enum Direction {
434
    UP,
435
    DOWN
436
  }
437

438
  public interface SomeInterface {}
439

440
  public abstract static class SomeAbstractClass {
441
    public static final SomeAbstractClass INSTANCE = new SomeAbstractClass() {};
442

443
    public SomeAbstractClass() {}
444
  }
445

446
  static class NonPublicClass {
447
    public NonPublicClass() {}
448
  }
449

450
  private static class WithPrivateConstructor {
451
    public static final WithPrivateConstructor INSTANCE = new WithPrivateConstructor();
452
  }
453

454
  public static class NoDefaultConstructor {
455
    public NoDefaultConstructor(@SuppressWarnings("unused") int i) {}
456
  }
457

458
  public static class WithExceptionalConstructor {
459
    public static final WithExceptionalConstructor INSTANCE =
460
        new WithExceptionalConstructor("whatever");
461

462
    public WithExceptionalConstructor() {
463
      throw new RuntimeException();
464
    }
465

466
    private WithExceptionalConstructor(String unused) {}
467
  }
468

469
  private static class WithPublicConstant {
470
    public static final WithPublicConstant INSTANCE = new WithPublicConstant();
471
  }
472

473
  private static class ParentClassHasConstant extends WithPublicConstant {}
474

475
  public static class WithGenericConstant<T> {
476
    public static final WithGenericConstant<String> STRING_CONSTANT = new WithGenericConstant<>();
477

478
    private WithGenericConstant() {}
479
  }
480

481
  public static class WithNullConstant {
482
    public static final @Nullable WithNullConstant NULL = null;
483

484
    private WithNullConstant() {}
485
  }
486

487
  public static class WithPublicConstructorAndConstant {
488
    public static final WithPublicConstructorAndConstant INSTANCE =
489
        new WithPublicConstructorAndConstant();
490

491
    public WithPublicConstructorAndConstant() {}
492
  }
493

494
  private static class WithPublicConstants {
495
    public static final WithPublicConstants FIRST = new WithPublicConstants();
496

497
    // To test that we pick the first constant alphabetically
498
    @SuppressWarnings("unused")
499
    public static final WithPublicConstants SECOND = new WithPublicConstants();
500
  }
501

502
  private static class FirstConstantIsNull {
503
    // To test that null constant is ignored
504
    @SuppressWarnings("unused")
505
    public static final @Nullable FirstConstantIsNull FIRST = null;
506

507
    public static final FirstConstantIsNull SECOND = new FirstConstantIsNull();
508
  }
509

510
  public static class NonFinalFieldIgnored {
511
    public static NonFinalFieldIgnored instance = new NonFinalFieldIgnored();
512

513
    private NonFinalFieldIgnored() {}
514
  }
515

516
  public static class NonPublicConstantIgnored {
517
    static final NonPublicConstantIgnored INSTANCE = new NonPublicConstantIgnored();
518

519
    private NonPublicConstantIgnored() {}
520
  }
521

522
  public static class NonStaticFieldIgnored {
523
    // This should cause infinite recursion. But it shouldn't be used anyway.
524
    public final NonStaticFieldIgnored instance = new NonStaticFieldIgnored();
525

526
    private NonStaticFieldIgnored() {}
527
  }
528
}
529
Java

Использование cookies
