/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.sshd.client.subsystem.sftp;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.EOFException;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.SocketTimeoutException;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.nio.file.CopyOption;
import java.nio.file.FileSystem;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Collection;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import java.util.Vector;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;

import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;

import org.apache.sshd.client.SshClient;
import org.apache.sshd.client.session.ClientSession;
import org.apache.sshd.client.subsystem.sftp.SftpClient.CloseableHandle;
import org.apache.sshd.client.subsystem.sftp.SftpClient.OpenMode;
import org.apache.sshd.client.subsystem.sftp.extensions.BuiltinSftpClientExtensions;
import org.apache.sshd.client.subsystem.sftp.extensions.SftpClientExtension;
import org.apache.sshd.common.Factory;
import org.apache.sshd.common.FactoryManager;
import org.apache.sshd.common.NamedFactory;
import org.apache.sshd.common.OptionalFeature;
import org.apache.sshd.common.PropertyResolverUtils;
import org.apache.sshd.common.channel.WindowClosedException;
import org.apache.sshd.common.file.FileSystemFactory;
import org.apache.sshd.common.file.virtualfs.VirtualFileSystemFactory;
import org.apache.sshd.common.random.Random;
import org.apache.sshd.common.session.Session;
import org.apache.sshd.common.subsystem.sftp.SftpConstants;
import org.apache.sshd.common.subsystem.sftp.SftpException;
import org.apache.sshd.common.subsystem.sftp.extensions.AclSupportedParser.AclCapabilities;
import org.apache.sshd.common.subsystem.sftp.extensions.NewlineParser.Newline;
import org.apache.sshd.common.subsystem.sftp.extensions.ParserUtils;
import org.apache.sshd.common.subsystem.sftp.extensions.Supported2Parser.Supported2;
import org.apache.sshd.common.subsystem.sftp.extensions.SupportedParser.Supported;
import org.apache.sshd.common.subsystem.sftp.extensions.VersionsParser.Versions;
import org.apache.sshd.common.subsystem.sftp.extensions.openssh.AbstractOpenSSHExtensionParser.OpenSSHExtension;
import org.apache.sshd.common.util.GenericUtils;
import org.apache.sshd.common.util.OsUtils;
import org.apache.sshd.common.util.ValidateUtils;
import org.apache.sshd.common.util.buffer.BufferUtils;
import org.apache.sshd.common.util.buffer.ByteArrayBuffer;
import org.apache.sshd.common.util.io.IoUtils;
import org.apache.sshd.server.Command;
import org.apache.sshd.server.session.ServerSession;
import org.apache.sshd.server.subsystem.sftp.AbstractSftpEventListenerAdapter;
import org.apache.sshd.server.subsystem.sftp.DirectoryHandle;
import org.apache.sshd.server.subsystem.sftp.FileHandle;
import org.apache.sshd.server.subsystem.sftp.Handle;
import org.apache.sshd.server.subsystem.sftp.SftpSubsystem;
import org.apache.sshd.server.subsystem.sftp.SftpSubsystemFactory;
import org.apache.sshd.util.test.JSchLogger;
import org.apache.sshd.util.test.SimpleUserInfo;
import org.apache.sshd.util.test.Utils;
import org.junit.After;
import org.junit.Assume;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;

