return 6; // NbtAddress is 6 bytes
        }
    }

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        packet = new TestNameServicePacket(mockConfig);
        packet.questionName = mockQuestionName;
        packet.recordName = mockRecordName;
    }

    @Test
    void testWriteInt2() {
        byte[] dst = new byte[2];
        NameServicePacket.writeInt2(0x1234, dst, 0);

    private static final String ALGORITHM_NAME = "AES-256-GCM";

    @Test
    @DisplayName("Default constructor should create exception with null message and cause")
    void testDefaultConstructor() {
        // Given & When
        CIFSUnsupportedCryptoException exception = new CIFSUnsupportedCryptoException();

        // Then

                        + "you should define versions in pluginManagement section of your pom.xml or parent");
    }

    @Test
    void testHandleBuildError() throws Exception {}

    @Test
    void testAttachToThread() throws Exception {}

    @Test
    void testGetKey() throws Exception {}

    public BuilderCommon getBuilderCommon(Logger logger) {

    private SmbTransport smbTransport;

    @Mock
    private CIFSContext cifsContext;

    @Mock
    private Address remoteAddress;

    @BeforeEach
    void setUp() {
        // Common setup for mocks if needed
    }

    @Test
    void testGetContext() {
        // Arrange
        when(smbTransport.getContext()).thenReturn(cifsContext);

        // Act
        CIFSContext result = smbTransport.getContext();

        @Override
        public void encode(final NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(length);
            _dst.enc_ndr_short(impersonation_level);
            _dst.enc_ndr_small(context_mode);
            _dst.enc_ndr_small(effective_only);

        }

        @Override
        public void decode(final NdrBuffer _src) throws NdrException {

        runner.ensureYellow();
        client = runner.client();
    }

    @AfterClass
    public static void afterClass() throws Exception {
        runner.close();
        runner.clean();
    }

    @Before
    public void before() throws Exception {
        // Delete test indices and settings indices for complete cleanup
        try {

    private SmbTransportImpl mockTransport;
    private Configuration mockConfig;
    private Credentials mockCredentials;
    private CredentialsInternal mockCredentialsInternal;

    @BeforeEach
    public void setUp() {
        mockContext = Mockito.mock(CIFSContext.class);
        mockTransport = Mockito.mock(SmbTransportImpl.class);
        mockConfig = Mockito.mock(Configuration.class);

  }

  @Test
  public void equivalent_nodeSetsDiffer() {
    graph.addNode(N1);

    MutableGraph<Integer> g2 = createGraph(edgeType);
    g2.addNode(N2);

    assertThat(graph).isNotEqualTo(g2);
  }

  // Node/edge sets are the same, but node/edge connections differ due to edge type.
  @Test
  public void equivalent_directedVsUndirected() {
    graph.putEdge(N1, N2);

    }
  }

  public void testPutStringWithLowSurrogate() {
    // we pad because the dummy hash function we use to test this, merely copies the input into
    // the output, so the input must be at least 32 bits, since the output has to be that long
    assertPutString(new char[] {'p', HashTestUtils.randomLowSurrogate(new Random())});
  }

  public void testPutStringWithHighSurrogate() {

import static org.junit.jupiter.api.Assertions.assertEquals;

/**
 */
@Deprecated
class CleanArgumentTest {

    @Test
    void cleanArgs() {
        String[] args = {
            "\"",
        };
        CleanArgument.cleanArgs(args);
    }

    @Test
    void cleanArgsShouldRemoveWrongSurroundingQuotes() {
        String[] args = {"\"-Dfoo=bar", "\"-Dfoo2=bar two\""};