// Test empty path
        testImplementation.setPath("");
        assertEquals("", testImplementation.getPath());

        // Test empty UNC path components
        testImplementation.setFullUNCPath("", "", "");
        assertEquals("", testImplementation.getDomain());
        assertEquals("", testImplementation.getServer());
        assertEquals("", testImplementation.getFullUNCPath());
    }

    @Test

        assertNotNull("Encoded result should not be null", encoded);
        final byte[] decoded = Base64Util.decode(encoded);
        assertEquals("Decoded should have same length", 2, decoded.length);
        assertEquals("First byte should match", twoBytes[0], decoded[0]);
        assertEquals("Second byte should match", twoBytes[1], decoded[1]);
    }

    /**
     * Test backward compatibility with standard Base64
     *

      mock.assertLastMethodCalled("submit");
      assertEquals(RESULT_VALUE, f.get());
    }
    {
      MockExecutor mock = new MockExecutor();
      TestExecutor testExecutor = new TestExecutor(mock);
      Callable<String> task = Callables.returning(RESULT_VALUE);
      Future<String> f = testExecutor.submit(task);
      mock.assertLastMethodCalled("submit");
      assertEquals(RESULT_VALUE, f.get());
    }
  }

        assertNotNull(resp);
        assertEquals(command, resp.getCommand());
        assertEquals(subcommand, resp.getSubCommand());
    }

    @Test
    @DisplayName("Test dataCount getter and setter")
    void testDataCountGetterSetter() {
        assertEquals(0, response.getDataCount());
        response.setDataCount(100);
        assertEquals(100, response.getDataCount());
    }

    @Test

        // Verify channel properties
        assertEquals("test-channel", channel.getChannelId());
        assertEquals(mockTransport, channel.getTransport());
        assertEquals(localNic, channel.getLocalInterface());
        assertEquals(remoteNic, channel.getRemoteInterface());
        assertEquals(ChannelState.ESTABLISHED, channel.getState());
        assertTrue(channel.isHealthy());

    val request = Request(server.url("/"))

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
      assertEquals(TlsVersion.TLS_1_3, response.handshake?.tlsVersion)
      assertEquals(Protocol.HTTP_2, response.protocol)

      assertThat(response.exchangeAccessor!!.connectionAccessor.socket())
        .isInstanceOf<SSLSocketImpl>()
    }
  }

    assertEquals(
        new TypeCapture<K>() {}.capture(), resolver.resolveType(new TypeCapture<K>() {}.capture()));
    assertEquals(Integer.class, resolver.resolveType(new TypeCapture<V>() {}.capture()));
  }

  public <T> void testWhere_mapFromWildcard() {
    Type subtype = new TypeCapture<TypedKeyMap<T>>() {}.capture();
    assertEquals(

        size8Method.setAccessible(true);

        // When & Then - test various sizes for 8-byte alignment
        assertEquals(8, size8Method.invoke(request, 1));
        assertEquals(8, size8Method.invoke(request, 8));
        assertEquals(16, size8Method.invoke(request, 9));
        assertEquals(72, size8Method.invoke(request, 68)); // SMB2_HEADER_LENGTH + 4 = 68
    }

    @Test

        assertEquals(10, logonInfo.getLogonCount());
        assertEquals(2, logonInfo.getBadPasswordCount());
        assertEquals("Display Name", logonInfo.getUserDisplayName());
        assertEquals("\\\\server\\\\profile", logonInfo.getProfilePath());
        assertEquals("\\\\server\\\\home", logonInfo.getHomeDirectory());
        assertEquals("H:", logonInfo.getHomeDrive());

            // Verify structure size (should be 33)
            assertEquals(33, SMBUtil.readInt2(buffer, 64));

            // Verify info type and file info class
            assertEquals((byte) 0x01, buffer[66]);
            assertEquals((byte) 0x04, buffer[67]);

            // Verify additional information
            assertEquals(0x12345678, SMBUtil.readInt4(buffer, 76));

            // Verify file ID