blob: 3d2502a6119f38b6fcec1e288b1faf57f0a5503a [file] [log] [blame]
package sftp
import (
"context"
"fmt"
"io"
"io/ioutil"
"net"
"os"
"runtime"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
var _ = fmt.Print
type csPair struct {
cli *Client
svr *RequestServer
svrResult chan error
}
// these must be closed in order, else client.Close will hang
func (cs csPair) Close() {
cs.svr.Close()
cs.cli.Close()
os.Remove(sock)
}
func (cs csPair) testHandler() *root {
return cs.svr.Handlers.FileGet.(*root)
}
const sock = "/tmp/rstest.sock"
func clientRequestServerPair(t *testing.T) *csPair {
skipIfWindows(t)
skipIfPlan9(t)
ready := make(chan struct{})
canReturn := make(chan struct{})
os.Remove(sock) // either this or signal handling
pair := &csPair{
svrResult: make(chan error, 1),
}
var server *RequestServer
go func() {
l, err := net.Listen("unix", sock)
if err != nil {
// neither assert nor t.Fatal reliably exit before Accept errors
panic(err)
}
close(ready)
fd, err := l.Accept()
require.NoError(t, err)
handlers := InMemHandler()
var options []RequestServerOption
if *testAllocator {
options = append(options, WithRSAllocator())
}
server = NewRequestServer(fd, handlers, options...)
close(canReturn)
err = server.Serve()
pair.svrResult <- err
}()
<-ready
defer os.Remove(sock)
c, err := net.Dial("unix", sock)
require.NoError(t, err)
client, err := NewClientPipe(c, c)
if err != nil {
t.Fatalf("unexpected error: %+v", err)
}
<-canReturn
pair.svr = server
pair.cli = client
return pair
}
func checkRequestServerAllocator(t *testing.T, p *csPair) {
if p.svr.pktMgr.alloc == nil {
return
}
checkAllocatorBeforeServerClose(t, p.svr.pktMgr.alloc)
p.Close()
checkAllocatorAfterServerClose(t, p.svr.pktMgr.alloc)
}
// after adding logging, maybe check log to make sure packet handling
// was split over more than one worker
func TestRequestSplitWrite(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
w, err := p.cli.Create("/foo")
require.NoError(t, err)
p.cli.maxPacket = 3 // force it to send in small chunks
contents := "one two three four five six seven eight nine ten"
w.Write([]byte(contents))
w.Close()
r := p.testHandler()
f, err := r.fetch("/foo")
require.NoError(t, err)
assert.Equal(t, contents, string(f.content))
checkRequestServerAllocator(t, p)
}
func TestRequestCache(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
foo := NewRequest("", "foo")
foo.ctx, foo.cancelCtx = context.WithCancel(context.Background())
bar := NewRequest("", "bar")
fh := p.svr.nextRequest(foo)
bh := p.svr.nextRequest(bar)
assert.Len(t, p.svr.openRequests, 2)
_foo, ok := p.svr.getRequest(fh)
assert.Equal(t, foo.Method, _foo.Method)
assert.Equal(t, foo.Filepath, _foo.Filepath)
assert.Equal(t, foo.Target, _foo.Target)
assert.Equal(t, foo.Flags, _foo.Flags)
assert.Equal(t, foo.Attrs, _foo.Attrs)
assert.Equal(t, foo.state, _foo.state)
assert.NotNil(t, _foo.ctx)
assert.Equal(t, _foo.Context().Err(), nil, "context is still valid")
assert.True(t, ok)
_, ok = p.svr.getRequest("zed")
assert.False(t, ok)
p.svr.closeRequest(fh)
assert.Equal(t, _foo.Context().Err(), context.Canceled, "context is now canceled")
p.svr.closeRequest(bh)
assert.Len(t, p.svr.openRequests, 0)
checkRequestServerAllocator(t, p)
}
func TestRequestCacheState(t *testing.T) {
// test operation that uses open/close
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
assert.Len(t, p.svr.openRequests, 0)
// test operation that doesn't open/close
err = p.cli.Remove("/foo")
assert.NoError(t, err)
assert.Len(t, p.svr.openRequests, 0)
checkRequestServerAllocator(t, p)
}
func putTestFile(cli *Client, path, content string) (int, error) {
w, err := cli.Create(path)
if err != nil {
return 0, err
}
defer w.Close()
return w.Write([]byte(content))
}
func getTestFile(cli *Client, path string) ([]byte, error) {
r, err := cli.Open(path)
if err != nil {
return nil, err
}
defer r.Close()
return ioutil.ReadAll(r)
}
func TestRequestWrite(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
n, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
assert.Equal(t, 5, n)
r := p.testHandler()
f, err := r.fetch("/foo")
require.NoError(t, err)
assert.False(t, f.isdir)
assert.Equal(t, f.content, []byte("hello"))
checkRequestServerAllocator(t, p)
}
func TestRequestWriteEmpty(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
n, err := putTestFile(p.cli, "/foo", "")
require.NoError(t, err)
assert.Equal(t, 0, n)
r := p.testHandler()
f, err := r.fetch("/foo")
require.NoError(t, err)
assert.False(t, f.isdir)
assert.Len(t, f.content, 0)
// lets test with an error
r.returnErr(os.ErrInvalid)
n, err = putTestFile(p.cli, "/bar", "")
require.Error(t, err)
r.returnErr(nil)
assert.Equal(t, 0, n)
checkRequestServerAllocator(t, p)
}
func TestRequestFilename(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
r := p.testHandler()
f, err := r.fetch("/foo")
require.NoError(t, err)
assert.Equal(t, f.Name(), "foo")
_, err = r.fetch("/bar")
assert.Error(t, err)
checkRequestServerAllocator(t, p)
}
func TestRequestJustRead(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
rf, err := p.cli.Open("/foo")
require.NoError(t, err)
defer rf.Close()
contents := make([]byte, 5)
n, err := rf.Read(contents)
if err != nil && err != io.EOF {
t.Fatalf("err: %v", err)
}
assert.Equal(t, 5, n)
assert.Equal(t, "hello", string(contents[0:5]))
checkRequestServerAllocator(t, p)
}
func TestRequestOpenFail(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
rf, err := p.cli.Open("/foo")
assert.Exactly(t, os.ErrNotExist, err)
assert.Nil(t, rf)
// if we return an error the sftp client will not close the handle
// ensure that we close it ourself
assert.Len(t, p.svr.openRequests, 0)
checkRequestServerAllocator(t, p)
}
func TestRequestCreate(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
fh, err := p.cli.Create("foo")
require.NoError(t, err)
err = fh.Close()
assert.NoError(t, err)
checkRequestServerAllocator(t, p)
}
func TestRequestReadAndWrite(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
file, err := p.cli.OpenFile("/foo", os.O_RDWR|os.O_CREATE)
require.NoError(t, err)
defer file.Close()
n, err := file.Write([]byte("hello"))
require.NoError(t, err)
assert.Equal(t, 5, n)
buf := make([]byte, 4)
n, err = file.ReadAt(buf, 1)
require.NoError(t, err)
assert.Equal(t, 4, n)
assert.Equal(t, []byte{'e', 'l', 'l', 'o'}, buf)
checkRequestServerAllocator(t, p)
}
func TestOpenFileExclusive(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
// first open should work
file, err := p.cli.OpenFile("/foo", os.O_RDWR|os.O_CREATE|os.O_EXCL)
require.NoError(t, err)
file.Close()
// second open should return error
_, err = p.cli.OpenFile("/foo", os.O_RDWR|os.O_CREATE|os.O_EXCL)
assert.Error(t, err)
checkRequestServerAllocator(t, p)
}
func TestOpenFileExclusiveNoSymlinkFollowing(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
// make a directory
err := p.cli.Mkdir("/foo")
require.NoError(t, err)
// make a symlink to that directory
err = p.cli.Symlink("/foo", "/foo2")
require.NoError(t, err)
// with O_EXCL, we can follow directory symlinks
file, err := p.cli.OpenFile("/foo2/bar", os.O_RDWR|os.O_CREATE|os.O_EXCL)
require.NoError(t, err)
err = file.Close()
require.NoError(t, err)
// we should have created the file above; and this create should fail.
_, err = p.cli.OpenFile("/foo/bar", os.O_RDWR|os.O_CREATE|os.O_EXCL)
require.Error(t, err)
// create a dangling symlink
err = p.cli.Symlink("/notexist", "/bar")
require.NoError(t, err)
// opening a dangling symlink with O_CREATE and O_EXCL should fail, regardless of target not existing.
_, err = p.cli.OpenFile("/bar", os.O_RDWR|os.O_CREATE|os.O_EXCL)
require.Error(t, err)
checkRequestServerAllocator(t, p)
}
func TestRequestMkdir(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
err := p.cli.Mkdir("/foo")
require.NoError(t, err)
r := p.testHandler()
f, err := r.fetch("/foo")
require.NoError(t, err)
assert.True(t, f.IsDir())
checkRequestServerAllocator(t, p)
}
func TestRequestRemove(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
r := p.testHandler()
_, err = r.fetch("/foo")
assert.NoError(t, err)
err = p.cli.Remove("/foo")
assert.NoError(t, err)
_, err = r.fetch("/foo")
assert.Equal(t, err, os.ErrNotExist)
checkRequestServerAllocator(t, p)
}
func TestRequestRename(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
content, err := getTestFile(p.cli, "/foo")
require.NoError(t, err)
require.Equal(t, []byte("hello"), content)
err = p.cli.Rename("/foo", "/bar")
require.NoError(t, err)
// file contents are now at /bar
content, err = getTestFile(p.cli, "/bar")
require.NoError(t, err)
require.Equal(t, []byte("hello"), content)
// /foo no longer exists
_, err = getTestFile(p.cli, "/foo")
require.Error(t, err)
_, err = putTestFile(p.cli, "/baz", "goodbye")
require.NoError(t, err)
content, err = getTestFile(p.cli, "/baz")
require.NoError(t, err)
require.Equal(t, []byte("goodbye"), content)
// SFTP-v2: SSH_FXP_RENAME may not overwrite existing files.
err = p.cli.Rename("/bar", "/baz")
require.Error(t, err)
// /bar and /baz are unchanged
content, err = getTestFile(p.cli, "/bar")
require.NoError(t, err)
require.Equal(t, []byte("hello"), content)
content, err = getTestFile(p.cli, "/baz")
require.NoError(t, err)
require.Equal(t, []byte("goodbye"), content)
// posix-rename@openssh.com extension allows overwriting existing files.
err = p.cli.PosixRename("/bar", "/baz")
require.NoError(t, err)
// /baz now has the contents of /bar
content, err = getTestFile(p.cli, "/baz")
require.NoError(t, err)
require.Equal(t, []byte("hello"), content)
// /bar no longer exists
_, err = getTestFile(p.cli, "/bar")
require.Error(t, err)
checkRequestServerAllocator(t, p)
}
func TestRequestRenameFail(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
_, err = putTestFile(p.cli, "/bar", "goodbye")
require.NoError(t, err)
err = p.cli.Rename("/foo", "/bar")
assert.IsType(t, &StatusError{}, err)
checkRequestServerAllocator(t, p)
}
func TestRequestStat(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
fi, err := p.cli.Stat("/foo")
require.NoError(t, err)
assert.Equal(t, fi.Name(), "foo")
assert.Equal(t, fi.Size(), int64(5))
assert.Equal(t, fi.Mode(), os.FileMode(0644))
assert.NoError(t, testOsSys(fi.Sys()))
checkRequestServerAllocator(t, p)
}
// NOTE: Setstat is a noop in the request server tests, but we want to test
// that is does nothing without crapping out.
func TestRequestSetstat(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
mode := os.FileMode(0644)
err = p.cli.Chmod("/foo", mode)
require.NoError(t, err)
fi, err := p.cli.Stat("/foo")
require.NoError(t, err)
assert.Equal(t, fi.Name(), "foo")
assert.Equal(t, fi.Size(), int64(5))
assert.Equal(t, fi.Mode(), os.FileMode(0644))
assert.NoError(t, testOsSys(fi.Sys()))
checkRequestServerAllocator(t, p)
}
func TestRequestFstat(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
fp, err := p.cli.Open("/foo")
require.NoError(t, err)
fi, err := fp.Stat()
require.NoError(t, err)
assert.Equal(t, fi.Name(), "foo")
assert.Equal(t, fi.Size(), int64(5))
assert.Equal(t, fi.Mode(), os.FileMode(0644))
assert.NoError(t, testOsSys(fi.Sys()))
checkRequestServerAllocator(t, p)
}
func TestRequestFsetstat(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
fp, err := p.cli.OpenFile("/foo", os.O_WRONLY)
require.NoError(t, err)
err = fp.Truncate(2)
fi, err := fp.Stat()
require.NoError(t, err)
assert.Equal(t, fi.Name(), "foo")
assert.Equal(t, fi.Size(), int64(2))
err = fp.Truncate(5)
require.NoError(t, err)
fi, err = fp.Stat()
require.NoError(t, err)
assert.Equal(t, fi.Name(), "foo")
assert.Equal(t, fi.Size(), int64(5))
err = fp.Close()
assert.NoError(t, err)
rf, err := p.cli.Open("/foo")
assert.NoError(t, err)
defer rf.Close()
contents := make([]byte, 20)
n, err := rf.Read(contents)
assert.EqualError(t, err, io.EOF.Error())
assert.Equal(t, 5, n)
assert.Equal(t, []byte{'h', 'e', 0, 0, 0}, contents[0:n])
checkRequestServerAllocator(t, p)
}
func TestRequestStatFail(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
fi, err := p.cli.Stat("/foo")
assert.Nil(t, fi)
assert.True(t, os.IsNotExist(err))
checkRequestServerAllocator(t, p)
}
func TestRequestLstat(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
err = p.cli.Symlink("/foo", "/bar")
require.NoError(t, err)
fi, err := p.cli.Lstat("/bar")
require.NoError(t, err)
assert.True(t, fi.Mode()&os.ModeSymlink == os.ModeSymlink)
checkRequestServerAllocator(t, p)
}
func TestRequestLink(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
err = p.cli.Link("/foo", "/bar")
require.NoError(t, err)
content, err := getTestFile(p.cli, "/bar")
assert.NoError(t, err)
assert.Equal(t, []byte("hello"), content)
checkRequestServerAllocator(t, p)
}
func TestRequestLinkFail(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
err := p.cli.Link("/foo", "/bar")
t.Log(err)
assert.True(t, os.IsNotExist(err))
checkRequestServerAllocator(t, p)
}
func TestRequestSymlink(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
err = p.cli.Symlink("/foo", "/bar")
require.NoError(t, err)
err = p.cli.Symlink("/bar", "/baz")
require.NoError(t, err)
r := p.testHandler()
fi, err := r.lfetch("/bar")
require.NoError(t, err)
assert.True(t, fi.Mode()&os.ModeSymlink == os.ModeSymlink)
fi, err = r.lfetch("/baz")
require.NoError(t, err)
assert.True(t, fi.Mode()&os.ModeSymlink == os.ModeSymlink)
content, err := getTestFile(p.cli, "/baz")
require.NoError(t, err)
assert.Equal(t, []byte("hello"), content)
checkRequestServerAllocator(t, p)
}
func TestRequestSymlinkLoop(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
err := p.cli.Symlink("/foo", "/bar")
require.NoError(t, err)
err = p.cli.Symlink("/bar", "/baz")
require.NoError(t, err)
err = p.cli.Symlink("/baz", "/foo")
require.NoError(t, err)
// test should fail if we reach this point
timer := time.NewTimer(1 * time.Second)
defer timer.Stop()
var content []byte
done := make(chan struct{})
go func() {
defer close(done)
content, err = getTestFile(p.cli, "/bar")
}()
select {
case <-timer.C:
t.Fatal("symlink loop following timed out")
return // just to let the compiler be absolutely sure
case <-done:
}
assert.Error(t, err)
assert.Len(t, content, 0)
checkRequestServerAllocator(t, p)
}
func TestRequestSymlinkDanglingFiles(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
// dangling links are ok. We will use "/foo" later.
err := p.cli.Symlink("/foo", "/bar")
require.NoError(t, err)
// creating a symlink in a non-existant directory should fail.
err = p.cli.Symlink("/dangle", "/foo/bar")
require.Error(t, err)
// creating a symlink under a dangling symlink should fail.
err = p.cli.Symlink("/dangle", "/bar/bar")
require.Error(t, err)
// opening a dangling link without O_CREATE should fail with os.IsNotExist == true
_, err = p.cli.OpenFile("/bar", os.O_RDONLY)
require.True(t, os.IsNotExist(err))
// overwriting a symlink is not allowed.
err = p.cli.Symlink("/dangle", "/bar")
require.Error(t, err)
// double symlink
err = p.cli.Symlink("/bar", "/baz")
require.NoError(t, err)
// opening a dangling link with O_CREATE should work.
_, err = putTestFile(p.cli, "/baz", "hello")
require.NoError(t, err)
// dangling link creation should create the target file itself.
content, err := getTestFile(p.cli, "/foo")
require.NoError(t, err)
assert.Equal(t, []byte("hello"), content)
// creating a symlink under a non-directory file should fail.
err = p.cli.Symlink("/dangle", "/foo/bar")
assert.Error(t, err)
checkRequestServerAllocator(t, p)
}
func TestRequestSymlinkDanglingDirectories(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
// dangling links are ok. We will use "/foo" later.
err := p.cli.Symlink("/foo", "/bar")
require.NoError(t, err)
// reading from a dangling symlink should fail.
_, err = p.cli.ReadDir("/bar")
require.True(t, os.IsNotExist(err))
// making a directory on a dangling symlink SHOULD NOT work.
err = p.cli.Mkdir("/bar")
require.Error(t, err)
// ok, now make directory, so we can test make files through the symlink.
err = p.cli.Mkdir("/foo")
require.NoError(t, err)
// should be able to make a file in that symlinked directory.
_, err = putTestFile(p.cli, "/bar/baz", "hello")
require.NoError(t, err)
// dangling directory creation should create the target directory itself.
content, err := getTestFile(p.cli, "/foo/baz")
assert.NoError(t, err)
assert.Equal(t, []byte("hello"), content)
checkRequestServerAllocator(t, p)
}
func TestRequestReadlink(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
_, err := putTestFile(p.cli, "/foo", "hello")
require.NoError(t, err)
err = p.cli.Symlink("/foo", "/bar")
require.NoError(t, err)
rl, err := p.cli.ReadLink("/bar")
assert.NoError(t, err)
assert.Equal(t, "foo", rl)
checkRequestServerAllocator(t, p)
}
func TestRequestReaddir(t *testing.T) {
p := clientRequestServerPair(t)
MaxFilelist = 22 // make not divisible by our test amount (100)
defer p.Close()
for i := 0; i < 100; i++ {
fname := fmt.Sprintf("/foo_%02d", i)
_, err := putTestFile(p.cli, fname, fname)
if err != nil {
t.Fatal("expected no error, got:", err)
}
}
_, err := p.cli.ReadDir("/foo_01")
assert.Equal(t, &StatusError{Code: sshFxFailure,
msg: " /foo_01: not a directory"}, err)
_, err = p.cli.ReadDir("/does_not_exist")
assert.Equal(t, os.ErrNotExist, err)
di, err := p.cli.ReadDir("/")
require.NoError(t, err)
require.Len(t, di, 100)
names := []string{di[18].Name(), di[81].Name()}
assert.Equal(t, []string{"foo_18", "foo_81"}, names)
assert.Len(t, p.svr.openRequests, 0)
checkRequestServerAllocator(t, p)
}
func TestRequestStatVFS(t *testing.T) {
if runtime.GOOS != "linux" && runtime.GOOS != "darwin" {
t.Skip("StatVFS is implemented on linux and darwin")
}
p := clientRequestServerPair(t)
defer p.Close()
_, ok := p.cli.HasExtension("statvfs@openssh.com")
require.True(t, ok, "request server doesn't list statvfs extension")
vfs, err := p.cli.StatVFS("/")
require.NoError(t, err)
expected, err := getStatVFSForPath("/")
require.NoError(t, err)
require.NotEqual(t, 0, expected.ID)
// check some stats
require.Equal(t, expected.Bavail, vfs.Bavail)
require.Equal(t, expected.Bfree, vfs.Bfree)
require.Equal(t, expected.Blocks, vfs.Blocks)
checkRequestServerAllocator(t, p)
}
func TestRequestStatVFSError(t *testing.T) {
if runtime.GOOS != "linux" && runtime.GOOS != "darwin" {
t.Skip("StatVFS is implemented on linux and darwin")
}
p := clientRequestServerPair(t)
defer p.Close()
_, err := p.cli.StatVFS("a missing path")
require.Error(t, err)
require.True(t, os.IsNotExist(err))
checkRequestServerAllocator(t, p)
}
func TestCleanDisconnect(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
err := p.cli.conn.Close()
require.NoError(t, err)
// server must return io.EOF after a clean client close
// with no pending open requests
err = <-p.svrResult
require.EqualError(t, err, io.EOF.Error())
checkRequestServerAllocator(t, p)
}
func TestUncleanDisconnect(t *testing.T) {
p := clientRequestServerPair(t)
defer p.Close()
foo := NewRequest("", "foo")
p.svr.nextRequest(foo)
err := p.cli.conn.Close()
require.NoError(t, err)
// the foo request above is still open after the client disconnects
// so the server will convert io.EOF to io.ErrUnexpectedEOF
err = <-p.svrResult
require.EqualError(t, err, io.ErrUnexpectedEOF.Error())
checkRequestServerAllocator(t, p)
}
func TestCleanPath(t *testing.T) {
assert.Equal(t, "/", cleanPath("/"))
assert.Equal(t, "/", cleanPath("."))
assert.Equal(t, "/", cleanPath("/."))
assert.Equal(t, "/", cleanPath("/a/.."))
assert.Equal(t, "/a/c", cleanPath("/a/b/../c"))
assert.Equal(t, "/a/c", cleanPath("/a/b/../c/"))
assert.Equal(t, "/a", cleanPath("/a/b/.."))
assert.Equal(t, "/a/b/c", cleanPath("/a/b/c"))
assert.Equal(t, "/", cleanPath("//"))
assert.Equal(t, "/a", cleanPath("/a/"))
assert.Equal(t, "/a", cleanPath("a/"))
assert.Equal(t, "/a/b/c", cleanPath("/a//b//c/"))
// filepath.ToSlash does not touch \ as char on unix systems
// so os.PathSeparator is used for windows compatible tests
bslash := string(os.PathSeparator)
assert.Equal(t, "/", cleanPath(bslash))
assert.Equal(t, "/", cleanPath(bslash+bslash))
assert.Equal(t, "/a", cleanPath(bslash+"a"+bslash))
assert.Equal(t, "/a", cleanPath("a"+bslash))
assert.Equal(t, "/a/b/c",
cleanPath(bslash+"a"+bslash+bslash+"b"+bslash+bslash+"c"+bslash))
assert.Equal(t, "/C:/a", cleanPath("C:"+bslash+"a"))
}