• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 org.junit.Assert.assertThrows;
21 
22 import com.google.common.base.CharMatcher;
23 import com.google.common.base.Charsets;
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 
testGet_primitives()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     assertEquals(Double.valueOf(0), ArbitraryInstances.get(double.class));
162     assertEquals(Double.valueOf(0), ArbitraryInstances.get(Double.class));
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(Charsets.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 
testGet_collections()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 
testGet_misc()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 
testGet_concurrent()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
testGet_functors()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")
testGet_comparable()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 
testGet_array()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 
testGet_enum()299   public void testGet_enum() {
300     assertNull(ArbitraryInstances.get(EmptyEnum.class));
301     assertEquals(Direction.UP, ArbitraryInstances.get(Direction.class));
302   }
303 
testGet_interface()304   public void testGet_interface() {
305     assertNull(ArbitraryInstances.get(SomeInterface.class));
306   }
307 
testGet_runnable()308   public void testGet_runnable() {
309     ArbitraryInstances.get(Runnable.class).run();
310   }
311 
testGet_class()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 
testGet_mutable()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 
testGet_io()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 
testGet_reflect()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 
testGet_regex()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 
testGet_usePublicConstant()377   public void testGet_usePublicConstant() {
378     assertSame(WithPublicConstant.INSTANCE, ArbitraryInstances.get(WithPublicConstant.class));
379   }
380 
testGet_useFirstPublicConstant()381   public void testGet_useFirstPublicConstant() {
382     assertSame(WithPublicConstants.FIRST, ArbitraryInstances.get(WithPublicConstants.class));
383   }
384 
testGet_nullConstantIgnored()385   public void testGet_nullConstantIgnored() {
386     assertSame(FirstConstantIsNull.SECOND, ArbitraryInstances.get(FirstConstantIsNull.class));
387   }
388 
testGet_constantWithGenericsNotUsed()389   public void testGet_constantWithGenericsNotUsed() {
390     assertNull(ArbitraryInstances.get(WithGenericConstant.class));
391   }
392 
testGet_nullConstant()393   public void testGet_nullConstant() {
394     assertNull(ArbitraryInstances.get(WithNullConstant.class));
395   }
396 
testGet_constantTypeDoesNotMatch()397   public void testGet_constantTypeDoesNotMatch() {
398     assertNull(ArbitraryInstances.get(ParentClassHasConstant.class));
399   }
400 
testGet_nonPublicConstantNotUsed()401   public void testGet_nonPublicConstantNotUsed() {
402     assertNull(ArbitraryInstances.get(NonPublicConstantIgnored.class));
403   }
404 
testGet_nonStaticFieldNotUsed()405   public void testGet_nonStaticFieldNotUsed() {
406     assertNull(ArbitraryInstances.get(NonStaticFieldIgnored.class));
407   }
408 
testGet_constructorPreferredOverConstants()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 
testGet_nonFinalFieldNotUsed()416   public void testGet_nonFinalFieldNotUsed() {
417     assertNull(ArbitraryInstances.get(NonFinalFieldIgnored.class));
418   }
419 
assertFreshInstanceReturned(Class<?>.... mutableClasses)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 
SomeAbstractClass()443     public SomeAbstractClass() {}
444   }
445 
446   static class NonPublicClass {
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 {
NoDefaultConstructor(@uppressWarnings"unused") int i)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 
WithExceptionalConstructor()462     public WithExceptionalConstructor() {
463       throw new RuntimeException();
464     }
465 
WithExceptionalConstructor(String unused)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 
WithGenericConstant()478     private WithGenericConstant() {}
479   }
480 
481   public static class WithNullConstant {
482     public static final @Nullable WithNullConstant NULL = null;
483 
WithNullConstant()484     private WithNullConstant() {}
485   }
486 
487   public static class WithPublicConstructorAndConstant {
488     public static final WithPublicConstructorAndConstant INSTANCE =
489         new WithPublicConstructorAndConstant();
490 
WithPublicConstructorAndConstant()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 
NonFinalFieldIgnored()513     private NonFinalFieldIgnored() {}
514   }
515 
516   public static class NonPublicConstantIgnored {
517     static final NonPublicConstantIgnored INSTANCE = new NonPublicConstantIgnored();
518 
NonPublicConstantIgnored()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 
NonStaticFieldIgnored()526     private NonStaticFieldIgnored() {}
527   }
528 }
529