return super.setException(t);
    }
  }

  enum Impl {
    NEW {
      @Override
      <T> Facade<T> newFacade() {
        return new NewAbstractFutureFacade<T>();
      }
    },
    OLD {
      @Override
      <T> Facade<T> newFacade() {
        return new OldAbstractFutureFacade<T>();
      }
    };

    abstract <T> Facade<T> newFacade();
  }

//
// 4. __outdated__           - returned by outDatedDisk, provided []StorageAPI
//                             returned by diskWithAllParts is passed for latestDisks.
//    - has an old copy of xl.meta
//    - doesn't have xl.meta (errFileNotFound)
//    - has the latest xl.meta but one or more parts are corrupt
//
// 5. __missingParts__       - has the latest copy of xl.meta but has some parts

  ImmutableMap<K, V> getAllPresent(Iterable<? extends Object> keys);

  /**
   * Associates {@code value} with {@code key} in this cache. If the cache previously contained a
   * value associated with {@code key}, the old value is replaced by {@code value}.
   *
   * <p>Prefer {@link #get(Object, Callable)} when using the conventional "if cached, return;
   * otherwise create, cache and return" pattern.
   *
   * @since 11.0
   */

        assertEquals("m", item.getInputs()[1]);
        assertEquals("z", item.getInputs()[2]);
    }

    @Test
    public void test_getNewInputs_setNewInputs() {
        String[] inputs = { "old" };
        CharMappingItem item = new CharMappingItem(1L, inputs, "output");

        // Initially null for non-zero id
        assertNull(item.getNewInputs());

        // Set new inputs

    /** The key of the message: Delete old search logs */
    public static final String LABELS_purge_search_log_day = "{labels.purge_search_log_day}";

    /** The key of the message: Delete old job logs */
    public static final String LABELS_purge_job_log_day = "{labels.purge_job_log_day}";

    /** The key of the message: Delete old user logs */

        return Synchronized.multiset(HashMultiset.<Integer>create(), null);
      }
    },
    ;

    abstract Multiset<Integer> get();
  }

  /**
   * Duplication of the old version of ConcurrentHashMultiset (with some unused stuff removed, like
   * serialization code) which used a map with boxed integers for the values.
   */

But then you have to call "that method that converts the first letter to upper case".

Was it `upper`? Was it `uppercase`? `first_uppercase`? `capitalize`?

Then, you try with the old programmer's friend, editor autocompletion.

You type the first parameter of the function, `first_name`, then a dot (`.`) and then hit `Ctrl+Space` to trigger the completion.

But, sadly, you get nothing useful:

   *
   * @param reference any array of the desired type
   * @param length the length of the new array
   */
  /*
   * The new array contains nulls, even if the old array did not. If we wanted to be accurate, we
   * would declare a return type of `@Nullable T[]`. However, we've decided not to think too hard
   * about arrays for now, as they're a mess.
   */

                    return oldItem;
                }
                if (!item.equals(oldItem)) {
                    throw new DictionaryException("StemmerOverride file was updated: old=" + oldItem + " : new=" + item);
                }
                try {
                    if (!item.isDeleted()) {
                        // update
                        writer.write(item.toLineString());

        testData2.add(createRelatedQuery("term2", new String[] { "query2" }, ""));
        mockBhv.setTestData(testData2);

        relatedQueryHelper.load();

        // Old term should not be found
        results = relatedQueryHelper.getRelatedQueries("term1");
        assertEquals(0, results.length);

        // New term should be found