TestCharSource okSource = new TestCharSource(STRING);
    assertThrows(IOException.class, () -> okSource.copyTo(new TestWriter(WRITE_THROWS)));
    assertTrue(okSource.wasStreamClosed());
  }

  public void testConcat() throws IOException {
    CharSource c1 = CharSource.wrap("abc");
    CharSource c2 = CharSource.wrap("");
    CharSource c3 = CharSource.wrap("de");

    String expected = "abcde";

    OutputStream out = new TestOutputStream(ByteStreams.nullOutputStream(), WRITE_THROWS);
    assertThrows(IOException.class, () -> okSource.copyTo(out));
    assertTrue(okSource.wasStreamClosed());
  }

  public void testConcat() throws IOException {
    ByteSource b1 = ByteSource.wrap(new byte[] {0, 1, 2, 3});
    ByteSource b2 = ByteSource.wrap(new byte[0]);
    ByteSource b3 = ByteSource.wrap(new byte[] {4, 5});

    assertThat(Bytes.lastIndexOf(ARRAY234, (byte) 4)).isEqualTo(2);
    assertThat(Bytes.lastIndexOf(new byte[] {(byte) 2, (byte) 3, (byte) 2, (byte) 3}, (byte) 3))
        .isEqualTo(3);
  }

  public void testConcat() {
    assertThat(Bytes.concat()).isEqualTo(EMPTY);
    assertThat(Bytes.concat(EMPTY)).isEqualTo(EMPTY);
    assertThat(Bytes.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY);

    assertThat(Booleans.lastIndexOf(ARRAY_FALSE_TRUE, true)).isEqualTo(1);
    assertThat(Booleans.lastIndexOf(new boolean[] {false, true, true}, true)).isEqualTo(2);
  }

  public void testConcat() {
    assertThat(Booleans.concat()).isEqualTo(EMPTY);
    assertThat(Booleans.concat(EMPTY)).isEqualTo(EMPTY);
    assertThat(Booleans.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY);

    try {
      Chars.constrainToRange((char) 1, (char) 3, (char) 2);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testConcat() {
    assertThat(Chars.concat()).isEqualTo(EMPTY);
    assertThat(Chars.concat(EMPTY)).isEqualTo(EMPTY);
    assertThat(Chars.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY);

    assertThat(Booleans.lastIndexOf(ARRAY_FALSE_TRUE, true)).isEqualTo(1);
    assertThat(Booleans.lastIndexOf(new boolean[] {false, true, true}, true)).isEqualTo(2);
  }

  public void testConcat() {
    assertThat(Booleans.concat()).isEqualTo(EMPTY);
    assertThat(Booleans.concat(EMPTY)).isEqualTo(EMPTY);
    assertThat(Booleans.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY);

    try {
      Shorts.constrainToRange((short) 1, (short) 3, (short) 2);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testConcat() {
    assertThat(Shorts.concat()).isEqualTo(EMPTY);
    assertThat(Shorts.concat(EMPTY)).isEqualTo(EMPTY);
    assertThat(Shorts.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY);

    try {
      Longs.constrainToRange((long) 1, (long) 3, (long) 2);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testConcat() {
    assertThat(Longs.concat()).isEqualTo(EMPTY);
    assertThat(Longs.concat(EMPTY)).isEqualTo(EMPTY);
    assertThat(Longs.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY);

    try {
      Doubles.constrainToRange((double) 1, (double) 3, (double) 2);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testConcat() {
    assertThat(Doubles.concat()).isEqualTo(EMPTY);
    assertThat(Doubles.concat(EMPTY)).isEqualTo(EMPTY);
    assertThat(Doubles.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY);

    try {
      Ints.constrainToRange((int) 1, (int) 3, (int) 2);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testConcat() {
    assertThat(Ints.concat()).isEqualTo(EMPTY);
    assertThat(Ints.concat(EMPTY)).isEqualTo(EMPTY);
    assertThat(Ints.concat(EMPTY, EMPTY, EMPTY)).isEqualTo(EMPTY);