req.setFileInformation(new FileBasicInfo(ctime, atime, mtime, 0L, attrs));
                    dh.send(req);
                } else if (dh.hasCapability(SmbConstants.CAP_NT_SMBS)) {
                    // use the open file descriptor
                    dh.send(new Trans2SetFileInformation(dh.getConfig(), dfd.getFid(), attrs, ctime, mtime, atime),

            log.println("open0: " + unc);
        }

        /*
         * NT Create AndX / Open AndX Request / Response
         */

        if (tree.session.transport.hasCapability(SmbConstants.CAP_NT_SMBS)) {
            final SmbComNTCreateAndXResponse response = new SmbComNTCreateAndXResponse();
            final SmbComNTCreateAndX request = new SmbComNTCreateAndX(unc, flags, access, shareAccess, attrs, options, null);

                    th.send(new TransWaitNamedPipe(th.getConfig(), this.uncPath), new TransWaitNamedPipeResponse(th.getConfig()));
                }

                if (th.hasCapability(SmbConstants.CAP_NT_SMBS) || this.uncPath.startsWith("\\pipe\\")) {
                    this.handle = this.pipe.openUnshared(this.openFlags, this.access, this.sharing, SmbConstants.ATTR_NORMAL, 0);
                } else {

        assertEquals(0x0002, SmbConstants.CAP_MPX_MODE);
        assertEquals(0x0004, SmbConstants.CAP_UNICODE);
        assertEquals(0x0008, SmbConstants.CAP_LARGE_FILES);
        assertEquals(0x0010, SmbConstants.CAP_NT_SMBS);
        assertEquals(0x0020, SmbConstants.CAP_RPC_REMOTE_APIS);
        assertEquals(0x0040, SmbConstants.CAP_STATUS32);
        assertEquals(0x0080, SmbConstants.CAP_LEVEL_II_OPLOCKS);

        writeSize = file.tree.session.transport.snd_buf_size - 70;

        useNTSmbs = file.tree.session.transport.hasCapability(SmbConstants.CAP_NT_SMBS);
        if (useNTSmbs) {
            reqx = new SmbComWriteAndX();
            rspx = new SmbComWriteAndXResponse();
        } else {
            req = new SmbComWrite();

        testConfig.useLargeReadWrite = true;
        testConfig.useUnicode = true;

        testConfig.initDefaults();

        assertTrue((testConfig.getCapabilities() & SmbConstants.CAP_NT_SMBS) != 0);
        assertTrue((testConfig.getCapabilities() & SmbConstants.CAP_STATUS32) != 0);
        assertTrue((testConfig.getCapabilities() & SmbConstants.CAP_EXTENDED_SECURITY) != 0);

        this.openFlags &= ~(SmbConstants.O_CREAT | SmbConstants.O_TRUNC); /* in case we close and reopen */
        this.writeSize = sendBufferSize - 70;

        this.useNTSmbs = th.hasCapability(SmbConstants.CAP_NT_SMBS);
        if (!this.useNTSmbs) {
            log.debug("No support for NT SMBs");
        }

        // there seems to be a bug with some servers that causes corruption if using signatures +

                req.setFileInformation(new FileEndOfFileInformation(newLength));
                th.send(req, RequestParam.NO_RETRY);
            } else if (th.hasCapability(SmbConstants.CAP_NT_SMBS)) {
                th.send(new Trans2SetFileInformation(th.getConfig(), fh.getFid(), new FileEndOfFileInformation(newLength)),
                        new Trans2SetFileInformationResponse(th.getConfig()), RequestParam.NO_RETRY);

        when(tree.getReceiveBufferSize()).thenReturn(1024);
        when(tree.getSendBufferSize()).thenReturn(1024);
        when(tree.hasCapability(anyInt())).thenAnswer(inv -> ntSmbsCap && inv.getArgument(0).equals(SmbConstants.CAP_NT_SMBS));
        when(tree.areSignaturesActive()).thenReturn(false);
        when(tree.isSMB2()).thenReturn(smb2);

        when(file.openUnshared(anyInt(), anyInt(), anyInt(), anyInt(), anyInt())).thenReturn(fh);

                    | (this.useUnicode || this.forceUnicode ? SmbConstants.FLAGS2_UNICODE : 0);
        }

        if (this.capabilities == 0) {
            this.capabilities = (this.useNTSmbs ? SmbConstants.CAP_NT_SMBS : 0) | (this.useNtStatus ? SmbConstants.CAP_STATUS32 : 0)
                    | (this.useExtendedSecurity ? SmbConstants.CAP_EXTENDED_SECURITY : 0)
                    | (this.useLargeReadWrite ? SmbConstants.CAP_LARGE_READX : 0)