assertEquals(underlying.size(), map.size());
    assertFalse(map.containsKey("c"));

    underlying.clear();
    assertEquals(underlying.size(), map.size());
  }

  public void testTransformChangesAreReflectedInUnderlyingMap() {
    Map<String, Integer> underlying = new LinkedHashMap<>();
    underlying.put("a", 1);
    underlying.put("b", 2);
    underlying.put("c", 3);
    underlying.put("d", 4);

    assertEquals(underlying.size(), map.size());
    assertFalse(map.containsKey("c"));

    underlying.clear();
    assertEquals(underlying.size(), map.size());
  }

  public void testTransformChangesAreReflectedInUnderlyingMap() {
    Map<String, Integer> underlying = new LinkedHashMap<>();
    underlying.put("a", 1);
    underlying.put("b", 2);
    underlying.put("c", 3);
    underlying.put("d", 4);

  }

  @Override
  protected Map<String, String> makePopulatedMap() {
    Map<String, Integer> underlying = new HashMap<>();
    underlying.put("a", 1);
    underlying.put("b", 2);
    underlying.put("c", 3);
    return transformValues(underlying, Functions.toStringFunction());
  }

    }

    @Override
    public void addInclude(String include) {
        // Update the underlying Resource model
        super.addInclude(include);

        // Update the project's SourceRoots
        updateProjectSourceRoot();
    }

    @Override
    public void removeInclude(String include) {
        // Update the underlying Resource model
        super.removeInclude(include);

        // Update the project's SourceRoots

    assertEquals(underlying.size(), map.size());
    assertFalse(map.containsKey("c"));

    underlying.clear();
    assertEquals(underlying.size(), map.size());
  }

  public void testTransformChangesAreReflectedInUnderlyingMap() {
    Map<String, Integer> underlying = new LinkedHashMap<>();
    underlying.put("a", 1);
    underlying.put("b", 2);
    underlying.put("c", 3);
    underlying.put("d", 4);

  }

  @Override
  protected Map<String, String> makePopulatedMap() {
    Map<String, Integer> underlying = new HashMap<>();
    underlying.put("a", 1);
    underlying.put("b", 2);
    underlying.put("c", 3);
    return transformValues(underlying, Functions.toStringFunction());
  }

	g := errgroup.WithNErrs(len(localDrives))

	// Disk states slices
	beforeState := make([]string, len(localDrives))
	afterState := make([]string, len(localDrives))

	// Make a volume entry on all underlying storage disks.
	for index := range localDrives {
		g.Go(func() (serr error) {
			if localDrives[index] == nil {
				beforeState[index] = madmin.DriveStateOffline
				afterState[index] = madmin.DriveStateOffline

type DecoderError struct {
	msg       string // description of error
	context   string // additional error context
	pos       errPos
	atChar    byte
	readerErr error // underlying reader error, if any
}

// ReaderErr returns the underlying error.
func (e DecoderError) ReaderErr() error { return e.readerErr }

// Error returns a string representation of the error.
func (e DecoderError) Error() string {

        // Assert
        // Verify that data was written to the underlying stream through CacheStream
        verify(initialOutputStream).write(testData);
        verify(initialOutputStream).flush();
        verify(initialOutputStream).close();
    }

    /**
     * Test that a RuntimeCIFSException is thrown when the handshake fails due to an underlying exception.
     * @throws IOException
     */
    @Test

        assertEquals('s', stream.read());
        assertEquals('t', stream.read());
    }

    public void test_read_delegatesToUnderlying() throws IOException {
        // Test that read() delegates to underlying stream
        byte[] data = "ABC".getBytes();
        InputStream underlyingStream = new ByteArrayInputStream(data);
        IgnoreCloseInputStream stream = new IgnoreCloseInputStream(underlyingStream);