assertNotNull(expanded);
        assertEquals(outlen, expanded.length);

        // Test vectors from RFC 3961 Appendix A.1
        // 64-fold("012345")
        verifyNfold("012345", 8,
                new byte[] { (byte) 0xbe, (byte) 0x07, (byte) 0x26, (byte) 0x31, (byte) 0x27, (byte) 0x6b, (byte) 0x19, (byte) 0x55 });

        // 56-fold("password")
        verifyNfold("password", 7,

    assertPermutationsCount(6, Collections2.permutations(newArrayList(1, 2, 3)));
    assertPermutationsCount(5040, Collections2.permutations(newArrayList(1, 2, 3, 4, 5, 6, 7)));
    assertPermutationsCount(40320, Collections2.permutations(newArrayList(1, 2, 3, 4, 5, 6, 7, 8)));
  }

  public void testPermutationSetSizeOverflow() {
    // 13 elements overflow an int
    assertEquals(
        Integer.MAX_VALUE,

     */
    @Test
    @DisplayName("Decode single AvPair with EOL")
    void testDecodeSinglePair() throws CIFSException {
        // Create test data: AvFlags with value 0x12345678 + EOL
        byte[] flagData = new byte[4];
        SMBUtil.writeInt4(0x12345678, flagData, 0);
        byte[] avPairData = createAvPairData(AvPair.MsvAvFlags, flagData);
        byte[] eolData = createEolData();

 */
@NullUnmarked
public class AbstractByteHasherTest extends TestCase {

  public void testBytes() {
    TestHasher hasher = new TestHasher(); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    hasher.putByte((byte) 1);
    hasher.putBytes(new byte[] {2, 3, 4, 5, 6});
    hasher.putByte((byte) 7);
    hasher.putBytes(new byte[] {});
    hasher.putBytes(new byte[] {8});

                response.dataLength = 10;
                // Copy data to the buffer that was passed in the response constructor
                byte[] testData = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
                System.arraycopy(testData, 0, response.b, response.off, testData.length);
                return null;
            }

    assertEquals("1.001 \u03bcs", stopwatch.toString());
    ticker.advance(8998);
    assertEquals("9.999 \u03bcs", stopwatch.toString());
    stopwatch.reset();
    stopwatch.start();
    ticker.advance(1234567);
    assertEquals("1.235 ms", stopwatch.toString());
    stopwatch.reset();
    stopwatch.start();
    ticker.advance(5000000000L);
    assertEquals("5.000 s", stopwatch.toString());
    stopwatch.reset();

        assertEquals(0x12, buffer[1] & 0xFF);
    }

    @Test
    @DisplayName("Should encode and decode 32-bit integers")
    void testInt32Operations() {
        // Given
        int value = 0x12345678;
        byte[] buffer = new byte[4];

        // When - encode little endian
        Encdec.enc_uint32le(value, buffer, 0);
        long decoded = Encdec.dec_uint32le(buffer, 0);

        // Then

  public enum SampleMatcherConfig {
    WHITESPACE(CharMatcher.whitespace(), WHITESPACE_CHARACTERS),
    HASH(CharMatcher.is('#'), "#"),
    ASCII(CharMatcher.ascii(), ASCII_CHARACTERS),
    WESTERN_DIGIT("0123456789"),
    ALL_DIGIT(CharMatcher.digit(), ALL_DIGITS),
    OPS_5("+-*/%"),
    HEX_16(CharMatcher.inRange('0', '9').or(CharMatcher.inRange('A', 'F')), "0123456789ABCDEF"),
    HEX_22(
        CharMatcher.inRange('0', '9')

    public void testContextWithFlags() {
        CompressionNegotiateContext contextWithFlags =
                new CompressionNegotiateContext(config, new int[] { CompressionNegotiateContext.COMPRESSION_LZ77 }, 0x12345678);

        assertEquals(0x12345678, contextWithFlags.getFlags());
    }

    @Test
    @DisplayName("Test toString representation")
    public void testToString() {
        String str = context.toString();

		t.Errorf("Failed to generate sql, got %v", sql)
	}

	stmt = dryRunDB.Model(&user).Where("id = ?", 1).Updates(map[string]interface{}{"age": ageFloat(0.12345678)}).Statement
	sql = DB.Dialector.Explain(stmt.SQL.String(), stmt.Vars...)
	if !regexp.MustCompile(`.*age.*=0.123457,`).MatchString(sql) {
		t.Errorf("Failed to generate sql, got %v", sql)
	}
}

func TestGroupConditions(t *testing.T) {
	type Pizza struct {