}

    // Test field assignment
    public void test_fieldAssignment() {
        String[] fields = new String[] { "field1", "field2", "field3" };
        facetInfo.field = fields;
        assertNotNull(facetInfo.field);
        assertEquals(3, facetInfo.field.length);
        assertSame(fields, facetInfo.field);
    }

    // Test size assignment
    public void test_sizeAssignment() {

   * processing or telecommunication systems, more especially switching devices "on" or "off." (If a
   * single "stop" control is required to interrupt or turn off ancillary devices, DC4 is the
   * preferred assignment.)
   *
   * @since 8.0
   */
  public static final byte DC1 = 17; // aka XON

  /**
   * Transmission On: Although originally defined as DC1, this ASCII control character is now better

     * This is an unsynchronized read! After the read, the function returns immediately or acquires
     * the lock to check again. Since an IDLE state was observed inside the preceding synchronized
     * block, and reference field assignment is atomic, this may save reacquiring the lock when
     * another thread or the worker task has cleared the count and set the state.
     *
     * <p>When {@link #executor} is a directExecutor(), the value written to

    // of the values gets evicted. With weak keys, we use identity equality, which means using
    // System.identityHashCode, which means the assignment of keys to segments is nondeterministic,
    // so more than (maximumSize / #segments) keys could get assigned to the same segment, which
    // would cause one to be evicted.
    return new CacheBuilderFactory()

          () -> {
            lock.lock();
            try {
              startUp();
              /*
               * requireNonNull is safe because executorService is never cleared after the
               * assignment above.
               */
              requireNonNull(executorService);
              runningTask = scheduler().schedule(delegate, executorService, task);
              notifyStarted();

          () -> {
            lock.lock();
            try {
              startUp();
              /*
               * requireNonNull is safe because executorService is never cleared after the
               * assignment above.
               */
              requireNonNull(executorService);
              runningTask = scheduler().schedule(delegate, executorService, task);
              notifyStarted();

    // of the values gets evicted. With weak keys, we use identity equality, which means using
    // System.identityHashCode, which means the assignment of keys to segments is nondeterministic,
    // so more than (maximumSize / #segments) keys could get assigned to the same segment, which
    // would cause one to be evicted.
    return new CacheBuilderFactory()

   * Guides the allowed concurrency among update operations. Used as a hint for internal sizing. The
   * table is internally partitioned to try to permit the indicated number of concurrent updates
   * without contention. Because assignment of entries to these partitions is not necessarily
   * uniform, the actual concurrency observed may vary. Ideally, you should choose a value to

     *
     * @param toClass
     *            The target class. Must not be {@literal null}.
     * @param fromClass
     *            The source class. Must not be {@literal null}.
     * @return Whether assignment is possible.
     * @see Class#isAssignableFrom(Class)
     */
    public static boolean isAssignableFrom(final Class<?> toClass, Class<?> fromClass) {
        assertArgumentNotNull("toClass", toClass);