Smb2EncryptionContext context = new Smb2EncryptionContext(EncryptionNegotiateContext.CIPHER_AES128_GCM, DialectVersion.SMB311,
                encKey, decKey, sessionKey, preauthHash);

        // When - Set very low rotation limits to trigger rotation
        context.setKeyRotationBytesLimit(100); // Rotate after 100 bytes

        // Encrypt first message - should work
        byte[] plaintext1 = "Message before rotation".getBytes();

        // Verify content
        assertEquals(SmbComTransaction.TRANS2_QUERY_FS_INFORMATION, buffer[0]);
        assertEquals(0x00, buffer[1]);
        assertEquals(0x03, buffer[2]); // Low byte of 0x0103
        assertEquals(0x01, buffer[3]); // High byte of 0x0103
    }

    @DisplayName("Test toString with different information levels")
    @ParameterizedTest

   * Shortcut for {@code newHasher().putUnencodedChars(input).hash()}. The implementation
   * <i>might</i> perform better than its longhand equivalent, but should not perform worse. Note
   * that no character encoding is performed; the low byte and high byte of each {@code char} are
   * hashed directly (in that order).
   *
   * <p><b>Warning:</b> This method will produce different output than most other languages do when

   * Shortcut for {@code newHasher().putUnencodedChars(input).hash()}. The implementation
   * <i>might</i> perform better than its longhand equivalent, but should not perform worse. Note
   * that no character encoding is performed; the low byte and high byte of each {@code char} are
   * hashed directly (in that order).
   *
   * <p><b>Warning:</b> This method will produce different output than most other languages do when

					StorageClass: "TIER-1",
				},
			},
			{
				ID:     "rule-2",
				Status: "Enabled",
				Filter: Filter{
					tagSet: true,
					Tag: Tag{
						Key:   "priority",
						Value: "low",
					},
				},
				Transition: Transition{
					Days:         TransitionDays(3),
					StorageClass: "TIER-2",
				},
			},
		},
	}

	now := time.Now().UTC()

            byte[] testBytes = Strings.getUNIBytes("Test");
            System.arraycopy(testBytes, 0, buffer, 0, 8);
            buffer[8] = 0; // null terminator low byte
            buffer[9] = 0; // null terminator high byte

            String result = testBlock.readString(buffer, 0, buffer.length, 8, true);

            assertEquals("Test", result);
        }
    }

   * of values that will be added, if that knowledge is readily available. It is better to guess a
   * value slightly too high than slightly too low. If the value is not exact, the {@link
   * ImmutableLongArray} that is built will very likely occupy more memory than strictly necessary;
   * to trim memory usage, build using {@code builder.build().trimmed()}.
   */

   * of values that will be added, if that knowledge is readily available. It is better to guess a
   * value slightly too high than slightly too low. If the value is not exact, the {@link
   * ImmutableIntArray} that is built will very likely occupy more memory than strictly necessary;
   * to trim memory usage, build using {@code builder.build().trimmed()}.
   */

        // Prepare buffer with specific type value
        testBuffer[0] = 0x01; // revision
        testBuffer[1] = 0x00; // padding
        testBuffer[2] = 0x04; // type low byte
        testBuffer[3] = (byte) 0x80; // type high byte (0x8004)
        // Set all offsets to 0
        for (int i = 4; i < 20; i++) {
            testBuffer[i] = 0;
        }

register, even on architectures with a hardware frame pointer.
</p>

<p>
For assembly functions with Go prototypes, <code>go</code> <code>vet</code> will check that the argument names
and offsets match.
On 32-bit systems, the low and high 32 bits of a 64-bit value are distinguished by adding
a <code>_lo</code> or <code>_hi</code> suffix to the name, as in <code>arg_lo+0(FP)</code> or <code>arg_hi+4(FP)</code>.