Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package path

import (
        "testing"
)

type PathTest struct {
        path, result string
}

var cleantests = []PathTest{
        // Already clean
        {"", "."},
        {"abc", "abc"},
        {"abc/def", "abc/def"},
        {"a/b/c", "a/b/c"},
        {".", "."},
        {"..", ".."},
        {"../..", "../.."},
        {"../../abc", "../../abc"},
        {"/abc", "/abc"},
        {"/", "/"},

        // Remove trailing slash
        {"abc/", "abc"},
        {"abc/def/", "abc/def"},
        {"a/b/c/", "a/b/c"},
        {"./", "."},
        {"../", ".."},
        {"../../", "../.."},
        {"/abc/", "/abc"},

        // Remove doubled slash
        {"abc//def//ghi", "abc/def/ghi"},
        {"//abc", "/abc"},
        {"///abc", "/abc"},
        {"//abc//", "/abc"},
        {"abc//", "abc"},

        // Remove . elements
        {"abc/./def", "abc/def"},
        {"/./abc/def", "/abc/def"},
        {"abc/.", "abc"},

        // Remove .. elements
        {"abc/def/ghi/../jkl", "abc/def/jkl"},
        {"abc/def/../ghi/../jkl", "abc/jkl"},
        {"abc/def/..", "abc"},
        {"abc/def/../..", "."},
        {"/abc/def/../..", "/"},
        {"abc/def/../../..", ".."},
        {"/abc/def/../../..", "/"},
        {"abc/def/../../../ghi/jkl/../../../mno", "../../mno"},

        // Combinations
        {"abc/./../def", "def"},
        {"abc//./../def", "def"},
        {"abc/../../././../def", "../../def"},
}

func TestClean(t *testing.T) {
        for _, test := range cleantests {
                if s := Clean(test.path); s != test.result {
                        t.Errorf("Clean(%q) = %q, want %q", test.path, s, test.result)
                }
        }
}

type SplitTest struct {
        path, dir, file string
}

var splittests = []SplitTest{
        {"a/b", "a/", "b"},
        {"a/b/", "a/b/", ""},
        {"a/", "a/", ""},
        {"a", "", "a"},
        {"/", "/", ""},
}

func TestSplit(t *testing.T) {
        for _, test := range splittests {
                if d, f := Split(test.path); d != test.dir || f != test.file {
                        t.Errorf("Split(%q) = %q, %q, want %q, %q", test.path, d, f, test.dir, test.file)
                }
        }
}

type JoinTest struct {
        elem []string
        path string
}

var jointests = []JoinTest{
        // zero parameters
        {[]string{}, ""},

        // one parameter
        {[]string{""}, ""},
        {[]string{"a"}, "a"},

        // two parameters
        {[]string{"a", "b"}, "a/b"},
        {[]string{"a", ""}, "a"},
        {[]string{"", "b"}, "b"},
        {[]string{"/", "a"}, "/a"},
        {[]string{"/", ""}, "/"},
        {[]string{"a/", "b"}, "a/b"},
        {[]string{"a/", ""}, "a"},
        {[]string{"", ""}, ""},
}

// join takes a []string and passes it to Join.
func join(elem []string, args ...string) string {
        args = elem
        return Join(args...)
}

func TestJoin(t *testing.T) {
        for _, test := range jointests {
                if p := join(test.elem); p != test.path {
                        t.Errorf("join(%q) = %q, want %q", test.elem, p, test.path)
                }
        }
}

type ExtTest struct {
        path, ext string
}

var exttests = []ExtTest{
        {"path.go", ".go"},
        {"path.pb.go", ".go"},
        {"a.dir/b", ""},
        {"a.dir/b.go", ".go"},
        {"a.dir/", ""},
}

func TestExt(t *testing.T) {
        for _, test := range exttests {
                if x := Ext(test.path); x != test.ext {
                        t.Errorf("Ext(%q) = %q, want %q", test.path, x, test.ext)
                }
        }
}

var basetests = []PathTest{
        // Already clean
        {"", "."},
        {".", "."},
        {"/.", "."},
        {"/", "/"},
        {"////", "/"},
        {"x/", "x"},
        {"abc", "abc"},
        {"abc/def", "def"},
        {"a/b/.x", ".x"},
        {"a/b/c.", "c."},
        {"a/b/c.x", "c.x"},
}

func TestBase(t *testing.T) {
        for _, test := range basetests {
                if s := Base(test.path); s != test.result {
                        t.Errorf("Base(%q) = %q, want %q", test.path, s, test.result)
                }
        }
}

var dirtests = []PathTest{
        {"", "."},
        {".", "."},
        {"/.", "/"},
        {"/", "/"},
        {"////", "/"},
        {"/foo", "/"},
        {"x/", "x"},
        {"abc", "."},
        {"abc/def", "abc"},
        {"a/b/.x", "a/b"},
        {"a/b/c.", "a/b"},
        {"a/b/c.x", "a/b"},
}

func TestDir(t *testing.T) {
        for _, test := range dirtests {
                if s := Dir(test.path); s != test.result {
                        t.Errorf("Dir(%q) = %q, want %q", test.path, s, test.result)
                }
        }
}

type IsAbsTest struct {
        path  string
        isAbs bool
}

var isAbsTests = []IsAbsTest{
        {"", false},
        {"/", true},
        {"/usr/bin/gcc", true},
        {"..", false},
        {"/a/../bb", true},
        {".", false},
        {"./", false},
        {"lala", false},
}

func TestIsAbs(t *testing.T) {
        for _, test := range isAbsTests {
                if r := IsAbs(test.path); r != test.isAbs {
                        t.Errorf("IsAbs(%q) = %v, want %v", test.path, r, test.isAbs)
                }
        }
}