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
    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);

	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

        // 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);

	var j JSON[T]
	j.p = p
	j.val = val
	return &j
}

// Value returns the underlying value.
// If not set yet, a new value is created.
func (j *JSON[T]) Value() *T {
	if j.val == nil {
		j.val = j.p.new()
	}
	return j.val
}

// ValueOrZero returns the underlying value.
// If the underlying value is nil, a zero value is returned.
func (j *JSON[T]) ValueOrZero() T {

        when(smbPipeHandle.getOutput()).thenReturn(mockOutputStream);
    }

    /**
     * Tests that the getter for the underlying pipe resource returns the correct instance.
     */
    @Test
    public void testGetPipe() {
        assertEquals(mockPipeResource, smbPipeHandle.getPipe(), "getPipe() should return the underlying pipe resource.");
    }

    /**
     * Tests that the getter for the input stream returns the correct stream.

    /**
     * Gets the send buffer size of the underlying SMB connection
     * @return the send buffer size of the underlying connection
     * @throws CIFSException if an error occurs retrieving the buffer size
     */
    int getSendBufferSize() throws CIFSException;

    /**
     * Gets the receive buffer size of the underlying SMB connection
     * @return the receive buffer size of the underlying connection