return
				}
			}
		case "InMemory":
			if dc.IsNil() {
				err = dc.ReadNil()
				if err != nil {
					err = msgp.WrapError(err, "InMemory")
					return
				}
				z.InMemory = nil
			} else {
				if z.InMemory == nil {
					z.InMemory = new(bool)
				}
				*z.InMemory, err = dc.ReadBool()
				if err != nil {
					err = msgp.WrapError(err, "InMemory")
					return
				}
			}

        ContentOutputStream cos = new ContentOutputStream(10, Curl.tmpDir);
        cos.write(new byte[] { 0, 1, 2 });
        assertTrue(cos.isInMemory());
        cos.write(new byte[] { 3, 4 });
        assertTrue(cos.isInMemory());
        cos.write(new byte[] { 5 });
        assertTrue(cos.isInMemory());
        assertFalse(cos.done);
        cos.close();
    }

    @Test

        }
    }

    // --- isInMemory() tests ---

    @Test
    public void testIsInMemory_WithByteArray() {
        // ## Arrange ##
        ContentCache cache = new ContentCache("test".getBytes());

        // ## Assert ##
        assertTrue(cache.isInMemory());
    }

    @Test
    public void testIsInMemory_WithFile() throws IOException {

                }
                dfos.flush();
                final ContentCache contentCache;
                logger.fine(() -> "Response in " + (dfos.isInMemory() ? "Memory" : "File"));
                if (dfos.isInMemory()) {
                    contentCache = new ContentCache(dfos.getData());
                } else {
                    contentCache = new ContentCache(dfos.getFile());
                }

        public long used;
        /** Committed non-heap memory in bytes */
        public long committed;
        /** Maximum non-heap memory in bytes */
        public long max;
        /** The percentage of non-heap memory usage. */
        public short percent;
    }

    /**
     * Data transfer object representing JVM buffer pool statistics.
     */

## 1. Overview

SMB Direct enables high-performance data transfer using Remote Direct Memory Access (RDMA) technology. This provides ultra-low latency and high bandwidth data transfer by bypassing the traditional TCP/IP stack and allowing direct memory-to-memory transfers between client and server.

## 2. Protocol Specification Reference

- **MS-SMBD**: SMB2 Remote Direct Memory Access (RDMA) Transport Protocol

        // requireNonNull is safe because we always have either `file` or `memory`.
        requireNonNull(memory);
        return new ByteArrayInputStream(memory.getBuffer(), 0, memory.getCount());
      }
    }

    synchronized void reset() throws IOException {
      try {
        close();
      } finally {
        if (memory == null) {
          memory = new MemoryOutput();
        } else {
          memory.reset();

<p>
Go approaches its memory model in much the same way as the rest of the language,
aiming to keep the semantics simple, understandable, and useful.
This section gives a general overview of the approach and should suffice for most programmers.
The memory model is specified more formally in the next section.
</p>

<p>
A data race is defined as

| `minio_node_mem_buffers_avg`   | Buffers memory on the node (avg).         |
| `minio_node_mem_buffers_max`   | Buffers memory on the node (max).         |
| `minio_node_mem_cache`         | Cache memory on the node.                 |
| `minio_node_mem_cache_avg`     | Cache memory on the node (avg).           |
| `minio_node_mem_cache_max`     | Cache memory on the node (max).           |

### Memory per Process { #memory-per-process }

Now, when the program loads things in memory, for example, a machine learning model in a variable, or the contents of a large file in a variable, all that **consumes a bit of the memory (RAM)** of the server.