src/test/java/org/apache/bcel/Java8PublicClasses.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.bcel;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.CharConversionException;
import java.io.Closeable;
import java.io.Console;
import java.io.DataInput;
import java.io.DataInputStream;
import java.io.DataOutput;
import java.io.DataOutputStream;
import java.io.EOFException;
import java.io.Externalizable;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilePermission;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.FilterInputStream;
import java.io.FilterOutputStream;
import java.io.FilterReader;
import java.io.FilterWriter;
import java.io.Flushable;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.InterruptedIOException;
import java.io.InvalidClassException;
import java.io.InvalidObjectException;
import java.io.LineNumberReader;
import java.io.NotActiveException;
import java.io.NotSerializableException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectInputValidation;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamClass;
import java.io.ObjectStreamException;
import java.io.ObjectStreamField;
import java.io.OptionalDataException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.PushbackInputStream;
import java.io.PushbackReader;
import java.io.RandomAccessFile;
import java.io.Reader;
import java.io.SequenceInputStream;
import java.io.Serializable;
import java.io.SerializablePermission;
import java.io.StreamCorruptedException;
import java.io.StreamTokenizer;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.SyncFailedException;
import java.io.UTFDataFormatException;
import java.io.UncheckedIOException;
import java.io.UnsupportedEncodingException;
import java.io.WriteAbortedException;
import java.io.Writer;
import java.lang.annotation.Annotation;
import java.lang.annotation.AnnotationFormatError;
import java.lang.annotation.AnnotationTypeMismatchException;
import java.lang.annotation.Documented;
import java.lang.annotation.IncompleteAnnotationException;
import java.lang.annotation.Inherited;
import java.lang.annotation.Native;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.invoke.CallSite;
import java.lang.invoke.ConstantCallSite;
import java.lang.invoke.LambdaMetafactory;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandleInfo;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.invoke.MutableCallSite;
import java.lang.invoke.SwitchPoint;
import java.lang.invoke.VolatileCallSite;
import java.lang.invoke.WrongMethodTypeException;
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.AnnotatedArrayType;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.AnnotatedParameterizedType;
import java.lang.reflect.AnnotatedType;
import java.lang.reflect.AnnotatedTypeVariable;
import java.lang.reflect.AnnotatedWildcardType;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.GenericDeclaration;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.MalformedParameterizedTypeException;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Parameter;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Proxy;
import java.lang.reflect.ReflectPermission;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.UndeclaredThrowableException;
import java.lang.reflect.WildcardType;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.math.RoundingMode;
import java.net.Authenticator;
import java.net.BindException;
import java.net.CacheRequest;
import java.net.CacheResponse;
import java.net.ConnectException;
import java.net.ContentHandler;
import java.net.CookieHandler;
import java.net.CookieManager;
import java.net.CookiePolicy;
import java.net.CookieStore;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.DatagramSocketImpl;
import java.net.FileNameMap;
import java.net.HttpCookie;
import java.net.HttpRetryException;
import java.net.HttpURLConnection;
import java.net.IDN;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.InterfaceAddress;
import java.net.JarURLConnection;
import java.net.MalformedURLException;
import java.net.MulticastSocket;
import java.net.NetPermission;
import java.net.NetworkInterface;
import java.net.NoRouteToHostException;
import java.net.PasswordAuthentication;
import java.net.PortUnreachableException;
import java.net.ProtocolException;
import java.net.ProxySelector;
import java.net.ResponseCache;
import java.net.SecureCacheResponse;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.SocketImpl;
import java.net.SocketOption;
import java.net.SocketOptions;
import java.net.SocketPermission;
import java.net.SocketTimeoutException;
import java.net.StandardProtocolFamily;
import java.net.StandardSocketOptions;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.net.URLConnection;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.net.URLStreamHandler;
import java.net.UnknownHostException;
import java.net.UnknownServiceException;
import java.nio.Buffer;
import java.nio.BufferOverflowException;
import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.CharBuffer;
import java.nio.DoubleBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.InvalidMarkException;
import java.nio.LongBuffer;
import java.nio.MappedByteBuffer;
import java.nio.ReadOnlyBufferException;
import java.nio.ShortBuffer;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import java.nio.charset.CodingErrorAction;
import java.nio.charset.IllegalCharsetNameException;
import java.nio.charset.MalformedInputException;
import java.nio.charset.StandardCharsets;
import java.nio.charset.UnmappableCharacterException;
import java.nio.charset.UnsupportedCharsetException;
import java.nio.file.AccessDeniedException;
import java.nio.file.AtomicMoveNotSupportedException;
import java.nio.file.ClosedDirectoryStreamException;
import java.nio.file.ClosedFileSystemException;
import java.nio.file.ClosedWatchServiceException;
import java.nio.file.DirectoryIteratorException;
import java.nio.file.DirectoryNotEmptyException;
import java.nio.file.DirectoryStream;
import java.nio.file.FileAlreadyExistsException;
import java.nio.file.FileSystem;
import java.nio.file.FileSystemException;
import java.nio.file.FileSystemLoopException;
import java.nio.file.FileSystemNotFoundException;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitOption;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.InvalidPathException;
import java.nio.file.LinkOption;
import java.nio.file.NoSuchFileException;
import java.nio.file.NotDirectoryException;
import java.nio.file.NotLinkException;
import java.nio.file.OpenOption;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.Paths;
import java.nio.file.ProviderMismatchException;
import java.nio.file.ProviderNotFoundException;
import java.nio.file.ReadOnlyFileSystemException;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.nio.file.StandardWatchEventKinds;
import java.nio.file.WatchEvent;
import java.nio.file.WatchKey;
import java.nio.file.WatchService;
import java.nio.file.Watchable;
import java.nio.file.attribute.AclEntry;
import java.nio.file.attribute.AclEntryFlag;
import java.nio.file.attribute.AclEntryPermission;
import java.nio.file.attribute.AclEntryType;
import java.nio.file.attribute.AclFileAttributeView;
import java.nio.file.attribute.AttributeView;
import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.DosFileAttributeView;
import java.nio.file.attribute.DosFileAttributes;
import java.nio.file.attribute.FileAttribute;
import java.nio.file.attribute.FileAttributeView;
import java.nio.file.attribute.FileOwnerAttributeView;
import java.nio.file.attribute.FileStoreAttributeView;
import java.nio.file.attribute.FileTime;
import java.nio.file.attribute.GroupPrincipal;
import java.nio.file.attribute.PosixFileAttributeView;
import java.nio.file.attribute.PosixFileAttributes;
import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;
import java.nio.file.attribute.UserDefinedFileAttributeView;
import java.nio.file.attribute.UserPrincipal;
import java.nio.file.attribute.UserPrincipalLookupService;
import java.nio.file.attribute.UserPrincipalNotFoundException;
import java.security.AccessControlContext;
import java.security.AccessControlException;
import java.security.AccessController;
import java.security.AlgorithmParameterGenerator;
import java.security.AlgorithmParameters;
import java.security.AlgorithmParametersSpi;
import java.security.AllPermission;
import java.security.AuthProvider;
import java.security.BasicPermission;
import java.security.Certificate;
import java.security.CodeSigner;
import java.security.CodeSource;
import java.security.DigestException;
import java.security.DigestInputStream;
import java.security.DigestOutputStream;
import java.security.DomainCombiner;
import java.security.GeneralSecurityException;
import java.security.Guard;
import java.security.GuardedObject;
import java.security.Identity;
import java.security.IdentityScope;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.InvalidParameterException;
import java.security.Key;
import java.security.KeyException;
import java.security.KeyFactory;
import java.security.KeyFactorySpi;
import java.security.KeyManagementException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.KeyPairGeneratorSpi;
import java.security.KeyRep;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.KeyStoreSpi;
import java.security.MessageDigest;
import java.security.MessageDigestSpi;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Permission;
import java.security.PermissionCollection;
import java.security.Permissions;
import java.security.Policy;
import java.security.PolicySpi;
import java.security.Principal;
import java.security.PrivateKey;
import java.security.PrivilegedAction;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.security.ProtectionDomain;
import java.security.Provider;
import java.security.ProviderException;
import java.security.PublicKey;
import java.security.SecureClassLoader;
import java.security.SecureRandom;
import java.security.SecureRandomSpi;
import java.security.Security;
import java.security.SecurityPermission;
import java.security.Signature;
import java.security.SignatureException;
import java.security.SignatureSpi;
import java.security.SignedObject;
import java.security.Signer;
import java.security.UnrecoverableEntryException;
import java.security.UnrecoverableKeyException;
import java.security.UnresolvedPermission;
import java.sql.BatchUpdateException;
import java.sql.Blob;
import java.sql.CallableStatement;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DataTruncation;
import java.sql.DatabaseMetaData;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.NClob;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLClientInfoException;
import java.sql.SQLData;
import java.sql.SQLDataException;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLInput;
import java.sql.SQLIntegrityConstraintViolationException;
import java.sql.SQLInvalidAuthorizationSpecException;
import java.sql.SQLNonTransientConnectionException;
import java.sql.SQLNonTransientException;
import java.sql.SQLOutput;
import java.sql.SQLPermission;
import java.sql.SQLRecoverableException;
import java.sql.SQLSyntaxErrorException;
import java.sql.SQLTimeoutException;
import java.sql.SQLTransactionRollbackException;
import java.sql.SQLTransientConnectionException;
import java.sql.SQLTransientException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Savepoint;
import java.sql.Statement;
import java.sql.Struct;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.sql.Wrapper;
import java.text.AttributedCharacterIterator;
import java.text.AttributedString;
import java.text.Bidi;
import java.text.BreakIterator;
import java.text.CharacterIterator;
import java.text.ChoiceFormat;
import java.text.CollationElementIterator;
import java.text.CollationKey;
import java.text.Collator;
import java.text.DateFormat;
import java.text.DateFormatSymbols;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.FieldPosition;
import java.text.Format;
import java.text.MessageFormat;
import java.text.Normalizer;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.RuleBasedCollator;
import java.text.SimpleDateFormat;
import java.text.StringCharacterIterator;
import java.time.Clock;
import java.time.DateTimeException;
import java.time.DayOfWeek;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.Month;
import java.time.MonthDay;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.Period;
import java.time.Year;
import java.time.YearMonth;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.chrono.AbstractChronology;
import java.time.chrono.ChronoLocalDate;
import java.time.chrono.ChronoLocalDateTime;
import java.time.chrono.ChronoPeriod;
import java.time.chrono.ChronoZonedDateTime;
import java.time.chrono.Chronology;
import java.time.chrono.Era;
import java.time.chrono.HijrahChronology;
import java.time.chrono.HijrahDate;
import java.time.chrono.HijrahEra;
import java.time.chrono.IsoChronology;
import java.time.chrono.IsoEra;
import java.time.chrono.JapaneseChronology;
import java.time.chrono.JapaneseDate;
import java.time.chrono.JapaneseEra;
import java.time.chrono.MinguoChronology;
import java.time.chrono.MinguoDate;
import java.time.chrono.MinguoEra;
import java.time.chrono.ThaiBuddhistChronology;
import java.time.chrono.ThaiBuddhistDate;
import java.time.chrono.ThaiBuddhistEra;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.DateTimeParseException;
import java.time.format.DecimalStyle;
import java.time.format.FormatStyle;
import java.time.format.ResolverStyle;
import java.time.format.SignStyle;
import java.time.format.TextStyle;
import java.time.temporal.ChronoField;
import java.time.temporal.ChronoUnit;
import java.time.temporal.IsoFields;
import java.time.temporal.JulianFields;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;
import java.time.temporal.TemporalAmount;
import java.time.temporal.TemporalField;
import java.time.temporal.TemporalQueries;
import java.time.temporal.TemporalQuery;
import java.time.temporal.TemporalUnit;
import java.time.temporal.UnsupportedTemporalTypeException;
import java.time.temporal.ValueRange;
import java.time.temporal.WeekFields;
import java.time.zone.ZoneOffsetTransition;
import java.time.zone.ZoneOffsetTransitionRule;
import java.time.zone.ZoneRules;
import java.time.zone.ZoneRulesException;
import java.time.zone.ZoneRulesProvider;
import java.util.AbstractCollection;
import java.util.AbstractList;
import java.util.AbstractMap;
import java.util.AbstractQueue;
import java.util.AbstractSequentialList;
import java.util.AbstractSet;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
import java.util.BitSet;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.ConcurrentModificationException;
import java.util.Currency;
import java.util.Date;
import java.util.Deque;
import java.util.Dictionary;
import java.util.DoubleSummaryStatistics;
import java.util.DuplicateFormatFlagsException;
import java.util.EmptyStackException;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.Enumeration;
import java.util.EventListener;
import java.util.EventListenerProxy;
import java.util.EventObject;
import java.util.FormatFlagsConversionMismatchException;
import java.util.Formattable;
import java.util.FormattableFlags;
import java.util.Formatter;
import java.util.FormatterClosedException;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.IdentityHashMap;
import java.util.IllegalFormatCodePointException;
import java.util.IllegalFormatConversionException;
import java.util.IllegalFormatException;
import java.util.IllegalFormatFlagsException;
import java.util.IllegalFormatPrecisionException;
import java.util.IllegalFormatWidthException;
import java.util.IllformedLocaleException;
import java.util.InputMismatchException;
import java.util.IntSummaryStatistics;
import java.util.InvalidPropertiesFormatException;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.ListResourceBundle;
import java.util.Locale;
import java.util.LongSummaryStatistics;
import java.util.Map;
import java.util.MissingFormatArgumentException;
import java.util.MissingFormatWidthException;
import java.util.MissingResourceException;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Observable;
import java.util.Observer;
import java.util.Optional;
import java.util.OptionalDouble;
import java.util.OptionalInt;
import java.util.OptionalLong;
import java.util.PrimitiveIterator;
import java.util.PriorityQueue;
import java.util.Properties;
import java.util.PropertyPermission;
import java.util.PropertyResourceBundle;
import java.util.Queue;
import java.util.Random;
import java.util.RandomAccess;
import java.util.ResourceBundle;
import java.util.Scanner;
import java.util.ServiceConfigurationError;
import java.util.ServiceLoader;
import java.util.Set;
import java.util.SimpleTimeZone;
import java.util.SortedMap;
import java.util.SortedSet;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.SplittableRandom;
import java.util.Stack;
import java.util.StringJoiner;
import java.util.StringTokenizer;
import java.util.TimeZone;
import java.util.Timer;
import java.util.TimerTask;
import java.util.TooManyListenersException;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.UUID;
import java.util.UnknownFormatConversionException;
import java.util.UnknownFormatFlagsException;
import java.util.Vector;
import java.util.WeakHashMap;
import java.util.concurrent.AbstractExecutorService;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
import java.util.concurrent.ConcurrentSkipListSet;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CountedCompleter;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.ForkJoinWorkerThread;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.LinkedTransferQueue;
import java.util.concurrent.Phaser;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.RunnableFuture;
import java.util.concurrent.RunnableScheduledFuture;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.Semaphore;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.TransferQueue;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicLongArray;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
import java.util.concurrent.atomic.AtomicMarkableReference;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicReferenceArray;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
import java.util.concurrent.atomic.AtomicStampedReference;
import java.util.concurrent.atomic.DoubleAccumulator;
import java.util.concurrent.atomic.DoubleAdder;
import java.util.concurrent.atomic.LongAccumulator;
import java.util.concurrent.atomic.LongAdder;
import java.util.concurrent.locks.AbstractOwnableSynchronizer;
import java.util.concurrent.locks.AbstractQueuedLongSynchronizer;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.StampedLock;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.BinaryOperator;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
import java.util.function.DoubleBinaryOperator;
import java.util.function.DoubleConsumer;
import java.util.function.DoubleFunction;
import java.util.function.DoublePredicate;
import java.util.function.DoubleSupplier;
import java.util.function.DoubleToIntFunction;
import java.util.function.DoubleToLongFunction;
import java.util.function.DoubleUnaryOperator;
import java.util.function.Function;
import java.util.function.IntBinaryOperator;
import java.util.function.IntConsumer;
import java.util.function.IntFunction;
import java.util.function.IntPredicate;
import java.util.function.IntSupplier;
import java.util.function.IntToDoubleFunction;
import java.util.function.IntToLongFunction;
import java.util.function.IntUnaryOperator;
import java.util.function.LongBinaryOperator;
import java.util.function.LongConsumer;
import java.util.function.LongFunction;
import java.util.function.LongPredicate;
import java.util.function.LongSupplier;
import java.util.function.LongToDoubleFunction;
import java.util.function.LongToIntFunction;
import java.util.function.LongUnaryOperator;
import java.util.function.ObjDoubleConsumer;
import java.util.function.ObjIntConsumer;
import java.util.function.ObjLongConsumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.ToDoubleBiFunction;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntBiFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongBiFunction;
import java.util.function.ToLongFunction;
import java.util.function.UnaryOperator;
import java.util.regex.MatchResult;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import java.util.stream.BaseStream;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class Java8PublicClasses {

    // java.io
    private static final Class<?>[] JAVA_IO = { BufferedInputStream.class, BufferedOutputStream.class, BufferedReader.class, BufferedWriter.class,
            ByteArrayInputStream.class, ByteArrayOutputStream.class, CharArrayReader.class, CharArrayWriter.class, Closeable.class, Console.class,
            DataInput.class, DataInputStream.class, DataOutput.class, DataOutputStream.class, File.class, FileDescriptor.class, FileInputStream.class,
            FileOutputStream.class, FilePermission.class, FileReader.class, FileWriter.class, FilterInputStream.class, FilterOutputStream.class,
            FilterReader.class, FilterWriter.class, Flushable.class, InputStream.class, InputStreamReader.class, LineNumberReader.class, ObjectInput.class,
            ObjectInputStream.class, ObjectOutput.class, ObjectOutputStream.class, ObjectStreamClass.class, ObjectStreamField.class, OutputStream.class,
            OutputStreamWriter.class, PipedInputStream.class, PipedOutputStream.class, PipedReader.class, PipedWriter.class, PrintStream.class,
            PrintWriter.class, PushbackInputStream.class, PushbackReader.class, RandomAccessFile.class, Reader.class, SequenceInputStream.class,
            Serializable.class, SerializablePermission.class, StreamTokenizer.class, StringReader.class, StringWriter.class, Writer.class, Externalizable.class,
            FileFilter.class, FilenameFilter.class, ObjectInputValidation.class,
            // Exceptions
            CharConversionException.class, EOFException.class, FileNotFoundException.class, InterruptedIOException.class, InvalidClassException.class,
            InvalidObjectException.class, IOException.class, NotActiveException.class, NotSerializableException.class, ObjectStreamException.class,
            OptionalDataException.class, StreamCorruptedException.class, SyncFailedException.class, UnsupportedEncodingException.class,
            UTFDataFormatException.class, WriteAbortedException.class, UncheckedIOException.class };

    // java.lang
    private static final Class<?>[] JAVA_LANG = { Appendable.class, AutoCloseable.class, Boolean.class, Byte.class, CharSequence.class, Character.class,
            Class.class, ClassLoader.class, ClassValue.class, Cloneable.class, Comparable.class, /* Compiler.class, */ Double.class, Enum.class, Float.class,
            InheritableThreadLocal.class, Integer.class, Iterable.class, Long.class, Math.class, Number.class, Object.class, Package.class, Process.class,
            ProcessBuilder.class, Readable.class, Runnable.class, Runtime.class, RuntimePermission.class, SecurityManager.class, Short.class,
            StackTraceElement.class, StrictMath.class, String.class, StringBuffer.class, StringBuilder.class, System.class, Thread.class, ThreadGroup.class,
            ThreadLocal.class, Throwable.class, Void.class,
            // Exceptions
            ArithmeticException.class, ArrayIndexOutOfBoundsException.class, ArrayStoreException.class, ClassCastException.class, ClassNotFoundException.class,
            CloneNotSupportedException.class, EnumConstantNotPresentException.class, Exception.class, IllegalAccessException.class,
            IllegalArgumentException.class, IllegalMonitorStateException.class, IllegalStateException.class, IllegalThreadStateException.class,
            IndexOutOfBoundsException.class, InstantiationException.class, InterruptedException.class, NegativeArraySizeException.class,
            NoSuchFieldException.class, NoSuchMethodException.class, NullPointerException.class, NumberFormatException.class,
            ReflectiveOperationException.class, RuntimeException.class, SecurityException.class, StringIndexOutOfBoundsException.class,
            TypeNotPresentException.class, UnsupportedOperationException.class,
            // Errors
            AbstractMethodError.class, AssertionError.class, BootstrapMethodError.class, ClassCircularityError.class, ClassFormatError.class, Error.class,
            ExceptionInInitializerError.class, IllegalAccessError.class, IncompatibleClassChangeError.class, InstantiationError.class, InternalError.class,
            LinkageError.class, NoClassDefFoundError.class, NoSuchFieldError.class, NoSuchMethodError.class, OutOfMemoryError.class, StackOverflowError.class,
            ThreadDeath.class, UnknownError.class, UnsatisfiedLinkError.class, UnsupportedClassVersionError.class, VerifyError.class,
            VirtualMachineError.class };

    // java.lang.annotation
    private static final Class<?>[] JAVA_LANG_ANNOTATION = { Annotation.class, Documented.class, Inherited.class, Retention.class, Target.class,
            AnnotationFormatError.class, AnnotationTypeMismatchException.class, IncompleteAnnotationException.class, Repeatable.class, Native.class };

    // java.lang.invoke
    private static final Class<?>[] JAVA_LANG_INVOKE = { CallSite.class, ConstantCallSite.class, MethodHandle.class, MethodHandleInfo.class,
            MethodHandles.class, MethodType.class, MutableCallSite.class, SwitchPoint.class, VolatileCallSite.class, WrongMethodTypeException.class,
            LambdaMetafactory.class };

    // java.lang.ref
    private static final Class<?>[] JAVA_LANG_REF = { PhantomReference.class, Reference.class, ReferenceQueue.class, SoftReference.class,
            WeakReference.class };

    // java.lang.reflect
    private static final Class<?>[] JAVA_LANG_REFLECT = { AccessibleObject.class, AnnotatedElement.class, Array.class, Constructor.class,
            Executable.class, Field.class, GenericArrayType.class, GenericDeclaration.class, InvocationHandler.class, Member.class, Method.class,
            Modifier.class, Parameter.class, ParameterizedType.class, Proxy.class, ReflectPermission.class, Type.class, TypeVariable.class, WildcardType.class,
            AnnotatedType.class, AnnotatedArrayType.class, AnnotatedParameterizedType.class, AnnotatedTypeVariable.class, AnnotatedWildcardType.class,
            InvocationTargetException.class, MalformedParameterizedTypeException.class, UndeclaredThrowableException.class };

    // java.math
    private static final Class<?>[] JAVA_MATH = { BigDecimal.class, BigInteger.class, MathContext.class, RoundingMode.class };

    // java.net
    private static final Class<?>[] JAVA_NET = { Authenticator.class, CacheRequest.class, CacheResponse.class, ContentHandler.class,
            CookieHandler.class, CookieManager.class, CookiePolicy.class, CookieStore.class, DatagramPacket.class, DatagramSocket.class,
            DatagramSocketImpl.class, FileNameMap.class, HttpCookie.class, HttpURLConnection.class, IDN.class, Inet4Address.class, Inet6Address.class,
            InetAddress.class, InetSocketAddress.class, InterfaceAddress.class, JarURLConnection.class, MulticastSocket.class, NetPermission.class,
            NetworkInterface.class, PasswordAuthentication.class, Proxy.class, ProxySelector.class, ResponseCache.class, SecureCacheResponse.class,
            ServerSocket.class, Socket.class, SocketAddress.class, SocketImpl.class, SocketOption.class, SocketOptions.class, SocketPermission.class,
            StandardProtocolFamily.class, StandardSocketOptions.class, URI.class, URL.class, URLClassLoader.class, URLConnection.class, URLDecoder.class,
            URLEncoder.class, URLStreamHandler.class, BindException.class, ConnectException.class, HttpRetryException.class, MalformedURLException.class,
            NoRouteToHostException.class, PortUnreachableException.class, ProtocolException.class, SocketException.class, SocketTimeoutException.class,
            UnknownHostException.class, UnknownServiceException.class, URISyntaxException.class };

    // java.nio
    private static final Class<?>[] JAVA_NIO = { Buffer.class, ByteBuffer.class, ByteOrder.class, CharBuffer.class, DoubleBuffer.class,
            FloatBuffer.class, IntBuffer.class, LongBuffer.class, MappedByteBuffer.class, ShortBuffer.class, BufferOverflowException.class,
            BufferUnderflowException.class, InvalidMarkException.class, ReadOnlyBufferException.class };

    // java.nio.charset
    private static final Class<?>[] JAVA_NIO_CHARSET = { Charset.class, CharsetDecoder.class, CharsetEncoder.class, CoderResult.class,
            CodingErrorAction.class, StandardCharsets.class, CharacterCodingException.class, IllegalCharsetNameException.class, MalformedInputException.class,
            UnmappableCharacterException.class, UnsupportedCharsetException.class };

    // java.nio.file
    private static final Class<?>[] JAVA_NIO_FILE = { DirectoryStream.class, FileSystem.class, FileSystems.class, FileVisitOption.class,
            FileVisitResult.class, FileVisitor.class, Files.class, LinkOption.class, OpenOption.class, Path.class, PathMatcher.class, Paths.class,
            SimpleFileVisitor.class, StandardCopyOption.class, StandardOpenOption.class, StandardWatchEventKinds.class, WatchEvent.class, WatchKey.class,
            WatchService.class, Watchable.class, AccessDeniedException.class, AtomicMoveNotSupportedException.class, ClosedDirectoryStreamException.class,
            ClosedFileSystemException.class, ClosedWatchServiceException.class, DirectoryIteratorException.class, DirectoryNotEmptyException.class,
            FileAlreadyExistsException.class, FileSystemException.class, FileSystemLoopException.class, FileSystemNotFoundException.class,
            InvalidPathException.class, NoSuchFileException.class, NotDirectoryException.class, NotLinkException.class, ProviderMismatchException.class,
            ProviderNotFoundException.class, ReadOnlyFileSystemException.class };

    // java.nio.file.attribute
    private static final Class<?>[] JAVA_NIO_FILE_ATTRIBUTE = { AclEntry.class, AclEntryFlag.class, AclEntryPermission.class, AclEntryType.class,
            AclFileAttributeView.class, AttributeView.class, BasicFileAttributeView.class, BasicFileAttributes.class, DosFileAttributeView.class,
            DosFileAttributes.class, FileAttribute.class, FileAttributeView.class, FileOwnerAttributeView.class, FileStoreAttributeView.class, FileTime.class,
            GroupPrincipal.class, PosixFileAttributeView.class, PosixFileAttributes.class, PosixFilePermission.class, PosixFilePermissions.class,
            UserDefinedFileAttributeView.class, UserPrincipal.class, UserPrincipalLookupService.class, UserPrincipalNotFoundException.class };

    // java.security
    private static final Class<?>[] JAVA_SECURITY = { AccessControlContext.class, AccessController.class, AlgorithmParameterGenerator.class,
            AlgorithmParameters.class, AlgorithmParametersSpi.class, AllPermission.class, AuthProvider.class, BasicPermission.class, Certificate.class,
            CodeSigner.class, CodeSource.class, DigestInputStream.class, DigestOutputStream.class, DomainCombiner.class, Guard.class, GuardedObject.class,
            Identity.class, IdentityScope.class, Key.class, KeyFactory.class, KeyFactorySpi.class, KeyPair.class, KeyPairGenerator.class,
            KeyPairGeneratorSpi.class, KeyRep.class, KeyStore.class, KeyStoreSpi.class, MessageDigest.class, MessageDigestSpi.class, Permission.class,
            PermissionCollection.class, Permissions.class, Policy.class, PolicySpi.class, Principal.class, PrivateKey.class, PrivilegedAction.class,
            PrivilegedActionException.class, PrivilegedExceptionAction.class, ProtectionDomain.class, Provider.class, PublicKey.class, SecureClassLoader.class,
            SecureRandom.class, SecureRandomSpi.class, Security.class, SecurityPermission.class, Signature.class, SignatureException.class, SignatureSpi.class,
            SignedObject.class, Signer.class, java.security.Timestamp.class, UnrecoverableEntryException.class, UnrecoverableKeyException.class,
            UnresolvedPermission.class, AccessControlException.class, DigestException.class, GeneralSecurityException.class,
            InvalidAlgorithmParameterException.class, InvalidKeyException.class, InvalidParameterException.class, KeyException.class,
            KeyManagementException.class, KeyStoreException.class, NoSuchAlgorithmException.class, NoSuchProviderException.class, ProviderException.class };

    // java.sql
    private static final Class<?>[] JAVA_SQL = { Array.class, Blob.class, CallableStatement.class, Clob.class, Connection.class, DatabaseMetaData.class,
            java.sql.Date.class, Driver.class, DriverManager.class, DriverPropertyInfo.class, NClob.class, ParameterMetaData.class, PreparedStatement.class,
            Ref.class, ResultSet.class, ResultSetMetaData.class, RowId.class, Savepoint.class, SQLData.class, SQLInput.class, SQLOutput.class,
            SQLPermission.class, SQLXML.class, Statement.class, Struct.class, Time.class, Timestamp.class, Types.class, Wrapper.class,
            BatchUpdateException.class, DataTruncation.class, SQLClientInfoException.class, SQLException.class, SQLDataException.class,
            SQLFeatureNotSupportedException.class, SQLIntegrityConstraintViolationException.class, SQLInvalidAuthorizationSpecException.class,
            SQLNonTransientConnectionException.class, SQLNonTransientException.class, SQLRecoverableException.class, SQLSyntaxErrorException.class,
            SQLTimeoutException.class, SQLTransactionRollbackException.class, SQLTransientConnectionException.class, SQLTransientException.class,
            SQLWarning.class };

    // java.text
    private static final Class<?>[] JAVA_TEXT = { Annotation.class, AttributedCharacterIterator.class, AttributedString.class, Bidi.class,
            BreakIterator.class, CharacterIterator.class, ChoiceFormat.class, CollationElementIterator.class, CollationKey.class, Collator.class,
            DateFormat.class, DateFormatSymbols.class, DecimalFormat.class, DecimalFormatSymbols.class, FieldPosition.class, Format.class, MessageFormat.class,
            Normalizer.class, NumberFormat.class, ParsePosition.class, RuleBasedCollator.class, SimpleDateFormat.class, StringCharacterIterator.class,
            ParseException.class };

    // java.time
    private static final Class<?>[] JAVA_TIME = { Clock.class, DateTimeException.class, DayOfWeek.class, Duration.class, Instant.class, LocalDate.class,
            LocalDateTime.class, LocalTime.class, Month.class, MonthDay.class, OffsetDateTime.class, OffsetTime.class, Period.class, Year.class,
            YearMonth.class, ZonedDateTime.class, ZoneId.class, ZoneOffset.class };

    // java.time.chrono
    private static final Class<?>[] JAVA_TIME_CHRONO = { AbstractChronology.class, ChronoLocalDate.class, ChronoLocalDateTime.class, Chronology.class,
            ChronoPeriod.class, ChronoZonedDateTime.class, Era.class, HijrahChronology.class, HijrahDate.class, HijrahEra.class, IsoChronology.class,
            IsoEra.class, JapaneseChronology.class, JapaneseDate.class, JapaneseEra.class, MinguoChronology.class, MinguoDate.class, MinguoEra.class,
            ThaiBuddhistChronology.class, ThaiBuddhistDate.class, ThaiBuddhistEra.class };

    // java.time.format
    private static final Class<?>[] JAVA_TIME_FORMAT = { DateTimeFormatter.class, DateTimeFormatterBuilder.class, DateTimeParseException.class,
            DecimalStyle.class, FormatStyle.class, ResolverStyle.class, SignStyle.class, TextStyle.class };

    // java.time.temporal
    private static final Class<?>[] JAVA_TIME_TEMPORAL = { ChronoField.class, ChronoUnit.class, IsoFields.class, JulianFields.class, Temporal.class,
            TemporalAccessor.class, TemporalAdjuster.class, TemporalAdjusters.class, TemporalAmount.class, TemporalField.class, TemporalQueries.class,
            TemporalQuery.class, TemporalUnit.class, ValueRange.class, WeekFields.class, UnsupportedTemporalTypeException.class };

    // java.time.zone
    private static final Class<?>[] JAVA_TIME_ZONE = { ZoneOffsetTransition.class, ZoneOffsetTransitionRule.class, ZoneRules.class,
            ZoneRulesException.class, ZoneRulesProvider.class };

    // java.util
    private static final Class<?>[] JAVA_UTIL = { AbstractCollection.class, AbstractList.class, AbstractMap.class, AbstractQueue.class,
            AbstractSequentialList.class, AbstractSet.class, ArrayDeque.class, ArrayList.class, Arrays.class, Base64.class, BitSet.class, Calendar.class,
            Collection.class, Collections.class, Comparator.class, Currency.class, Date.class, Deque.class, Dictionary.class, DoubleSummaryStatistics.class,
            EnumMap.class, EnumSet.class, Enumeration.class, EventListener.class, EventListenerProxy.class, EventObject.class, FormattableFlags.class,
            Formatter.class, GregorianCalendar.class, HashMap.class, HashSet.class, Hashtable.class, IdentityHashMap.class, IntSummaryStatistics.class,
            Iterator.class, LinkedHashMap.class, LinkedHashSet.class, LinkedList.class, List.class, ListIterator.class, ListResourceBundle.class, Locale.class,
            LongSummaryStatistics.class, Map.class, NavigableMap.class, NavigableSet.class, Objects.class, Observable.class, Observer.class, Optional.class,
            OptionalDouble.class, OptionalInt.class, OptionalLong.class, PrimitiveIterator.class, PriorityQueue.class, Properties.class,
            PropertyPermission.class, PropertyResourceBundle.class, Queue.class, Random.class, RandomAccess.class, ResourceBundle.class, Scanner.class,
            ServiceLoader.class, Set.class, SimpleTimeZone.class, SortedMap.class, SortedSet.class, Spliterator.class, Spliterators.class,
            SplittableRandom.class, Stack.class, StringJoiner.class, StringTokenizer.class, Timer.class, TimerTask.class, TimeZone.class, TreeMap.class,
            TreeSet.class, UUID.class, Vector.class, WeakHashMap.class, Formattable.class,
            // Exceptions
            ConcurrentModificationException.class, DuplicateFormatFlagsException.class, EmptyStackException.class, FormatFlagsConversionMismatchException.class,
            FormatterClosedException.class, IllegalFormatCodePointException.class, IllegalFormatConversionException.class, IllegalFormatException.class,
            IllegalFormatFlagsException.class, IllegalFormatPrecisionException.class, IllegalFormatWidthException.class, IllformedLocaleException.class,
            InputMismatchException.class, InvalidPropertiesFormatException.class, MissingFormatArgumentException.class, MissingFormatWidthException.class,
            MissingResourceException.class, NoSuchElementException.class, TooManyListenersException.class, UnknownFormatConversionException.class,
            UnknownFormatFlagsException.class, ServiceConfigurationError.class };

    // java.util.concurrent
    private static final Class<?>[] JAVA_UTIL_CONCURRENT = { AbstractExecutorService.class, ArrayBlockingQueue.class, BlockingDeque.class,
            BlockingQueue.class, Callable.class, CompletableFuture.class, CompletionException.class, CompletionService.class, ConcurrentHashMap.class,
            ConcurrentLinkedDeque.class, ConcurrentLinkedQueue.class, ConcurrentMap.class, ConcurrentNavigableMap.class, ConcurrentSkipListMap.class,
            ConcurrentSkipListSet.class, CopyOnWriteArrayList.class, CopyOnWriteArraySet.class, CountDownLatch.class, CountedCompleter.class,
            CyclicBarrier.class, Delayed.class, DelayQueue.class, Exchanger.class, Executor.class, ExecutorCompletionService.class, ExecutorService.class,
            Executors.class, ForkJoinPool.class, ForkJoinTask.class, ForkJoinWorkerThread.class, Future.class, FutureTask.class, LinkedBlockingDeque.class,
            LinkedBlockingQueue.class, LinkedTransferQueue.class, Phaser.class, PriorityBlockingQueue.class, RecursiveAction.class, RecursiveTask.class,
            RejectedExecutionHandler.class, RunnableFuture.class, RunnableScheduledFuture.class, ScheduledExecutorService.class, ScheduledFuture.class,
            ScheduledThreadPoolExecutor.class, Semaphore.class, SynchronousQueue.class, ThreadFactory.class, ThreadLocalRandom.class, ThreadPoolExecutor.class,
            TimeUnit.class, TransferQueue.class, BrokenBarrierException.class, CancellationException.class, CompletionException.class, ExecutionException.class,
            RejectedExecutionException.class, TimeoutException.class };

    // java.util.concurrent.atomic
    private static final Class<?>[] JAVA_UTIL_CONCURRENT_ATOMIC = { AtomicBoolean.class, AtomicInteger.class, AtomicIntegerArray.class,
            AtomicIntegerFieldUpdater.class, AtomicLong.class, AtomicLongArray.class, AtomicLongFieldUpdater.class, AtomicMarkableReference.class,
            AtomicReference.class, AtomicReferenceArray.class, AtomicReferenceFieldUpdater.class, AtomicStampedReference.class, DoubleAccumulator.class,
            DoubleAdder.class, LongAccumulator.class, LongAdder.class };

    // java.util.concurrent.locks
    private static final Class<?>[] JAVA_UTIL_CONCURRENT_LOCKS = { AbstractOwnableSynchronizer.class, AbstractQueuedLongSynchronizer.class,
            AbstractQueuedSynchronizer.class, Condition.class, Lock.class, LockSupport.class, ReadWriteLock.class, ReentrantLock.class,
            ReentrantReadWriteLock.class, StampedLock.class };

    // java.util.function
    private static final Class<?>[] JAVA_UTIL_FUNCTION = { BiConsumer.class, BiFunction.class, BinaryOperator.class, BiPredicate.class,
            BooleanSupplier.class, Consumer.class, DoubleBinaryOperator.class, DoubleConsumer.class, DoubleFunction.class, DoublePredicate.class,
            DoubleSupplier.class, DoubleToIntFunction.class, DoubleToLongFunction.class, DoubleUnaryOperator.class, Function.class, IntBinaryOperator.class,
            IntConsumer.class, IntFunction.class, IntPredicate.class, IntSupplier.class, IntToDoubleFunction.class, IntToLongFunction.class,
            IntUnaryOperator.class, LongBinaryOperator.class, LongConsumer.class, LongFunction.class, LongPredicate.class, LongSupplier.class,
            LongToDoubleFunction.class, LongToIntFunction.class, LongUnaryOperator.class, ObjDoubleConsumer.class, ObjIntConsumer.class, ObjLongConsumer.class,
            Predicate.class, Supplier.class, ToDoubleBiFunction.class, ToDoubleFunction.class, ToIntBiFunction.class, ToIntFunction.class,
            ToLongBiFunction.class, ToLongFunction.class, UnaryOperator.class };

    // java.util.regex
    private static final Class<?>[] JAVA_UTIL_REGEX = { MatchResult.class, Matcher.class, Pattern.class, PatternSyntaxException.class };

    // java.util.stream
    private static final Class<?>[] JAVA_UTIL_STREAM = { BaseStream.class, Collector.class, Collectors.class, DoubleStream.class, IntStream.class,
            LongStream.class, Stream.class, StreamSupport.class };

    private static final Class<?>[] ALL = addAll(JAVA_LANG, JAVA_LANG_ANNOTATION, JAVA_LANG_INVOKE,
            JAVA_LANG_REF, JAVA_LANG_REFLECT, JAVA_MATH, JAVA_IO, JAVA_NIO, JAVA_NIO_CHARSET,
            JAVA_NIO_FILE, JAVA_NIO_FILE_ATTRIBUTE, JAVA_UTIL, JAVA_UTIL_CONCURRENT, JAVA_UTIL_CONCURRENT_ATOMIC,
            JAVA_UTIL_CONCURRENT_LOCKS, JAVA_UTIL_FUNCTION, JAVA_UTIL_STREAM, JAVA_UTIL_REGEX, JAVA_TIME,
            JAVA_TIME_CHRONO, JAVA_TIME_FORMAT, JAVA_TIME_TEMPORAL, JAVA_TIME_ZONE, JAVA_NET, JAVA_TEXT,
            JAVA_SQL, JAVA_SECURITY);

    @SafeVarargs
    private static Class<?>[] addAll(final Class<?>[]... arrays) {
        int newLen = 0;
        for (final Class<?>[] array : arrays) {
            newLen += array.length;
        }
        final Class<?>[] result = new Class<?>[newLen];
        int i = 0;
        for (final Class<?>[] array : arrays) {
            System.arraycopy(array, 0, result, i, array.length);
            i += array.length;
        }
        return result;
    }

    public static Class<?>[] getAll() {
        return ALL.clone();
    }
}