override fun obtain(): String? = parameters.run {
        if (enableConfigurationCacheForDocsTests.getOrElse(false)) {
            // If the CC is enabled for docs tests, use a static dummy timestamp (the Epoch) so that we get hits,
            // otherwise we'll use the current timestamp by default and miss
            val formatter = SimpleDateFormat("yyyyMMddHHmmssZ").apply {
                timeZone = TimeZone.getTimeZone("UTC")
            }

			PauseEnd:   gcStats.PauseEnd,
		},
		MinioEnvVars: make(map[string]string, 10),
	}

	for poolNumber := range poolNumbers {
		props.PoolNumbers = append(props.PoolNumbers, poolNumber)
	}
	sort.Ints(props.PoolNumbers)
	props.PoolNumber = func() int {
		if len(props.PoolNumbers) == 1 {
			return props.PoolNumbers[0]
		}
		return math.MaxInt // this indicates that its unset.
	}()

        // Verify watchTree flag is set to 0x01
        assertEquals(0x01, dst[dstIndex + 6]);
    }

    @ParameterizedTest
    @DisplayName("Test writeSetupWireFormat with various FID values")
    @ValueSource(ints = { 0x0000, 0x0001, 0x7FFF, 0xFFFF, 0x1234, 0xABCD })
    void testWriteSetupWireFormatWithVariousFids(int fid) {
        notifyChange = new NtTransNotifyChange(mockConfig, fid, FILE_NOTIFY_CHANGE_FILE_NAME, false);

//
// floating point conditional branch
//
//	LBRA rel
label4:
	BFPT	1(PC)	// BFPT 1(PC)			// 4501000100000000
	BFPT	label4	// BFPT 24			// 4501fffd00000000

//inst:
//
// load ints and bytes
//
//	LMOVV rreg ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVV	R25, R17	// 00198825
	MOVV	R1, R2		// 00011025
	MOVV	LO, R1		// 00000812
	MOVV	HI, R1		// 00000810

    private final AtomicLong changeNotifications = new AtomicLong();
    
    public double getCacheHitRatio() {
        long hits = cacheHits.get();
        long misses = cacheMisses.get();
        long total = hits + misses;
        
        if (total == 0) return 0.0;
        return (double) hits / total;
    }
    
    public void recordCacheHit() { cacheHits.incrementAndGet(); }

        K castKey = (K) key;
        result.put(castKey, value);
        hits++;
      }
    }
    globalStatsCounter.recordHits(hits);
    globalStatsCounter.recordMisses(misses);
    return result.buildKeepingLast();
  }

  ImmutableMap<K, V> getAll(Iterable<? extends K> keys) throws ExecutionException {
    int hits = 0;
    int misses = 0;

    Map<K, V> result = new LinkedHashMap<>();

                        request.setReadLength(r);

                        // Optimization: Set remaining bytes hint for server read-ahead
                        request.setRemainingBytes(Math.min(len - r, 1024 * 1024)); // Hint up to 1MB for read-ahead

                        try {
                            final Smb2ReadResponse resp = th.send(request, RequestParam.NO_RETRY);

   *
   * @since 10.0
   */
  public interface StatsCounter {
    /**
     * Records cache hits. This should be called when a cache request returns a cached value.
     *
     * @param count the number of hits to record
     * @since 11.0
     */
    void recordHits(int count);

    /**

    void decodesSrvCopyChunkCopyResponse() throws Exception {
        // Validate createOutputDecodable() mapping and Decodable decode
        byte[] header = buildHeader(NtStatus.NT_STATUS_SUCCESS);

        // Prepare 3 ints: chunksWritten=1, chunkBytesWritten=2, totalBytesWritten=3
        byte[] out = new byte[12];
        SMBUtil.writeInt4(1, out, 0);
        SMBUtil.writeInt4(2, out, 4);
        SMBUtil.writeInt4(3, out, 8);

            assertDoesNotThrow(() -> request.setData(emptyData, 0, 0));
        }

        @ParameterizedTest
        @DisplayName("Should handle various data sizes")
        @ValueSource(ints = { 0, 1, 100, 1024, 4096, 65536, 1048576 })
        void testVariousDataSizes(int size) {
            byte[] data = new byte[size];
            assertDoesNotThrow(() -> request.setData(data, 0, size));
        }