domain = unicode ? domainName.getBytes(UNI_ENCODING) : domainName.getBytes(oem);
            }
            final int domainLength = domain != null ? domain.length : 0;
            final String userName = getUser();
            byte[] user = null;
            if (userName != null && userName.length() != 0) {
                user = unicode ? userName.getBytes(UNI_ENCODING) : userName.toUpperCase().getBytes(oem);

        when(mockTree.getConfig()).thenReturn(mockConfig);
        when(mockTree.isConnected()).thenReturn(true);
        when(mockTree.getTreeId()).thenReturn(1L);

        when(mockFile.getType()).thenReturn(SmbConstants.TYPE_FILESYSTEM);
    }

    @Nested
    @DisplayName("Happy path")
    class HappyPath {

        @Test

     */
    @Test
    void testParseAuthDataPacWithInvalidToken() {
        // GIVEN an invalid token for AUTH_DATA_PAC
        byte[] invalidToken = "invalid-pac-token".getBytes();

        // WHEN parsing the auth data
        // THEN a PACDecodingException should be thrown
        assertThrows(PACDecodingException.class, () -> {

        final InputStream is = ResourceUtil.getResourceAsStream(StringUtil.replace(getClass().getName(), ".", "/") + ".class");
        try {
            assertNotNull("1", InputStreamUtil.getBytes(is));
        } finally {
            is.close();
        }
    }

    /**
     * Constructs a pipe wait request without timeout.
     *
     * @param name the pipe name to wait for
     */
    public FsctlPipeWaitRequest(final String name) {
        this.nameBytes = name.getBytes(StandardCharsets.UTF_16LE);
        this.timeoutSpecified = false;
        this.timeout = 0;
    }

    /**
     * Constructs a pipe wait request with timeout.
     *
     * @param name the pipe name to wait for

        return Stream.of(Arguments.of(new byte[0], ""), Arguments.of(new byte[] { (byte) 0x41 }, "QQ=="), // "A"
                Arguments.of(new byte[] { (byte) 0x41, (byte) 0x42 }, "QUI="), // "AB"
                Arguments.of("Man".getBytes(), "TWFu"), // 3 bytes, no padding
                Arguments.of(new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00 }, "AAAA"), // all zeros

    }

    /**
     * @throws Exception
     */
    @Test
    public void testFileToFile() throws Exception {
        int result = copy(inputFile, outputFile);
        assertThat(result, is(urlString.getBytes("UTF-8").length));

        result = copy(outputFile, "UTF-8", writer);
        assertThat(writer.toString(), is(urlString));
    }

    /**
     * @throws Exception
     */
    @Test

            try {
                domain = DEFAULT_DOMAIN.getBytes(UNI_ENCODING);
            } catch (final IOException ex) {}
        }
        final int domainLength = domain.length;
        byte[] server = {};
        try {
            final String host = NbtAddress.getLocalHost().getHostName();
            if (host != null) {
                try {
                    server = host.getBytes(UNI_ENCODING);

        ResponseData responseData = new ResponseData() {
            @Override
            public InputStream getResponseBody() {
                return new ByteArrayInputStream("Test response body".getBytes());
            }

            @Override
            public String getUrl() {
                return "http://example.com/test";
            }
        };

        DefaultToolchain toolchain = newDefaultToolchain(model, "TYPE");
        assertEquals("TYPE", toolchain.getType());

        model.setType("MODEL_TYPE");
        toolchain = newDefaultToolchain(model);
        assertEquals("MODEL_TYPE", toolchain.getType());
    }

    @Test
    void testGetLogger() {
        ToolchainModel model = new ToolchainModel();