}
    };
  }

  public void testSkip() throws Exception {
    String begin = "abcde";
    String end = "fghij";
    Reader joinedReader = CharSource.concat(newCharSource(begin), newCharSource(end)).openStream();

    String expected = begin + end;
    assertEquals(expected.charAt(0), joinedReader.read());
    CharStreams.skipFully(joinedReader, 1);

    for (int i = 0; i < IPV4_PART_COUNT; i++) {
      int end = ipString.indexOf(IPV4_DELIMITER, start);
      if (end == -1) {
        end = ipString.length();
      }
      try {
        bytes[i] = parseOctet(ipString, start, end);
      } catch (NumberFormatException ex) {
        return null;
      }
      start = end + 1;
    }

    return bytes;
  }

  @CheckForNull

          return combineBuffers(bufs, totalLen);
        }
        off += r;
        totalLen += r;
      }
    }

    // read MAX_ARRAY_LEN bytes without seeing end of stream
    if (in.read() == -1) {
      // oh, there's the end of the stream
      return combineBuffers(bufs, MAX_ARRAY_LEN);
    } else {
      throw new OutOfMemoryError("input is too large to fit in a byte array");
    }
  }

      return matcher.find(index);
    }

    @Override
    public String replaceAll(String replacement) {
      return matcher.replaceAll(replacement);
    }

    @Override
    public int end() {
      return matcher.end();
    }

    @Override
    public int start() {
      return matcher.start();
    }
  }

  private static final long serialVersionUID = 0;

    }

    // Do *not* override offset() to delegate: We want to test the default implementation.

    @Override
    public long distance(Integer start, Integer end) {
      return DELEGATE.distance(start, end);
    }

    @Override
    public Integer minValue() {
      return DELEGATE.minValue();
    }

    @Override
    public Integer maxValue() {

    return result;
  }

  /**
   * Returns a new array that appends {@code element} to {@code array}.
   *
   * @param array the array of elements to prepend
   * @param element the element to append to the end
   * @return an array whose size is one larger than {@code array}, with the same contents as {@code
   *     array}, plus {@code element} occupying the last position.
   */

        append = true;
      }
      dummy ^= sb.toString().length();
    }
    return dummy;
  }

  /**
   * Starts with an empty delimiter and changes to the desired value at the end of the iteration.
   */
  @Benchmark
  int assignDelimiter(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      StringBuilder sb = new StringBuilder();
      String delim = "";

    expectAdded(getNumElements() / 2, createDisjointCollection());
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAllAtIndex_end() {
    assertTrue(
        "addAll(end, disjoint) should return true",
        getList().addAll(getNumElements(), createDisjointCollection()));
    expectAdded(getNumElements(), createDisjointCollection());
  }

 * into lines. Like {@link BufferedReader}, these methods break lines on any of {@code \n}, {@code
 * \r} or {@code \r\n}, do not include the line separator in each line and do not consider there to
 * be an empty line at the end if the contents are terminated with a line separator.
 *
 * <p>Any {@link ByteSource} containing text encoded with a specific {@linkplain Charset character

    }

    @Override
    public char charAt(int index) {
      return "foo".charAt(index);
    }

    @Override
    public CharSequence subSequence(int start, int end) {
      return "foo".subSequence(start, end);
    }

    @Override
    public String toString() {
      throw new AssertionFailedError("shouldn't be invoked");
    }
  }

  // Don't do this.