*
   * Note about volatile: volatile doesn't make it safe to read from a mutable graph in one thread
   * while writing to it in another. All it does is help with _reading_ from multiple threads
   * concurrently. For more information, see AbstractNetworkTest.concurrentIteration.
   */
  private transient volatile @Nullable Entry<K, V> cacheEntry;

  MapIteratorCache(Map<K, V> backingMap) {

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

/*
Package zip provides support for reading and writing ZIP archives.

See the [ZIP specification] for details.

This package does not support disk spanning.

A note about ZIP64:

To be backwards compatible the FileHeader has both 32 and 64 bit Size

     *            The file channel. Must not be {@literal null}.
     * @param buffer
     *            The byte buffer. Must not be {@literal null}.
     * @param position
     *            The position to start reading from.
     * @return The number of bytes read.
     */
    public static int read(final FileChannel channel, final ByteBuffer buffer, final long position) {
        assertArgumentNotNull("channel", channel);

                                                    <td>${f:h(data.token)}</td>
                                                    <td>${f:h(data.reading)}</td>
                                                </tr>
                                            </c:forEach>
                                            </tbody>
                                        </table>

	stats, err := readStat(statsFile)
	if err != nil {
		return IOStats{}, err
	}
	if len(stats) < 11 {
		return IOStats{}, fmt.Errorf("found invalid format while reading %v", statsFile)
	}
	// refer https://www.kernel.org/doc/Documentation/block/stat.txt
	iostats = IOStats{
		ReadIOs:      stats[0],
		ReadMerges:   stats[1],
		ReadSectors:  stats[2],
		ReadTicks:    stats[3],

		if f, err := os.Open(sessionPolicyFile); err != nil {
			log.Fatalf("Unable to open session policy file %s: %v", sessionPolicyFile, err)
		} else {
			bs, err := io.ReadAll(f)
			if err != nil {
				log.Fatalf("Error reading session policy file: %v", err)
			}
			policy = string(bs)
		}
		ldapOpts = append(ldapOpts, cr.LDAPIdentityPolicyOpt(policy))
	}
	if expiryDuration != 0 {

// simultaneously, but each returned writer will be used only by
// one goroutine at a time.
type Compressor func(w io.Writer) (io.WriteCloser, error)

// A Decompressor returns a new decompressing reader, reading from r.
// The [io.ReadCloser]'s Close method must be used to release associated resources.
// The Decompressor itself must be safe to invoke from multiple goroutines
// simultaneously, but each returned reader will be used only by

	httpStats := newHTTPStats()
	// Simulate the concurrent scenario from the original race condition:
	// Multiple HTTP request handlers updating stats concurrently,
	// while background processes are reading the stats for persistence.
	const numWriters = 100 // Simulate many HTTP request handlers.
	const numReaders = 50  // Simulate background stats readers.
	const opsPerGoroutine = 100

	var wg sync.WaitGroup

            assertTrue(str.contains("allocationSize=4096"));
            assertTrue(str.contains("endOfFile=2048"));
        }
    }

    @Nested
    @DisplayName("Data Reading Tests")
    class DataReadingTests {

        @Test
        @DisplayName("Should read data for basic info level")
        void testReadDataBasicInfo() {
            Trans2QueryPathInformationResponse resp =

        assertArrayEquals(secondData, secondResult);
    }

    @Test
    void testReadDataWireFormatWithOffset() throws SMBProtocolDecodingException {
        // Test reading data from different buffer offsets
        byte[] testData = "Test data with offset".getBytes();
        byte[] buffer = new byte[200];
        int offset = 50;