* <i>chaining</i>, and <i>using</i>.
 *
 * <h4>Acquiring</h4>
 *
 * <p>The common ways to get an instance of {@code Ordering} are:
 *
 * <ul>
 *   <li>Subclass it and implement {@link #compare} instead of implementing {@link Comparator}
 *       directly
 *   <li>Pass a <i>pre-existing</i> {@link Comparator} instance to {@link #from(Comparator)}

    assertThat(future.isDone()).isFalse();
    assertThat(future.set(1)).isTrue();
    assertSuccessful(future, 1);
  }

  /** Concrete subclass for testing. */
  private static class TestedFuture<V extends @Nullable Object> extends AbstractFuture<V> {
    private static <V extends @Nullable Object> TestedFuture<V> create() {
      return new TestedFuture<V>();
    }

        assertEquals("single", item.getInputsValue());
    }

    @Test
    public void test_getInputsValue_withNullInputs() {
        // Create item and then set inputs to null via reflection or subclass
        CharMappingItem item = new CharMappingItem(1L, new String[] { "temp" }, "output") {
            @Override
            public String getInputsValue() {
                // Simulate null inputs scenario

      if (result) {
        executionList.execute();
      }
      return result;
    }

    /**
     * Following the contract of {@link AbstractQueuedSynchronizer} we create a private subclass to
     * hold the synchronizer. This synchronizer is used to implement the blocking and waiting calls
     * as well as to handle state changes in a thread-safe manner. The current state of the future

   * ForwardingMultiset#entrySet}, and {@link ForwardingMultiset#remove(Object, int)}. In many
   * situations, you may wish to override {@link ForwardingMultiset#elementSet} to forward to this
   * implementation or a subclass thereof.
   *
   * @since 10.0
   */
  protected class StandardElementSet extends Multisets.ElementSet<E> {
    /** Constructor for use by subclasses. */
    public StandardElementSet() {}

    @Override

Works shall not include works that contain only declarations,
interfaces, types, classes, structures, or files of the Program solely
in each case in order to link to, bind by name, or subclass the Program
or Modified Works thereof.

"Distribute" means the acts of a) distributing or b) making available
in any manner that enables the transfer of a copy.

    static Comparator<byte[]> getBestComparator() {
      try {
        Class<? extends LexicographicalComparator> unsafeImpl =
            Class.forName(UNSAFE_COMPARATOR_NAME).asSubclass(LexicographicalComparator.class);
        // requireNonNull is safe because the class is an enum.
        LexicographicalComparator unsafeComparator =
            requireNonNull(unsafeImpl.getEnumConstants())[0];

        testConfig.disallowCompound = customDisallow;

        testConfig.initDefaults();

        assertEquals(customDisallow, testConfig.disallowCompound);
    }

    /**
     * Testable subclass that exposes the default constructor
     */
    private static class TestableBaseConfiguration extends BaseConfiguration {
        TestableBaseConfiguration() throws CIFSException {
            super(true);
        }

 * </ul>
 *
 * <h3>Example</h3>
 *
 * {@snippet :
 * return Converter.from(
 *     Integer::toHexString,
 *     s -> parseUnsignedInt(s, 16));
 * }
 *
 * <p>An alternative using a subclass:
 *
 * {@snippet :
 * return new Converter<Integer, String>() {
 *   @Override
 *   protected String doForward(Integer i) {
 *     return Integer.toHexString(i);
 *   }
 *
 *   @Override

        return null;
      }
      try {
        /*
         * We use URLClassLoader because it's the only concrete class loader implementation in the
         * JDK. If we used our own ClassLoader subclass, Finalizer would indirectly reference this
         * class loader:
         *
         * Finalizer.class -> CustomClassLoader -> CustomClassLoader.class -> This class loader
         *