/**
 * @author <a href="mailto:dev@mina.apache.org">Apache MINA SSHD Project</a>
 */
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class SftpTest extends AbstractSftpClientTestSupport {
    private static final Map<String, OptionalFeature> EXPECTED_EXTENSIONS = SftpSubsystem.DEFAULT_SUPPORTED_CLIENT_EXTENSIONS;

    private com.jcraft.jsch.Session session;

    public SftpTest() throws IOException {
        super();
    }

    @BeforeClass
    public static void jschInit() {
        JSchLogger.init();
    }

    @Before
    public void setUp() throws Exception {
        setupServer();
        JSch sch = new JSch();
        session = sch.getSession("sshd", TEST_LOCALHOST, port);
        session.setUserInfo(new SimpleUserInfo("sshd"));
        session.connect();
    }

    @After
    public void tearDown() throws Exception {
        if (session != null) {
            session.disconnect();
        }

        tearDownServer();
    }

    @Test   // see SSHD-547
    public void testWriteOffsetIgnoredForAppendMode() throws IOException {
        Path targetPath = detectTargetFolder();
        Path parentPath = targetPath.getParent();
        Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
        Path testFile = assertHierarchyTargetFolderExists(lclSftp).resolve("file.txt");
        Files.deleteIfExists(testFile);

        byte[] expectedRandom = new byte[Byte.MAX_VALUE];
        Factory<? extends Random> factory = sshd.getRandomFactory();
        Random rnd = factory.create();
        rnd.fill(expectedRandom);

        byte[] expectedText = (getClass().getName() + "#" + getCurrentTestName()).getBytes(StandardCharsets.UTF_8);
        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                try (SftpClient sftp = session.createSftpClient()) {
                    String file = Utils.resolveRelativeRemotePath(parentPath, testFile);

                    try (CloseableHandle handle = sftp.open(file, OpenMode.Create, OpenMode.Write, OpenMode.Read, OpenMode.Append)) {
                        sftp.write(handle, 7365L, expectedRandom);
                        byte[] actualRandom = new byte[expectedRandom.length];
                        int readLen = sftp.read(handle, 0L, actualRandom);
                        assertEquals("Incomplete random data read", expectedRandom.length, readLen);
                        assertArrayEquals("Mismatched read random data", expectedRandom, actualRandom);

                        sftp.write(handle, 3777347L, expectedText);
                        byte[] actualText = new byte[expectedText.length];
                        readLen = sftp.read(handle, actualRandom.length, actualText);
                        assertEquals("Incomplete text data read", actualText.length, readLen);
                        assertArrayEquals("Mismatched read text data", expectedText, actualText);
                    }
                }
            } finally {
                client.stop();
            }
        }

        byte[] actualBytes = Files.readAllBytes(testFile);
        assertEquals("Mismatched result file size", expectedRandom.length + expectedText.length, actualBytes.length);

        byte[] actualRandom = Arrays.copyOfRange(actualBytes, 0, expectedRandom.length);
        assertArrayEquals("Mismatched random part", expectedRandom, actualRandom);

        byte[] actualText = Arrays.copyOfRange(actualBytes, expectedRandom.length, actualBytes.length);
        assertArrayEquals("Mismatched text part", expectedText, actualText);
    }

    @Test   // see SSHD-545
    public void testReadBufferLimit() throws Exception {
        Path targetPath = detectTargetFolder();
        Path parentPath = targetPath.getParent();
        Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
        Path testFile = assertHierarchyTargetFolderExists(lclSftp).resolve("file.txt");
        byte[] expected = new byte[1024];

        Factory<? extends Random> factory = sshd.getRandomFactory();
        Random rnd = factory.create();
        rnd.fill(expected);
        Files.write(testFile, expected);

        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                try (SftpClient sftp = session.createSftpClient()) {
                    String file = Utils.resolveRelativeRemotePath(parentPath, testFile);
                    byte[] actual = new byte[expected.length];
                    int maxAllowed = actual.length / 4;
                    // allow less than actual
                    PropertyResolverUtils.updateProperty(sshd, SftpSubsystem.MAX_PACKET_LENGTH_PROP, maxAllowed);
                    try (CloseableHandle handle = sftp.open(file, OpenMode.Read)) {
                        int readLen = sftp.read(handle, 0L, actual);
                        assertEquals("Mismatched read len", maxAllowed, readLen);

                        for (int index = 0; index < readLen; index++) {
                            byte expByte = expected[index];
                            byte actByte = actual[index];
                            if (expByte != actByte) {
                                fail("Mismatched values at index=" + index
                                    + ": expected=0x" + Integer.toHexString(expByte & 0xFF)
                                    + ", actual=0x" + Integer.toHexString(actByte & 0xFF));
                            }
                        }
                    }
                }
            } finally {
                client.stop();
            }
        }
    }

    @Test   // see extra fix for SSHD-538
    public void testNavigateBeyondRootFolder() throws Exception {
        Path rootLocation = Paths.get(OsUtils.isUNIX() ? "/" : "C:\\");
        final FileSystem fsRoot = rootLocation.getFileSystem();
        sshd.setFileSystemFactory(new FileSystemFactory() {
                @Override
                public FileSystem createFileSystem(Session session) throws IOException {
                    return fsRoot;
                }
            });

        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                try (SftpClient sftp = session.createSftpClient()) {
                    String rootDir = sftp.canonicalPath("/");
                    String upDir = sftp.canonicalPath(rootDir + "/..");
                    assertEquals("Mismatched root dir parent", rootDir, upDir);
                }
            } finally {
                client.stop();
            }
        }
    }

    @Test   // see SSHD-605
    public void testCannotEscapeUserAbsoluteRoot() throws Exception {
        testCannotEscapeRoot(true);
    }

    @Test   // see SSHD-605
    public void testCannotEscapeUserRelativeRoot() throws Exception {
        testCannotEscapeRoot(false);
    }

    private void testCannotEscapeRoot(boolean useAbsolutePath) throws Exception {
        Path targetPath = detectTargetFolder();
        Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
        assertHierarchyTargetFolderExists(lclSftp);
        sshd.setFileSystemFactory(new VirtualFileSystemFactory(lclSftp));

        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                String escapePath;
                if (useAbsolutePath) {
                    escapePath = targetPath.toString();
                    if (OsUtils.isWin32()) {
                        escapePath = "/" + escapePath.replace(File.separatorChar, '/');
                    }
                } else {
                    Path parent = lclSftp.getParent();
                    Path forbidden = Files.createDirectories(parent.resolve("forbidden"));
                    escapePath = "../" + forbidden.getFileName();
                }

                try (SftpClient sftp = session.createSftpClient()) {
                    SftpClient.Attributes attrs = sftp.stat(escapePath);
                    fail("Unexpected escape success for path=" + escapePath + ": " + attrs);
                } catch (SftpException e) {
                    int expected = OsUtils.isWin32() || (!useAbsolutePath)
                            ? SftpConstants.SSH_FX_INVALID_FILENAME
                            : SftpConstants.SSH_FX_NO_SUCH_FILE;
                    assertEquals("Mismatched status for " + escapePath,
                                 SftpConstants.getStatusName(expected),
                                 SftpConstants.getStatusName(e.getStatus()));
                }
            } finally {
                client.stop();
            }
        }
    }

    @Test
    public void testNormalizeRemoteRootValues() throws Exception {
        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                try (SftpClient sftp = session.createSftpClient()) {
                    StringBuilder sb = new StringBuilder(Long.SIZE + 1);
                    String expected = sftp.canonicalPath("/");
                    for (int i = 0; i < Long.SIZE; i++) {
                        if (sb.length() > 0) {
                            sb.setLength(0);
                        }

                        for (int j = 1; j <= i; j++) {
                            sb.append('/');
                        }

                        String remotePath = sb.toString();
                        String actual = sftp.canonicalPath(remotePath);
                        assertEquals("Mismatched roots for " + remotePath.length() + " slashes", expected, actual);
                    }
                }
            } finally {
                client.stop();
            }
        }
    }

    @Test
    public void testNormalizeRemotePathsValues() throws Exception {
        Path targetPath = detectTargetFolder();
        Path parentPath = targetPath.getParent();
        Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
        Path testFile = assertHierarchyTargetFolderExists(lclSftp).resolve("file.txt");
        String file = Utils.resolveRelativeRemotePath(parentPath, testFile);
        String[] comps = GenericUtils.split(file, '/');

        try (SshClient client = setupTestClient()) {
            client.start();

            Factory<? extends Random> factory = client.getRandomFactory();
            Random rnd = factory.create();
            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                try (SftpClient sftp = session.createSftpClient()) {
                    StringBuilder sb = new StringBuilder(file.length() + comps.length);
                    String expected = sftp.canonicalPath(file);
                    for (int i = 0; i < file.length(); i++) {
                        if (sb.length() > 0) {
                            sb.setLength(0);
                        }

                        sb.append(comps[0]);
                        for (int j = 1; j < comps.length; j++) {
                            String name = comps[j];
                            slashify(sb, rnd);
                            sb.append(name);
                        }
                        slashify(sb, rnd);

                        if (rnd.random(Byte.SIZE) < (Byte.SIZE / 2)) {
                            sb.append('.');
                        }

                        String remotePath = sb.toString();
                        String actual = sftp.canonicalPath(remotePath);
                        assertEquals("Mismatched canonical value for " + remotePath, expected, actual);
                    }
                }
            } finally {
                client.stop();
            }
        }
    }

    private static int slashify(StringBuilder sb, Random rnd) {
        int slashes = 1 /* at least one slash */ + rnd.random(Byte.SIZE);
        for (int k = 0; k < slashes; k++) {
            sb.append('/');
        }

        return slashes;
    }

    @Test
    public void testOpen() throws Exception {
        Path targetPath = detectTargetFolder();
        Path parentPath = targetPath.getParent();
        Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
        Path clientFolder = lclSftp.resolve("client");
        Path testFile = clientFolder.resolve("file.txt");
        String file = Utils.resolveRelativeRemotePath(parentPath, testFile);

        File javaFile = testFile.toFile();
        assertHierarchyTargetFolderExists(javaFile.getParentFile());

        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                javaFile.createNewFile();
                javaFile.setWritable(false, false);
                javaFile.setReadable(false, false);

                try (SftpClient sftp = session.createSftpClient()) {
                    boolean isWindows = OsUtils.isWin32();

                    try (SftpClient.CloseableHandle h = sftp.open(file /* no mode == read */)) {
                        // NOTE: on Windows files are always readable
                        // see https://svn.apache.org/repos/asf/harmony/enhanced/java/branches/java6/classlib/modules/
                        //      luni/src/test/api/windows/org/apache/harmony/luni/tests/java/io/WinFileTest.java
                        assertTrue("Empty read should have failed on " + file, isWindows);
                    } catch (IOException e) {
                        if (isWindows) {
                            throw e;
                        }
                    }

                    try (SftpClient.CloseableHandle h = sftp.open(file, EnumSet.of(SftpClient.OpenMode.Write))) {
                        fail("Empty write should have failed on " + file);
                    } catch (IOException e) {
                        // ok
                    }

                    try (SftpClient.CloseableHandle h = sftp.open(file, EnumSet.of(SftpClient.OpenMode.Truncate))) {
                        // NOTE: on Windows files are always readable
                        assertTrue("Empty truncate should have failed on " + file, isWindows);
                    } catch (IOException e) {
                        // ok
                    }

                    // NOTE: on Windows files are always readable
                    int perms = sftp.stat(file).getPermissions();
                    int readMask = isWindows ? 0 : SftpConstants.S_IRUSR;
                    int permsMask = SftpConstants.S_IWUSR | readMask;
                    assertEquals("Mismatched permissions for " + file + ": 0x" + Integer.toHexString(perms), 0, perms & permsMask);

                    javaFile.setWritable(true, false);

                    try (SftpClient.CloseableHandle h = sftp.open(file, EnumSet.of(SftpClient.OpenMode.Truncate, SftpClient.OpenMode.Write))) {
                        // OK should succeed
                        assertTrue("Handle not marked as open for file=" + file, h.isOpen());
                    }

                    byte[] d = "0123456789\n".getBytes(StandardCharsets.UTF_8);
                    try (SftpClient.CloseableHandle h = sftp.open(file, EnumSet.of(SftpClient.OpenMode.Write))) {
                        sftp.write(h, 0, d, 0, d.length);
                        sftp.write(h, d.length, d, 0, d.length);
                    }

                    try (SftpClient.CloseableHandle h = sftp.open(file, EnumSet.of(SftpClient.OpenMode.Write))) {
                        sftp.write(h, d.length * 2, d, 0, d.length);
                    }

                    try (SftpClient.CloseableHandle h = sftp.open(file, EnumSet.of(SftpClient.OpenMode.Write))) {
                        byte[] overwrite = "-".getBytes(StandardCharsets.UTF_8);
                        sftp.write(h, 3L, overwrite, 0, 1);
                        d[3] = overwrite[0];
                    }

                    try (SftpClient.CloseableHandle h = sftp.open(file /* no mode == read */)) {
                        // NOTE: on Windows files are always readable
                        assertTrue("Data read should have failed on " + file, isWindows);
                    } catch (IOException e) {
                        if (isWindows) {
                            throw e;
                        }
                    }

                    javaFile.setReadable(true, false);

                    byte[] buf = new byte[3];
                    try (SftpClient.CloseableHandle h = sftp.open(file /* no mode == read */)) {
                        int l = sftp.read(h, 2L, buf, 0, buf.length);
                        String expected = new String(d, 2, l, StandardCharsets.UTF_8);
                        String actual = new String(buf, 0, l, StandardCharsets.UTF_8);
                        assertEquals("Mismatched read data", expected, actual);
                    }
                }
            } finally {
                client.stop();
            }
        }
    }

    @Test
    @SuppressWarnings({"checkstyle:anoninnerlength", "checkstyle:methodlength"})
    public void testClient() throws Exception {
        List<NamedFactory<Command>> factories = sshd.getSubsystemFactories();
        assertEquals("Mismatched subsystem factories count", 1, GenericUtils.size(factories));

        NamedFactory<Command> f = factories.get(0);
        assertObjectInstanceOf("Not an SFTP subsystem factory", SftpSubsystemFactory.class, f);

        SftpSubsystemFactory factory = (SftpSubsystemFactory) f;
        final AtomicInteger versionHolder = new AtomicInteger(-1);
        final AtomicInteger openCount = new AtomicInteger(0);
        final AtomicInteger closeCount = new AtomicInteger(0);
        final AtomicLong readSize = new AtomicLong(0L);
        final AtomicLong writeSize = new AtomicLong(0L);
        final AtomicInteger entriesCount = new AtomicInteger(0);
        final AtomicInteger creatingCount = new AtomicInteger(0);
        final AtomicInteger createdCount = new AtomicInteger(0);
        final AtomicInteger removingCount = new AtomicInteger(0);
        final AtomicInteger removedCount = new AtomicInteger(0);
        final AtomicInteger modifyingCount = new AtomicInteger(0);
        final AtomicInteger modifiedCount = new AtomicInteger(0);

        factory.addSftpEventListener(new AbstractSftpEventListenerAdapter() {
            @Override
            public void initialized(ServerSession session, int version) {
                log.info("initialized(" + session + ") version: " + version);
                assertTrue("Initialized version below minimum", version >= SftpSubsystem.LOWER_SFTP_IMPL);
                assertTrue("Initialized version above maximum", version <= SftpSubsystem.HIGHER_SFTP_IMPL);
                assertTrue("Initializion re-called", versionHolder.getAndSet(version) < 0);
            }

            @Override
            public void destroying(ServerSession session) {
                log.info("destroying(" + session + ")");
                assertTrue("Initialization method not called", versionHolder.get() > 0);
            }

            @Override
            public void written(ServerSession session, String remoteHandle, FileHandle localHandle,
                    long offset, byte[] data, int dataOffset, int dataLen, Throwable thrown) {
                writeSize.addAndGet(dataLen);
                if (log.isDebugEnabled()) {
                    log.debug("write(" + session + ")[" + localHandle.getFile() + "] offset=" + offset + ", requested=" + dataLen);
                }
            }

            @Override
            public void removing(ServerSession session, Path path) {
                removingCount.incrementAndGet();
                log.info("removing(" + session + ") " + path);
            }

            @Override
            public void removed(ServerSession session, Path path, Throwable thrown) {
                removedCount.incrementAndGet();
                log.info("removed(" + session + ") " + path
                       + ((thrown == null) ? "" : (": " + thrown.getClass().getSimpleName() + ": " + thrown.getMessage())));
            }

            @Override
            public void modifyingAttributes(ServerSession session, Path path, Map<String, ?> attrs) {
                modifyingCount.incrementAndGet();
                log.info("modifyingAttributes(" + session + ") " + path);
            }

            @Override
            public void modifiedAttributes(ServerSession session, Path path, Map<String, ?> attrs, Throwable thrown) {
                modifiedCount.incrementAndGet();
                log.info("modifiedAttributes(" + session + ") " + path
                       + ((thrown == null) ? "" : (": " + thrown.getClass().getSimpleName() + ": " + thrown.getMessage())));
            }

            @Override
            public void read(ServerSession session, String remoteHandle, FileHandle localHandle, long offset, byte[] data,
                    int dataOffset, int dataLen, int readLen, Throwable thrown) {
                readSize.addAndGet(readLen);
                if (log.isDebugEnabled()) {
                    log.debug("read(" + session + ")[" + localHandle.getFile() + "] offset=" + offset + ", requested=" + dataLen + ", read=" + readLen);
                }
            }

            @Override
            public void read(ServerSession session, String remoteHandle, DirectoryHandle localHandle, Map<String, Path> entries) {
                int numEntries = GenericUtils.size(entries);
                entriesCount.addAndGet(numEntries);

                if (log.isDebugEnabled()) {
                    log.debug("read(" + session + ")[" + localHandle.getFile() + "] " + numEntries + " entries");
                }

                if ((numEntries > 0) && log.isTraceEnabled()) {
                    for (Map.Entry<String, Path> ee : entries.entrySet()) {
                        log.trace("read(" + session + ")[" + localHandle.getFile() + "] " + ee.getKey() + " - " + ee.getValue());
                    }
                }
            }

            @Override
            public void open(ServerSession session, String remoteHandle, Handle localHandle) {
                Path path = localHandle.getFile();
                log.info("open(" + session + ")[" + remoteHandle + "] " + (Files.isDirectory(path) ? "directory" : "file") + " " + path);
                openCount.incrementAndGet();
            }

            @Override
            public void moving(ServerSession session, Path srcPath, Path dstPath, Collection<CopyOption> opts) {
                log.info("moving(" + session + ")[" + opts + "]" + srcPath + " => " + dstPath);
            }

            @Override
            public void moved(ServerSession session, Path srcPath, Path dstPath, Collection<CopyOption> opts, Throwable thrown) {
                log.info("moved(" + session + ")[" + opts + "]" + srcPath + " => " + dstPath
                       + ((thrown == null) ? "" : (": " + thrown.getClass().getSimpleName() + ": " + thrown.getMessage())));
            }

            @Override
            public void linking(ServerSession session, Path src, Path target, boolean symLink) {
                log.info("linking(" + session + ")[" + symLink + "]" + src + " => " + target);
            }

            @Override
            public void linked(ServerSession session, Path src, Path target, boolean symLink, Throwable thrown) {
                log.info("linked(" + session + ")[" + symLink + "]" + src + " => " + target
                      + ((thrown == null) ? "" : (": " + thrown.getClass().getSimpleName() + ": " + thrown.getMessage())));
            }

            @Override
            public void creating(ServerSession session, Path path, Map<String, ?> attrs) {
                creatingCount.incrementAndGet();
                log.info("creating(" + session + ") " + (Files.isDirectory(path) ? "directory" : "file") + " " + path);
            }

            @Override
            public void created(ServerSession session, Path path, Map<String, ?> attrs, Throwable thrown) {
                createdCount.incrementAndGet();
                log.info("created(" + session + ") " + (Files.isDirectory(path) ? "directory" : "file") + " " + path
                       + ((thrown == null) ? "" : (": " + thrown.getClass().getSimpleName() + ": " + thrown.getMessage())));
            }

            @Override
            public void blocking(ServerSession session, String remoteHandle, FileHandle localHandle, long offset, long length, int mask) {
                log.info("blocking(" + session + ")[" + localHandle.getFile() + "]"
                       + " offset=" + offset + ", length=" + length + ", mask=0x" + Integer.toHexString(mask));
            }

            @Override
            public void blocked(ServerSession session, String remoteHandle, FileHandle localHandle,
                                long offset, long length, int mask, Throwable thrown) {
                log.info("blocked(" + session + ")[" + localHandle.getFile() + "]"
                       + " offset=" + offset + ", length=" + length + ", mask=0x" + Integer.toHexString(mask)
                       + ((thrown == null) ? "" : (": " + thrown.getClass().getSimpleName() + ": " + thrown.getMessage())));
            }

            @Override
            public void unblocking(ServerSession session, String remoteHandle, FileHandle localHandle, long offset, long length) {
                log.info("unblocking(" + session + ")[" + localHandle.getFile() + "] offset=" + offset + ", length=" + length);
            }

            @Override
            public void unblocked(ServerSession session, String remoteHandle, FileHandle localHandle,
                                  long offset, long length, Throwable thrown) {
                log.info("unblocked(" + session + ")[" + localHandle.getFile() + "]"
                       + " offset=" + offset + ", length=" + length
                       + ((thrown == null) ? "" : (": " + thrown.getClass().getSimpleName() + ": " + thrown.getMessage())));
            }

            @Override
            public void close(ServerSession session, String remoteHandle, Handle localHandle) {
                Path path = localHandle.getFile();
                log.info("close(" + session + ")[" + remoteHandle + "] " + (Files.isDirectory(path) ? "directory" : "file") + " " + path);
                closeCount.incrementAndGet();
            }
        });

        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                try (SftpClient sftp = session.createSftpClient()) {
                    assertEquals("Mismatched negotiated version", sftp.getVersion(), versionHolder.get());
                    testClient(client, sftp);
                }

                assertEquals("Mismatched open/close count", openCount.get(), closeCount.get());
                assertTrue("No entries read", entriesCount.get() > 0);
                assertTrue("No data read", readSize.get() > 0L);
                assertTrue("No data written", writeSize.get() > 0L);
                assertEquals("Mismatched removal counts", removingCount.get(), removedCount.get());
                assertTrue("No removals signalled", removedCount.get() > 0);
                assertEquals("Mismatched creation counts", creatingCount.get(), createdCount.get());
                assertTrue("No creations signalled", creatingCount.get() > 0);
                assertEquals("Mismatched modification counts", modifyingCount.get(), modifiedCount.get());
                assertTrue("No modifications signalled", modifiedCount.get() > 0);
            } finally {
                client.stop();
            }
        }
    }

    /**
     * this test is meant to test out write's logic, to ensure that internal chunking (based on Buffer.MAX_LEN) is
     * functioning properly. To do this, we write a variety of file sizes, both smaller and larger than Buffer.MAX_LEN.
     * in addition, this test ensures that improper arguments passed in get caught with an IllegalArgumentException
     *
     * @throws Exception upon any uncaught exception or failure
     */
    @Test
    public void testWriteChunking() throws Exception {
        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                Path targetPath = detectTargetFolder();
                Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
                Utils.deleteRecursive(lclSftp);

                Path parentPath = targetPath.getParent();
                Path clientFolder = assertHierarchyTargetFolderExists(lclSftp).resolve("client");
                String dir = Utils.resolveRelativeRemotePath(parentPath, clientFolder);

                try (SftpClient sftp = session.createSftpClient()) {
                    sftp.mkdir(dir);

                    uploadAndVerifyFile(sftp, clientFolder, dir, 0, "emptyFile.txt");
                    uploadAndVerifyFile(sftp, clientFolder, dir, 1000, "smallFile.txt");
                    uploadAndVerifyFile(sftp, clientFolder, dir, ByteArrayBuffer.MAX_LEN - 1, "bufferMaxLenMinusOneFile.txt");
                    uploadAndVerifyFile(sftp, clientFolder, dir, ByteArrayBuffer.MAX_LEN, "bufferMaxLenFile.txt");
                    // were chunking not implemented, these would fail. these sizes should invoke our internal chunking mechanism
                    uploadAndVerifyFile(sftp, clientFolder, dir, ByteArrayBuffer.MAX_LEN + 1, "bufferMaxLenPlusOneFile.txt");
                    uploadAndVerifyFile(sftp, clientFolder, dir, (int) (1.5 * ByteArrayBuffer.MAX_LEN), "1point5BufferMaxLenFile.txt");
                    uploadAndVerifyFile(sftp, clientFolder, dir, (2 * ByteArrayBuffer.MAX_LEN) - 1, "2TimesBufferMaxLenMinusOneFile.txt");
                    uploadAndVerifyFile(sftp, clientFolder, dir, 2 * ByteArrayBuffer.MAX_LEN, "2TimesBufferMaxLenFile.txt");
                    uploadAndVerifyFile(sftp, clientFolder, dir, (2 * ByteArrayBuffer.MAX_LEN) + 1, "2TimesBufferMaxLenPlusOneFile.txt");
                    uploadAndVerifyFile(sftp, clientFolder, dir, 200000, "largerFile.txt");

                    // test erroneous calls that check for negative values
                    Path invalidPath = clientFolder.resolve(getCurrentTestName() + "-invalid");
                    testInvalidParams(sftp, invalidPath, Utils.resolveRelativeRemotePath(parentPath, invalidPath));

                    // cleanup
                    sftp.rmdir(dir);
                }
            } finally {
                client.stop();
            }
        }
    }

    private void testInvalidParams(SftpClient sftp, Path file, String filePath) throws Exception {
        // generate random file and upload it
        String randomData = randomString(5);
        byte[] randomBytes = randomData.getBytes(StandardCharsets.UTF_8);
        try (SftpClient.CloseableHandle handle = sftp.open(filePath, EnumSet.of(SftpClient.OpenMode.Write, SftpClient.OpenMode.Create))) {
            try {
                sftp.write(handle, -1, randomBytes, 0, 0);
                fail("should not have been able to write file with invalid file offset for " + filePath);
            } catch (IllegalArgumentException e) {
                // expected
            }
            try {
                sftp.write(handle, 0, randomBytes, -1, 0);
                fail("should not have been able to write file with invalid source offset for " + filePath);
            } catch (IllegalArgumentException e) {
                // expected
            }
            try {
                sftp.write(handle, 0, randomBytes, 0, -1);
                fail("should not have been able to write file with invalid length for " + filePath);
            } catch (IllegalArgumentException e) {
                // expected
            }
            try {
                sftp.write(handle, 0, randomBytes, 0, randomBytes.length + 1);
                fail("should not have been able to write file with length bigger than array itself (no offset) for " + filePath);
            } catch (IllegalArgumentException e) {
                // expected
            }
            try {
                sftp.write(handle, 0, randomBytes, randomBytes.length, 1);
                fail("should not have been able to write file with length bigger than array itself (with offset) for " + filePath);
            } catch (IllegalArgumentException e) {
                // expected
            }
        }

        sftp.remove(filePath);
        assertFalse("File should not be there: " + file.toString(), Files.exists(file));
    }

    private void uploadAndVerifyFile(SftpClient sftp, Path clientFolder, String remoteDir, int size, String filename) throws Exception {
        // generate random file and upload it
        String remotePath = remoteDir + "/" + filename;
        String randomData = randomString(size);
        try (SftpClient.CloseableHandle handle = sftp.open(remotePath, EnumSet.of(SftpClient.OpenMode.Write, SftpClient.OpenMode.Create))) {
            sftp.write(handle, 0, randomData.getBytes(StandardCharsets.UTF_8), 0, randomData.length());
        }

        // verify results
        Path resultPath = clientFolder.resolve(filename);
        assertTrue("File should exist on disk: " + resultPath, Files.exists(resultPath));
        assertTrue("Mismatched file contents: " + resultPath, randomData.equals(readFile(remotePath)));

        // cleanup
        sftp.remove(remotePath);
        assertFalse("File should have been removed: " + resultPath, Files.exists(resultPath));
    }

    @Test
    public void testSftp() throws Exception {
        String d = getCurrentTestName() + "\n";

        Path targetPath = detectTargetFolder();
        Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
        Utils.deleteRecursive(lclSftp);

        Path target = assertHierarchyTargetFolderExists(lclSftp).resolve("file.txt");
        String remotePath = Utils.resolveRelativeRemotePath(targetPath.getParent(), target);

        final int numIterations = 10;
        StringBuilder sb = new StringBuilder(d.length() * numIterations * numIterations);
        for (int j = 1; j <= numIterations; j++) {
            if (sb.length() > 0) {
                sb.setLength(0);
            }

            for (int i = 0; i < j; i++) {
                sb.append(d);
            }

            sendFile(remotePath, sb.toString());
            assertFileLength(target, sb.length(), TimeUnit.SECONDS.toMillis(5L));
            Files.delete(target);
        }
    }

    @Test
    public void testReadWriteWithOffset() throws Exception {
        Path targetPath = detectTargetFolder();
        Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
        Utils.deleteRecursive(lclSftp);

        Path localPath = assertHierarchyTargetFolderExists(lclSftp).resolve("file.txt");
        String remotePath = Utils.resolveRelativeRemotePath(targetPath.getParent(), localPath);
        String data = getCurrentTestName();
        String extraData = "@" + getClass().getSimpleName();
        int appendOffset = -5;

        ChannelSftp c = (ChannelSftp) session.openChannel(SftpConstants.SFTP_SUBSYSTEM_NAME);
        c.connect();
        try {
            c.put(new ByteArrayInputStream(data.getBytes(StandardCharsets.UTF_8)), remotePath);

            assertTrue("Remote file not created after initial write: " + localPath, Files.exists(localPath));
            assertEquals("Mismatched data read from " + remotePath, data, readFile(remotePath));

            try (OutputStream os = c.put(remotePath, null, ChannelSftp.APPEND, appendOffset)) {
                os.write(extraData.getBytes(StandardCharsets.UTF_8));
            }
        } finally {
            c.disconnect();
        }

        assertTrue("Remote file not created after data update: " + localPath, Files.exists(localPath));

        String expected = data.substring(0, data.length() + appendOffset) + extraData;
        String actual = readFile(remotePath);
        assertEquals("Mismatched final file data in " + remotePath, expected, actual);
    }

    @Test
    public void testReadDir() throws Exception {
        ChannelSftp c = (ChannelSftp) session.openChannel(SftpConstants.SFTP_SUBSYSTEM_NAME);
        c.connect();
        try {
            URI url = getClass().getClassLoader().getResource(SshClient.class.getName().replace('.', '/') + ".class").toURI();
            URI base = new File(System.getProperty("user.dir")).getAbsoluteFile().toURI();
            File baseDir = new File(base.relativize(url).getPath());
            String path = baseDir.getParent() + "/";
            path = path.replace('\\', '/');

            Vector<?> res = c.ls(path);
            File dir = baseDir.getParentFile();
            Collection<String> expNames = OsUtils.isUNIX()
                                        ? new LinkedList<String>()
                                        : new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
            String[] names = dir.list();
            if (GenericUtils.length(names) > 0) {
                for (String n : names) {
                    if (".".equals(n) || "..".equals(n)) {
                        continue;
                    }

                    assertTrue("Failed to accumulate " + n, expNames.add(n));
                }
            }

            for (Object f : res) {
                outputDebugMessage("LsEntry: %s", f);

                ChannelSftp.LsEntry entry = (ChannelSftp.LsEntry) f;
                String name = entry.getFilename();
                if (".".equals(name) || "..".equals(name)) {
                    continue;
                }

                assertTrue("Entry not found: " + name, expNames.remove(name));
            }

            assertTrue("Un-listed names: " + expNames, GenericUtils.isEmpty(expNames));
        } finally {
            c.disconnect();
        }
    }

    @Test
    public void testRename() throws Exception {
        Path targetPath = detectTargetFolder();
        Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
        Utils.deleteRecursive(lclSftp);

        Path parentPath = targetPath.getParent();
        Path clientFolder = assertHierarchyTargetFolderExists(lclSftp.resolve("client"));

        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                try (SftpClient sftp = session.createSftpClient()) {
                    Path file1 = clientFolder.resolve("file-1.txt");
                    String file1Path = Utils.resolveRelativeRemotePath(parentPath, file1);
                    try (OutputStream os = sftp.write(file1Path, SftpClient.MIN_WRITE_BUFFER_SIZE)) {
                        os.write((getCurrentTestName() + "\n").getBytes(StandardCharsets.UTF_8));
                    }

                    Path file2 = clientFolder.resolve("file-2.txt");
                    String file2Path = Utils.resolveRelativeRemotePath(parentPath, file2);
                    Path file3 = clientFolder.resolve("file-3.txt");
                    String file3Path = Utils.resolveRelativeRemotePath(parentPath, file3);
                    try {
                        sftp.rename(file2Path, file3Path);
                        fail("Unxpected rename success of " + file2Path + " => " + file3Path);
                    } catch (org.apache.sshd.common.subsystem.sftp.SftpException e) {
                        assertEquals("Mismatched status for failed rename of " + file2Path + " => " + file3Path, SftpConstants.SSH_FX_NO_SUCH_FILE, e.getStatus());
                    }

                    try (OutputStream os = sftp.write(file2Path, SftpClient.MIN_WRITE_BUFFER_SIZE)) {
                        os.write("h".getBytes(StandardCharsets.UTF_8));
                    }

                    try {
                        sftp.rename(file1Path, file2Path);
                        fail("Unxpected rename success of " + file1Path + " => " + file2Path);
                    } catch (org.apache.sshd.common.subsystem.sftp.SftpException e) {
                        assertEquals("Mismatched status for failed rename of " + file1Path + " => " + file2Path, SftpConstants.SSH_FX_FILE_ALREADY_EXISTS, e.getStatus());
                    }

                    sftp.rename(file1Path, file2Path, SftpClient.CopyMode.Overwrite);
                }
            } finally {
                client.stop();
            }
        }
    }

    @Test
    public void testServerExtensionsDeclarations() throws Exception {
        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                try (SftpClient sftp = session.createSftpClient()) {
                    Map<String, byte[]> extensions = sftp.getServerExtensions();
                    for (String name : new String[]{
                        SftpConstants.EXT_NEWLINE, SftpConstants.EXT_VERSIONS,
                        SftpConstants.EXT_VENDOR_ID, SftpConstants.EXT_ACL_SUPPORTED,
                        SftpConstants.EXT_SUPPORTED, SftpConstants.EXT_SUPPORTED2
                    }) {
                        assertTrue("Missing extension=" + name, extensions.containsKey(name));
                    }

                    Map<String, ?> data = ParserUtils.parse(extensions);
                    for (Map.Entry<String, ?> de : data.entrySet()) {
                        String extName = de.getKey();
                        Object extValue = de.getValue();
                        outputDebugMessage("%s: %s", extName, extValue);
                        if (SftpConstants.EXT_SUPPORTED.equalsIgnoreCase(extName)) {
                            assertSupportedExtensions(extName, ((Supported) extValue).extensionNames);
                        } else if (SftpConstants.EXT_SUPPORTED2.equalsIgnoreCase(extName)) {
                            assertSupportedExtensions(extName, ((Supported2) extValue).extensionNames);
                        } else if (SftpConstants.EXT_ACL_SUPPORTED.equalsIgnoreCase(extName)) {
                            assertSupportedAclCapabilities((AclCapabilities) extValue);
                        } else if (SftpConstants.EXT_VERSIONS.equalsIgnoreCase(extName)) {
                            assertSupportedVersions((Versions) extValue);
                        } else if (SftpConstants.EXT_NEWLINE.equalsIgnoreCase(extName)) {
                            assertNewlineValue((Newline) extValue);
                        }
                    }

                    for (String extName : extensions.keySet()) {
                        if (!data.containsKey(extName)) {
                            outputDebugMessage("No parser for extension=%s", extName);
                        }
                    }

                    for (OpenSSHExtension expected : SftpSubsystem.DEFAULT_OPEN_SSH_EXTENSIONS) {
                        String name = expected.getName();
                        Object value = data.get(name);
                        assertNotNull("OpenSSH extension not declared: " + name, value);

                        OpenSSHExtension actual = (OpenSSHExtension) value;
                        assertEquals("Mismatched version for OpenSSH extension=" + name, expected.getVersion(), actual.getVersion());
                    }

                    for (BuiltinSftpClientExtensions type : BuiltinSftpClientExtensions.VALUES) {
                        String extensionName = type.getName();
                        boolean isOpenSSHExtension = extensionName.endsWith("@openssh.com");
                        SftpClientExtension instance = sftp.getExtension(extensionName);

                        assertNotNull("Extension not implemented:" + extensionName, instance);
                        assertEquals("Mismatched instance name", extensionName, instance.getName());

                        if (instance.isSupported()) {
                            if (isOpenSSHExtension) {
                                assertTrue("Unlisted default OpenSSH extension: " + extensionName, SftpSubsystem.DEFAULT_OPEN_SSH_EXTENSIONS_NAMES.contains(extensionName));
                            }
                        } else {
                            assertTrue("Unsupported non-OpenSSH extension: " + extensionName, isOpenSSHExtension);
                            assertFalse("Unsupported default OpenSSH extension: " + extensionName, SftpSubsystem.DEFAULT_OPEN_SSH_EXTENSIONS_NAMES.contains(extensionName));
                        }
                    }
                }
            } finally {
                client.stop();
            }
        }
    }

    private static void assertSupportedExtensions(String extName, Collection<String> extensionNames) {
        assertEquals(extName + "[count]", EXPECTED_EXTENSIONS.size(), GenericUtils.size(extensionNames));

        for (Map.Entry<String, OptionalFeature> ee : EXPECTED_EXTENSIONS.entrySet()) {
            String name = ee.getKey();
            OptionalFeature f = ee.getValue();
            if (!f.isSupported()) {
                assertFalse(extName + " - unsupported feature reported: " + name, extensionNames.contains(name));
            } else {
                assertTrue(extName + " - missing " + name, extensionNames.contains(name));
            }
        }
    }

    private static void assertSupportedVersions(Versions vers) {
        List<String> values = vers.getVersions();
        assertEquals("Mismatched reported versions size: " + values,
                     1 + SftpSubsystem.HIGHER_SFTP_IMPL - SftpSubsystem.LOWER_SFTP_IMPL,
                     GenericUtils.size(values));
        for (int expected = SftpSubsystem.LOWER_SFTP_IMPL, index = 0; expected <= SftpSubsystem.HIGHER_SFTP_IMPL; expected++, index++) {
            String e = Integer.toString(expected);
            String a = values.get(index);
            assertEquals("Missing value at index=" + index + ": " + values, e, a);
        }
    }

    private static void assertNewlineValue(Newline nl) {
        assertEquals("Mismatched NL value",
                     BufferUtils.toHex(':', IoUtils.EOL.getBytes(StandardCharsets.UTF_8)),
                     BufferUtils.toHex(':', nl.getNewline().getBytes(StandardCharsets.UTF_8)));
    }

    private static void assertSupportedAclCapabilities(AclCapabilities caps) {
        Set<Integer> actual = AclCapabilities.deconstructAclCapabilities(caps.getCapabilities());
        assertEquals("Mismatched ACL capabilities count", SftpSubsystem.DEFAULT_ACL_SUPPORTED_MASK.size(), actual.size());
        assertTrue("Missing capabilities - expected=" + SftpSubsystem.DEFAULT_ACL_SUPPORTED_MASK + ", actual=" + actual,
                   actual.containsAll(SftpSubsystem.DEFAULT_ACL_SUPPORTED_MASK));
    }

    @Test
    public void testSftpVersionSelector() throws Exception {
        final AtomicInteger selected = new AtomicInteger(-1);
        SftpVersionSelector selector = new SftpVersionSelector() {
            @Override
            public int selectVersion(int current, List<Integer> available) {
                int numAvailable = GenericUtils.size(available);
                Integer maxValue = null;
                if (numAvailable == 1) {
                    maxValue = available.get(0);
                } else {
                    for (Integer v : available) {
                        if (v.intValue() == current) {
                            continue;
                        }

                        if ((maxValue == null) || (maxValue.intValue() < v.intValue())) {
                            maxValue = v;
                        }
                    }
                }

                selected.set(maxValue.intValue());
                return selected.get();
            }
        };

        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                try (SftpClient sftp = session.createSftpClient(selector)) {
                    assertEquals("Mismatched negotiated version", selected.get(), sftp.getVersion());
                    testClient(client, sftp);
                }
            } finally {
                client.stop();
            }
        }
    }

    @Test   // see SSHD-621
    public void testServerDoesNotSupportSftp() throws Exception {
        sshd.setSubsystemFactories(null);

        try (SshClient client = setupTestClient()) {
            client.start();

            try (ClientSession session = client.connect(getCurrentTestName(), TEST_LOCALHOST, port).verify(7L, TimeUnit.SECONDS).getSession()) {
                session.addPasswordIdentity(getCurrentTestName());
                session.auth().verify(5L, TimeUnit.SECONDS);

                PropertyResolverUtils.updateProperty(session, SftpClient.SFTP_CHANNEL_OPEN_TIMEOUT, TimeUnit.SECONDS.toMillis(4L));
                try (SftpClient sftp = session.createSftpClient()) {
                    fail("Unexpected SFTP client creation success");
                } catch (SocketTimeoutException | EOFException | WindowClosedException e) {
                    // expected - ignored
                }
            } finally {
                client.stop();
            }
        }
    }

    private void testClient(FactoryManager manager, SftpClient sftp) throws Exception {
        Path targetPath = detectTargetFolder();
        Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
        Utils.deleteRecursive(lclSftp);

        Path parentPath = targetPath.getParent();
        Path clientFolder = assertHierarchyTargetFolderExists(lclSftp).resolve("client");
        String dir = Utils.resolveRelativeRemotePath(parentPath, clientFolder);
        String file = dir + "/" + "file.txt";

        sftp.mkdir(dir);

        try (SftpClient.CloseableHandle h = sftp.open(file, EnumSet.of(SftpClient.OpenMode.Write, SftpClient.OpenMode.Create))) {
            byte[] d = "0123456789\n".getBytes(StandardCharsets.UTF_8);
            sftp.write(h, 0, d, 0, d.length);
            sftp.write(h, d.length, d, 0, d.length);

            SftpClient.Attributes attrs = sftp.stat(h);
            assertNotNull("No handle attributes", attrs);
        }

        try (SftpClient.CloseableHandle h = sftp.openDir(dir)) {
            List<SftpClient.DirEntry> dirEntries = sftp.readDir(h);
            assertNotNull("No dir entries", dirEntries);

            boolean dotFiltered = false;
            boolean dotdotFiltered = false;
            for (Iterator<SftpClient.DirEntry> it = dirEntries.iterator(); it.hasNext();) {
                SftpClient.DirEntry entry = it.next();
                String name = entry.getFilename();
                if (".".equals(name) && (!dotFiltered)) {
                    it.remove();
                    dotFiltered = true;
                } else if ("..".equals(name) && (!dotdotFiltered)) {
                    it.remove();
                    dotdotFiltered = true;
                }
            }

            assertTrue("Dot entry not listed", dotFiltered);
            assertTrue("Dot-dot entry not listed", dotdotFiltered);
            assertEquals("Mismatched number of listed entries", 1, dirEntries.size());
            assertNull("Unexpected extra entry read after listing ended", sftp.readDir(h));
        }

        sftp.remove(file);

        final int sizeFactor = Short.SIZE;
        byte[] workBuf = new byte[IoUtils.DEFAULT_COPY_SIZE * Short.SIZE];
        Factory<? extends Random> factory = manager.getRandomFactory();
        Random random = factory.create();
        random.fill(workBuf);

        try (OutputStream os = sftp.write(file)) {
            os.write(workBuf);
        }

        // force several internal read cycles to satisfy the full read
        try (InputStream is = sftp.read(file, workBuf.length / sizeFactor)) {
            int readLen = is.read(workBuf);
            assertEquals("Mismatched read data length", workBuf.length, readLen);

            int i = is.read();
            assertEquals("Unexpected read past EOF", -1, i);
        }

        SftpClient.Attributes attributes = sftp.stat(file);
        assertTrue("Test file not detected as regular", attributes.isRegularFile());

        attributes = sftp.stat(dir);
        assertTrue("Test directory not reported as such", attributes.isDirectory());

        int nb = 0;
        boolean dotFiltered = false;
        boolean dotdotFiltered = false;
        for (SftpClient.DirEntry entry : sftp.readDir(dir)) {
            assertNotNull("Unexpected null entry", entry);
            String name = entry.getFilename();
            if (".".equals(name) && (!dotFiltered)) {
                dotFiltered = true;
            } else if ("..".equals(name) && (!dotdotFiltered)) {
                dotdotFiltered = true;
            } else {
                nb++;
            }
        }
        assertTrue("Dot entry not read", dotFiltered);
        assertTrue("Dot-dot entry not read", dotdotFiltered);
        assertEquals("Mismatched read dir entries", 1, nb);

        sftp.remove(file);

        sftp.rmdir(dir);
    }

    @Test
    public void testCreateSymbolicLink() throws Exception {
        // Do not execute on windows as the file system does not support symlinks
        Assume.assumeTrue("Skip non-Unix O/S", OsUtils.isUNIX());
        List<NamedFactory<Command>> factories = sshd.getSubsystemFactories();
        assertEquals("Mismatched subsystem factories count", 1, GenericUtils.size(factories));

        NamedFactory<Command> f = factories.get(0);
        assertObjectInstanceOf("Not an SFTP subsystem factory", SftpSubsystemFactory.class, f);

        SftpSubsystemFactory factory = (SftpSubsystemFactory) f;
        final AtomicReference<LinkData> linkDataHolder = new AtomicReference<>();
        factory.addSftpEventListener(new AbstractSftpEventListenerAdapter() {
            @Override
            public void linking(ServerSession session, Path src, Path target, boolean symLink) {
                assertNull("Multiple linking calls", linkDataHolder.getAndSet(new LinkData(src, target, symLink)));
            }

            @Override
            public void linked(ServerSession session, Path src, Path target, boolean symLink, Throwable thrown) {
                LinkData data = linkDataHolder.get();
                assertNotNull("No previous linking call", data);
                assertSame("Mismatched source", data.getSource(), src);
                assertSame("Mismatched target", data.getTarget(), target);
                assertEquals("Mismatched link type", data.isSymLink(), symLink);
                assertNull("Unexpected failure", thrown);
            }
        });

        Path targetPath = detectTargetFolder();
        Path lclSftp = Utils.resolve(targetPath, SftpConstants.SFTP_SUBSYSTEM_NAME, getClass().getSimpleName(), getCurrentTestName());
        Utils.deleteRecursive(lclSftp);

        /*
         * NOTE !!! according to Jsch documentation
         * (see http://epaul.github.io/jsch-documentation/simple.javadoc/com/jcraft/jsch/ChannelSftp.html#current-directory)
         *
         *
         *         This sftp client has the concept of a current local directory and
         *         a current remote directory. These are not inherent to the protocol,
         *      but are used implicitly for all path-based commands sent to the server
         *      for the remote directory) or accessing the local file system (for the local directory).
         *
         *  Therefore we are using "absolute" remote files for this test
         */
        Path parentPath = targetPath.getParent();
        Path sourcePath = assertHierarchyTargetFolderExists(lclSftp).resolve("src.txt");
        String remSrcPath = "/" + Utils.resolveRelativeRemotePath(parentPath, sourcePath);

        String data = getCurrentTestName();
        ChannelSftp c = (ChannelSftp) session.openChannel(SftpConstants.SFTP_SUBSYSTEM_NAME);
        c.connect();
        try {
            try (InputStream dataStream = new ByteArrayInputStream(data.getBytes(StandardCharsets.UTF_8))) {
                c.put(dataStream, remSrcPath);
            }
            assertTrue("Source file not created: " + sourcePath, Files.exists(sourcePath));
            assertEquals("Mismatched stored data in " + remSrcPath, data, readFile(remSrcPath));

            Path linkPath = lclSftp.resolve("link-" + sourcePath.getFileName());
            String remLinkPath = "/" + Utils.resolveRelativeRemotePath(parentPath, linkPath);
            LinkOption[] options = IoUtils.getLinkOptions(false);
            if (Files.exists(linkPath, options)) {
                Files.delete(linkPath);
            }
            assertFalse("Target link exists before linking: " + linkPath, Files.exists(linkPath, options));

            outputDebugMessage("Symlink %s => %s", remLinkPath, remSrcPath);
            c.symlink(remSrcPath, remLinkPath);

            assertTrue("Symlink not created: " + linkPath, Files.exists(linkPath, options));
            assertEquals("Mismatched link data in " + remLinkPath, data, readFile(remLinkPath));

            String str1 = c.readlink(remLinkPath);
            String str2 = c.realpath(remSrcPath);
            assertEquals("Mismatched link vs. real path", str1, str2);
        } finally {
            c.disconnect();
        }

        assertNotNull("No symlink signalled", linkDataHolder.getAndSet(null));
    }

    protected String readFile(String path) throws Exception {
        ChannelSftp c = (ChannelSftp) session.openChannel(SftpConstants.SFTP_SUBSYSTEM_NAME);
        c.connect();

        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
             InputStream is = c.get(path)) {

            byte[] buffer = new byte[256];
            int count;
            while (-1 != (count = is.read(buffer))) {
                bos.write(buffer, 0, count);
            }

            return bos.toString();
        } finally {
            c.disconnect();
        }
    }

    protected void sendFile(String path, String data) throws Exception {
        ChannelSftp c = (ChannelSftp) session.openChannel(SftpConstants.SFTP_SUBSYSTEM_NAME);
        c.connect();
        try {
            c.put(new ByteArrayInputStream(data.getBytes(StandardCharsets.UTF_8)), path);
        } finally {
            c.disconnect();
        }
    }

    private String randomString(int size) {
        StringBuilder sb = new StringBuilder(size);
        for (int i = 0; i < size; i++) {
            sb.append((char) ((i % 10) + '0'));
        }
        return sb.toString();
    }

    static class LinkData {
        private final Path source;
        private final Path target;
        private final boolean symLink;

        LinkData(Path src, Path target, boolean symLink) {
            this.source = ValidateUtils.checkNotNull(src, "No source");
            this.target = ValidateUtils.checkNotNull(target, "No target");
            this.symLink = symLink;
        }

        public Path getSource() {
            return source;
        }

        public Path getTarget() {
            return target;
        }

        public boolean isSymLink() {
            return symLink;
        }

        @Override
        public String toString() {
            return (isSymLink() ? "Symbolic" : "Hard") + " " + getSource() + " => " + getTarget();
        }
    }
}