resourceMetricsMapMu.Lock()
	defer resourceMetricsMapMu.Unlock()
	subsysMetrics, found := resourceMetricsMap[subSys]
	if !found {
		subsysMetrics = ResourceMetrics{}
	}

	key := getResourceKey(name, labels)
	metric, found := subsysMetrics[key]
	if !found {
		metric = ResourceMetric{
			Name:   name,
			Labels: labels,
		}
	}

	if isCumulative {

            assertTrue(result.length > 0, "Result should not be empty");

            // Verify round-trip conversion
            String roundTrip = new String(result, StandardCharsets.UTF_16LE);
            assertEquals(UNICODE_STRING, roundTrip, "Round-trip conversion should preserve Unicode");
        }

        @Test
        @DisplayName("getASCIIBytes should encode string as ASCII")

        assertArrayEquals(mechs, parsed.getMechanisms(), "Mechanism OIDs should round-trip");
        assertEquals(flags, parsed.getContextFlags(), "Flags should round-trip");
        assertArrayEquals(mechToken, parsed.getMechanismToken(), "Mechanism token should round-trip");
        assertArrayEquals(mic, parsed.getMechanismListMIC(), "MIC should round-trip");

        assertTrue(parsed.getContextFlag(NegTokenInit.DELEGATION));

							if !ok || err != nil {
								t.Fatal("failed:", err, ok)
							}
						}
					}
					start := time.Now()
					l.expireOldLocks(time.Hour)
					t.Logf("Scan Took: %v. Left: %d/%d", time.Since(start).Round(time.Millisecond), len(l.lockUID), len(l.lockMap))
					if len(l.lockMap) != locks {
						t.Fatalf("objects deleted, want %d != got %d", locks, len(l.lockMap))
					}
					if len(l.lockUID) != locks*readers {

            verify(mockBuffer).dec_ndr_short();
            assertEquals(largeValue, ndrShort.value);
        }
    }

    @Nested
    @DisplayName("Round-trip Tests")
    class RoundTripTests {

        @Test
        @DisplayName("Should handle encode-decode round-trip correctly")
        void testEncodeDecodeRoundTrip() throws NdrException {
            // Given: Original value that fits in byte range

          // Four byte characters
          FOUR_BYTE_ROUNDTRIPPABLE_CHARACTERS;

  /** Tests that round tripping of all two byte permutations work. */
  @GwtIncompatible // java.nio.charset.Charset
  public void testIsWellFormed_1Byte() {
    testBytes(1, EXPECTED_ONE_BYTE_ROUNDTRIPPABLE_COUNT);
  }

  /** Tests that round tripping of all two byte permutations work. */
  @GwtIncompatible // java.nio.charset.Charset

        assertTrue(str.contains("EndOfFileInformation"));
        assertTrue(str.contains("1024"));
    }

    /**
     * Test FileEndOfFileInformation encode/decode round trip
     */
    @Test
    @DisplayName("Test FileEndOfFileInformation encode/decode round trip")
    void testFileEndOfFileInformationEncodeDecodeRoundTrip() throws SMBProtocolDecodingException {
        long originalValue = 0x123456789ABCDEFL;

        right = right << 1 | right >>> 31 & 1;

        work = (leftt ^ right) & 0xaaaaaaaa;
        leftt ^= work;
        right ^= work;
        leftt = leftt << 1 | leftt >>> 31 & 1;

        for (round = 0; round < 8; ++round) {
            work = right << 28 | right >>> 4;
            work ^= keys[keysi];
            keysi++;
            fval = SP7[work & 0x0000003f];
            fval |= SP5[work >>> 8 & 0x0000003f];

        int bytesRead = info.decode(buffer, startIndex, buffer.length - startIndex);

        assertEquals(20 + nameBytes.length, bytesRead);
    }

    @Test
    @DisplayName("Test encode and decode round trip")
    void testEncodeDecodeRoundTrip() throws SMBProtocolDecodingException {
        String fileName = "roundtrip_test.txt";
        boolean replaceIfExists = true;

	// All times are rounded to avoid showing milli, micro and nano seconds
	formatStartTime := time.Now().Round(time.Second)
	getElapsedTime := func() string {
		return time.Now().Round(time.Second).Sub(formatStartTime).String()
	}

	var (
		tries   int
		verbose bool
	)

	// Initialize all storage disks