throws Exception {
    // Make sure we are actually running with the expected helper implementation
    Class<?> abstractFutureClass = classLoader.loadClass(AbstractFuture.class.getName());
    Field helperField = abstractFutureClass.getDeclaredField("ATOMIC_HELPER");
    helperField.setAccessible(true);
    assertEquals(expectedHelperClassName, helperField.get(null).getClass().getSimpleName());

import com.google.common.annotations.GwtCompatible;
import java.util.List;
import java.util.Map.Entry;
import java.util.SortedMap;

/**
 * Implementation helper for {@link TestMapGenerator} for use with sorted maps of strings.
 *
 * @author Chris Povirk
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault

import java.io.IOException;
import java.io.Writer;

/**
 * Unit test for {@link AppendableWriter}.
 *
 * @author Alan Green
 */
public class AppendableWriterTest extends IoTestCase {

  /** Helper class for testing behavior with Flushable and Closeable targets. */
  private static class SpyAppendable implements Appendable, Flushable, Closeable {
    boolean flushed;
    boolean closed;

        </configuration>
      </plugin>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>build-helper-maven-plugin</artifactId>
        <version>1.7</version>
        <executions>
          <execution>
            <id>add-benchmark-sources</id>
            <phase>generate-test-sources</phase>

      }
      s.getChars(lastEscape, slen, dest, destIndex);
      destIndex = sizeNeeded;
    }
    return new String(dest, 0, destIndex);
  }

  /**
   * Helper method to grow the character buffer as needed, this only happens once in a while so it's
   * ok if it's in a method call. If the index passed in is 0 then no copying will be done.
   */

     * unable to do so.
     */
    static GetCheckedTypeValidator getBestValidator() {
      return weakSetValidator();
    }
  }

  // TODO(cpovirk): change parameter order to match other helper methods (Class, Throwable)?
  private static <X extends Exception> void wrapAndThrowExceptionOrError(
      Throwable cause, Class<X> exceptionClass) throws X {
    if (cause instanceof Error) {

    return stringOrNull(escaper.escape(cp));
  }

  @CheckForNull
  private static String stringOrNull(@CheckForNull char[] in) {
    return (in == null) ? null : new String(in);
  }

  /** Private helper to wrap a CharEscaper as a UnicodeEscaper. */
  private static UnicodeEscaper wrap(CharEscaper escaper) {
    return new UnicodeEscaper() {
      @Override
      @CheckForNull
      protected char[] escape(int cp) {

      }
    }
  }

  /** Helper method that asserts the arithmetic mean of x and y is equal to the expectedMean. */
  private static void assertMean(long expectedMean, long x, long y) {
    assertEquals(
        "The expectedMean should be the same as computeMeanSafely",
        expectedMean,
        computeMeanSafely(x, y));
    assertMean(x, y);
  }

  /**

        },
        (Multiset<E> multiset) -> copyOfSortedEntries(comparator, multiset.entrySet()));
  }

  @SuppressWarnings({"AndroidJdkLibsChecker", "Java7ApiChecker"})
  @IgnoreJRERequirement // helper for toImmutableSortedMultiset
  /*
   * If we make these calls inline inside toImmutableSortedMultiset, we get an Animal Sniffer error,
   * despite the @IgnoreJRERequirement annotation there. My assumption is that, because javac

      void addEntries(MoreObjects.ToStringHelper helper) {
        helper
            .add(SHORT_NAME, 10)
            .addValue(10L)
            .add(SHORT_NAME, 3.14f)
            .addValue(3.14d)
            .add(LONG_NAME, false)
            .add(LONG_NAME, LONG_NAME);
      }
    },
    CONDITIONAL {
      void addEntries(MoreObjects.ToStringHelper helper) {
        helper
            .add(SHORT_NAME, "x")