}

    @Test
    @DisplayName("Constructor should initialize TransPeekNamedPipeResponse")
    void testConstructor() {
        // Assert
        assertNotNull(response);
        assertTrue(response instanceof SmbComTransactionResponse);
        assertEquals(0, response.getAvailable());
    }

    @Test
    @DisplayName("Should verify status constants are correctly defined")
    void testStatusConstants() {

        assertNotNull(encryptedStr, "Encrypted string should not be null");
        assertFalse(encryptedStr.contains("TestPassword456"), "Plaintext should not be visible in encrypted string");

        // Should be valid base64
        assertTrue(encryptedStr.matches("^[A-Za-z0-9+/]*={0,2}$"), "Should be valid Base64 format");

        // Decrypt from string

	} else if user.ID == 0 {
		t.Fatalf("user's primary value should not zero, %v", user.ID)
	} else if user.UpdatedAt.IsZero() {
		t.Fatalf("user's updated at should not zero, %v", user.UpdatedAt)
	}
	lastUpdatedAt = user.UpdatedAt

	if err := DB.Model(user).Update("Age", 10).Error; err != nil {
		t.Errorf("errors happened when update: %v", err)
	} else if user.Age != 10 {
		t.Errorf("Age should equals to 10, but got %v", user.Age)
	}

            assertTrue(completed, "All verify operations should complete");
            assertEquals(threadCount * operationsPerThread, completedVerifies.get(), "All verifies should complete");

            // Performance check - should complete reasonably fast with optimized locking
            long duration = endTime - startTime;
            assertTrue(duration < 5000, "Concurrent verifies should complete within 5 seconds");
        }
    }

		t.Fatalf("Scan into struct should work, got %#v, should %#v", res, user3)
	}

	DB.Table("users").Select("id, name, age").Where("id = ?", user2.ID).Scan(&res)
	if res.ID != user2.ID || res.Name != user2.Name || res.Age != int(user2.Age) {
		t.Fatalf("Scan into struct should work, got %#v, should %#v", res, user2)
	}

            int modifiers = field.getModifiers();
            assertTrue(Modifier.isPublic(modifiers), "Field " + field.getName() + " should be public");
            assertTrue(Modifier.isStatic(modifiers), "Field " + field.getName() + " should be static");
            assertTrue(Modifier.isFinal(modifiers), "Field " + field.getName() + " should be final");
        }
    }

    @Test
    @DisplayName("Test constant values are unique")

        assertTrue(DialectVersion.SMB302.compareTo(DialectVersion.SMB311) < 0);
    }

    @Test
    @DisplayName("Should identify SMB1 vs SMB2+ versions")
    void testSMBVersionIdentification() {
        // SMB1 should not be SMB2
        assertFalse(DialectVersion.SMB1.isSMB2());

        // SMB2+ versions should be identified as SMB2
        assertTrue(DialectVersion.SMB202.isSMB2());
        assertTrue(DialectVersion.SMB210.isSMB2());

        assertFalse(file.exists(), "File should not exist initially");

        file.createNewFile();
        assertTrue(file.exists(), "File should exist after creation");
        assertTrue(file.isFile(), "Should be identified as a file");
        assertFalse(file.isDirectory(), "Should not be identified as a directory");
        assertEquals(0, file.length(), "New file should have zero length");
    }

    @Test

        assertEquals(2, trans.maxParameterCount, "The maxParameterCount should be 2.");
        assertEquals(40, trans.maxDataCount, "The maxDataCount should be 40.");
        assertEquals((byte) 0x00, trans.maxSetupCount, "The maxSetupCount should be 0.");
    }

    /**
     * Tests the writeSetupWireFormat method.
     */
    @Test
    void testWriteSetupWireFormat() {
        // Given

    @DisplayName("Constructor with null pipe name should handle gracefully")
    void testConstructorWithNullPipeName() {
        // Act
        transWaitNamedPipe = new TransWaitNamedPipe(mockConfig, null);

        // Assert
        assertNotNull(transWaitNamedPipe);
        assertNull(transWaitNamedPipe.name);
    }

    @Test
    @DisplayName("Constructor with empty pipe name should handle gracefully")