assertNotNull(bindWithParams, "Constructor should create instance");
            assertEquals(0, bindWithParams.getOpnum(), "Opnum should be 0");
            assertEquals(11, bindWithParams.getPtype(), "Ptype should be 11 for bind message");
            assertEquals(DcerpcConstants.DCERPC_FIRST_FRAG | DcerpcConstants.DCERPC_LAST_FRAG, bindWithParams.getFlags(),
                    "Flags should be set for first and last fragment");

        // Verify the AvPair type is MsvAvTargetName
        assertEquals(AvPair.MsvAvTargetName, avTargetName.getType(), "AvPair type should be MsvAvTargetName");
        // Verify the raw bytes are correctly stored
        assertArrayEquals(rawBytes, avTargetName.getRaw(), "Raw bytes should match the input");
    }

    /**
     * Test constructor with a target name string.

        assertNotNull(request);
        // The request should be properly created - we can't easily verify headers without mocking framework
    }

    public void test_post() {
        setupMockConfig("localhost:9200", "", "");

        curlHelper.init();
        CurlRequest request = curlHelper.post("/test");

        assertNotNull(request);
        // The request should be properly created
    }

    public void test_put() {

		t.Errorf(fmt.Sprintf("Count should work, but got err %v", err))
	}
	if count1 != 1 {
		t.Errorf("Count with group should be 1, but got count: %v", count1)
	}

	var count2 int64
	if err := DB.Model(&Company{}).Where("name in ?", []string{"company_count_group_b", "company_count_group_c"}).Group("name").Count(&count2).Error; err != nil {
		t.Errorf(fmt.Sprintf("Count should work, but got err %v", err))
	}
	if count2 != 2 {

        response.setDataCount(5);

        // With 0 entries, should return dataCount
        int result = response.readDataWireFormat(buffer, 0, 0);
        // Should return dataCount
        assertEquals(5, result);
    }

    @Test
    void testGetSid() {
        // Test the getSid method
        // By default, it should be 0
        assertEquals(0, response.getSid());
    }

    @Test

    }

    @Test
    void testNtlmNegotiateOem() {
        assertEquals(0x00000002, NtlmFlags.NTLMSSP_NEGOTIATE_OEM, "NTLMSSP_NEGOTIATE_OEM should be 0x00000002");
    }

    @Test
    void testNtlmRequestTarget() {
        assertEquals(0x00000004, NtlmFlags.NTLMSSP_REQUEST_TARGET, "NTLMSSP_REQUEST_TARGET should be 0x00000004");
    }

    @Test

        }

        @Test
        @DisplayName("Should throw exception on null buffer")
        void testEncodeWithNullBuffer() {
            assertThrows(IllegalArgumentException.class, () -> testRequest.encode(null, 0), "Should throw exception for null buffer");
        }

        @Test
        @DisplayName("Should throw exception on negative index")
        void testEncodeWithNegativeIndex() {

     * IllegalArgumentException, since the call could succeed with a different argument. Those
     * exceptions' docs suggest that either is acceptable. Google's Java Practices page recommends
     * IllegalArgumentException here, in part to keep its recommendation simple: Static methods
     * should throw IllegalStateException only when they use static state.
     *

        }

        @Test
        @DisplayName("Should create instance with null ciphers")
        void testConstructorWithNullCiphers() {
            EncryptionNegotiateContext context = new EncryptionNegotiateContext(mockConfig, null);

            assertNotNull(context);
            assertNull(context.getCiphers());
        }

        @Test
        @DisplayName("Should create instance with empty ciphers array")

        }

        @Test
        @DisplayName("Should initialize DfsReferralResponseBuffer")
        void testDfsResponseBufferInitialization() {
            assertNotNull(response.getDfsResponse());
            assertTrue(response.getDfsResponse() instanceof DfsReferralResponseBuffer);
        }

        @Test
        @DisplayName("Should throw NullPointerException with null configuration")