* </ul>
 *
 * <p>Disadvantages compared to {@code int[]}:
 *
 * <ul>
 *   <li>Memory footprint has a fixed overhead (about 24 bytes per instance).
 *   <li><i>Some</i> construction use cases force the data to be copied (though several construction
 *       APIs are offered that don't).
 *   <li>Can't be passed directly to methods that expect {@code int[]} (though the most common
 *       utilities do have replacements here).

import java.util.logging.Formatter
import java.util.logging.LogRecord

/**
 * Is Java8 Data and Time really this bad, or is writing this on a plane from just javadocs a bad
 * idea?
 *
 * Why so much construction?
 */
class OneLineLogFormat : Formatter() {
  private val d =
    DateTimeFormatterBuilder()
      .appendValue(HOUR_OF_DAY, 2)
      .appendLiteral(':')
      .appendValue(MINUTE_OF_HOUR, 2)

    MemoizingSupplier(Supplier<T> delegate) {
      this.delegate = checkNotNull(delegate);
    }

    @Override
    @ParametricNullness
    // We set the field only once (during construction or deserialization).
    @SuppressWarnings("SynchronizeOnNonFinalField")
    public T get() {
      // A 2-field variant of Double Checked Locking.
      if (!initialized) {
        synchronized (lock) {

     * Creates a new duplicate host helper instance.
     */
    public DuplicateHostHelper() {
        // Default constructor
    }

    /**
     * Initializes the duplicate host helper after construction.
     * Loads duplicate host configurations from the DuplicateHostService.
     */
    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {

 *
 * <p><b>Warning:</b> {@code ArrayTable} is rarely the {@link Table} implementation you want. First,
 * it requires that the complete universe of rows and columns be specified at construction time.
 * Second, it is always backed by an array large enough to hold a value for every possible
 * combination of row and column keys. (This is rarely optimal unless the table is extremely dense.)

   * will never throw {@link ConcurrentModificationException}, and guarantees to traverse elements
   * as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect
   * any modifications subsequent to construction.
   *
   * @return an iterator over the elements in this queue
   */
  @CanIgnoreReturnValue // pushed down from class to method
  @Override

    }

    // Test constructor
    public void test_constructor_withValidParameters() {
        // Test normal construction
        assertNotNull(securityResourceProvider);

        // Verify fields are set correctly
        InvertibleCryptographer providedInvertible = securityResourceProvider.providePrimaryInvertibleCryptographer();

   * ConcurrentModificationException}, and guarantees to traverse elements as they existed upon
   * construction of the iterator, and may (but is not guaranteed to) reflect any modifications
   * subsequent to construction.
   *
   * @return an iterator over the elements in this queue in proper sequence
   */
  @CanIgnoreReturnValue
  @Override

    MemoizingSupplier(Supplier<T> delegate) {
      this.delegate = checkNotNull(delegate);
    }

    @Override
    @ParametricNullness
    // We set the field only once (during construction or deserialization).
    @SuppressWarnings("SynchronizeOnNonFinalField")
    public T get() {
      // A 2-field variant of Double Checked Locking.
      if (!initialized) {
        synchronized (lock) {

                    1,
                    SECONDS));
    assertThat(expected).hasCauseThat().isSameInstanceAs(CHECKED_EXCEPTION);
  }

  // Edge case tests of the exception-construction code through untimed get():

  @SuppressWarnings("FuturesGetCheckedIllegalExceptionType")
  public void testGetCheckedUntimed_exceptionClassIsRuntimeException() {
    assertThrows(