mirror of
https://gitee.com/johng/gf
synced 2026-06-08 02:27:42 +08:00
John Guo
20
.travis.yml
20
.travis.yml
@ -10,29 +10,29 @@ branches:
|
||||
- develop
|
||||
|
||||
env:
|
||||
- GO111MODULE=on
|
||||
- GO111MODULE=on
|
||||
|
||||
services:
|
||||
- mysql
|
||||
- redis-server
|
||||
- mysql
|
||||
- redis-server
|
||||
|
||||
addons:
|
||||
hosts:
|
||||
- local
|
||||
- local
|
||||
|
||||
before_install:
|
||||
- pwd
|
||||
- pwd
|
||||
|
||||
install:
|
||||
- cat /etc/hosts
|
||||
- cat /etc/hosts
|
||||
|
||||
script:
|
||||
- cd g
|
||||
- GOARCH=386 go test -v ./...
|
||||
- GOARCH=amd64 go test -v ./... -race -coverprofile=coverage.txt -covermode=atomic
|
||||
- cd g
|
||||
- GOARCH=386 go test -v ./...
|
||||
- GOARCH=amd64 go test -v ./... -race -coverprofile=coverage.txt -covermode=atomic
|
||||
|
||||
after_success:
|
||||
- bash <(curl -s https://codecov.io/bash)
|
||||
- bash <(curl -s https://codecov.io/bash)
|
||||
|
||||
|
||||
|
||||
|
||||
334
g/os/gfile/gfile_contents_test.go
Normal file
334
g/os/gfile/gfile_contents_test.go
Normal file
@ -0,0 +1,334 @@
|
||||
package gfile_test
|
||||
|
||||
import (
|
||||
"github.com/gogf/gf/g/os/gfile"
|
||||
"github.com/gogf/gf/g/test/gtest"
|
||||
"io/ioutil"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 创建测试文件
|
||||
func createTestFile(filename, content string) error {
|
||||
TempDir := testpath()
|
||||
err := ioutil.WriteFile(TempDir+filename, []byte(content), 0666)
|
||||
return err
|
||||
}
|
||||
|
||||
// 测试完删除文件或目录
|
||||
func delTestFiles(filenames string) {
|
||||
os.RemoveAll(testpath() + filenames)
|
||||
}
|
||||
|
||||
// 创建目录
|
||||
func createDir(paths string) {
|
||||
TempDir := testpath()
|
||||
os.Mkdir(TempDir+paths, 0777)
|
||||
}
|
||||
|
||||
// 统一格式化文件目录为"/"
|
||||
func formatpaths(paths []string) []string {
|
||||
for k, v := range paths {
|
||||
paths[k] = filepath.ToSlash(v)
|
||||
paths[k] = strings.Replace(paths[k], "./", "/", 1)
|
||||
}
|
||||
|
||||
return paths
|
||||
}
|
||||
|
||||
// 统一格式化文件目录为"/"
|
||||
func formatpath(paths string) string {
|
||||
paths = filepath.ToSlash(paths)
|
||||
paths = strings.Replace(paths, "./", "/", 1)
|
||||
return paths
|
||||
}
|
||||
|
||||
// 指定返回要测试的目录
|
||||
func testpath() string {
|
||||
return os.TempDir()
|
||||
}
|
||||
|
||||
func TestGetContents(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
|
||||
var (
|
||||
filepaths string = "/testfile_t1.txt"
|
||||
)
|
||||
createTestFile(filepaths, "my name is jroam")
|
||||
defer delTestFiles(filepaths)
|
||||
|
||||
gtest.Assert(gfile.GetContents(testpath()+filepaths), "my name is jroam")
|
||||
gtest.Assert(gfile.GetContents(""), "")
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestGetBinContents(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
filepaths1 string = "/testfile_t1.txt" // 文件存在时
|
||||
filepaths2 string = testpath() + "/testfile_t1_no.txt" // 文件不存在时
|
||||
readcontent []byte
|
||||
str1 string = "my name is jroam"
|
||||
)
|
||||
createTestFile(filepaths1, str1)
|
||||
defer delTestFiles(filepaths1)
|
||||
readcontent = gfile.GetBinContents(testpath() + filepaths1)
|
||||
gtest.Assert(readcontent, []byte(str1))
|
||||
|
||||
readcontent = gfile.GetBinContents(filepaths2)
|
||||
gtest.Assert(string(readcontent), "")
|
||||
|
||||
gtest.Assert(string(gfile.GetBinContents(filepaths2)), "")
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
// 截断文件为指定的大小
|
||||
func TestTruncate(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
filepaths1 string = "/testfile_GetContentsyyui.txt" //文件存在时
|
||||
err error
|
||||
files *os.File
|
||||
)
|
||||
createTestFile(filepaths1, "abcdefghijkmln")
|
||||
defer delTestFiles(filepaths1)
|
||||
err = gfile.Truncate(testpath()+filepaths1, 10)
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
//=========================检查修改文后的大小，是否与期望一致
|
||||
files, err = os.Open(testpath() + filepaths1)
|
||||
defer files.Close()
|
||||
gtest.Assert(err, nil)
|
||||
fileinfo, err2 := files.Stat()
|
||||
gtest.Assert(err2, nil)
|
||||
gtest.Assert(fileinfo.Size(), 10)
|
||||
|
||||
//====测试当为空时，是否报错
|
||||
err = gfile.Truncate("", 10)
|
||||
gtest.AssertNE(err, nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestPutContents(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
filepaths string = "/testfile_PutContents.txt"
|
||||
err error
|
||||
readcontent []byte
|
||||
)
|
||||
createTestFile(filepaths, "a")
|
||||
defer delTestFiles(filepaths)
|
||||
|
||||
err = gfile.PutContents(testpath()+filepaths, "test!")
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
//==================判断是否真正写入
|
||||
readcontent, err = ioutil.ReadFile(testpath() + filepaths)
|
||||
gtest.Assert(err, nil)
|
||||
gtest.Assert(string(readcontent), "test!")
|
||||
|
||||
err = gfile.PutContents("", "test!")
|
||||
gtest.AssertNE(err, nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestPutContentsAppend(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
filepaths string = "/testfile_PutContents.txt"
|
||||
err error
|
||||
readcontent []byte
|
||||
)
|
||||
|
||||
createTestFile(filepaths, "a")
|
||||
defer delTestFiles(filepaths)
|
||||
err = gfile.PutContentsAppend(testpath()+filepaths, "hello")
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
//==================判断是否真正写入
|
||||
readcontent, err = ioutil.ReadFile(testpath() + filepaths)
|
||||
gtest.Assert(err, nil)
|
||||
gtest.Assert(string(readcontent), "ahello")
|
||||
|
||||
err = gfile.PutContentsAppend("", "hello")
|
||||
gtest.AssertNE(err, nil)
|
||||
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
func TestPutBinContents(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
filepaths string = "/testfile_PutContents.txt"
|
||||
err error
|
||||
readcontent []byte
|
||||
)
|
||||
createTestFile(filepaths, "a")
|
||||
defer delTestFiles(filepaths)
|
||||
|
||||
err = gfile.PutBinContents(testpath()+filepaths, []byte("test!!"))
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
// 判断是否真正写入
|
||||
readcontent, err = ioutil.ReadFile(testpath() + filepaths)
|
||||
gtest.Assert(err, nil)
|
||||
gtest.Assert(string(readcontent), "test!!")
|
||||
|
||||
err = gfile.PutBinContents("", []byte("test!!"))
|
||||
gtest.AssertNE(err, nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestPutBinContentsAppend(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
filepaths string = "/testfile_PutContents.txt" //原文件内容: yy
|
||||
err error
|
||||
readcontent []byte
|
||||
)
|
||||
createTestFile(filepaths, "test!!")
|
||||
defer delTestFiles(filepaths)
|
||||
err = gfile.PutBinContentsAppend(testpath()+filepaths, []byte("word"))
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
// 判断是否真正写入
|
||||
readcontent, err = ioutil.ReadFile(testpath() + filepaths)
|
||||
gtest.Assert(err, nil)
|
||||
gtest.Assert(string(readcontent), "test!!word")
|
||||
|
||||
err = gfile.PutBinContentsAppend("", []byte("word"))
|
||||
gtest.AssertNE(err, nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestGetBinContentsByTwoOffsetsByPath(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
filepaths string = "/testfile_GetContents.txt" // 文件内容: abcdefghijk
|
||||
readcontent []byte
|
||||
)
|
||||
|
||||
createTestFile(filepaths, "abcdefghijk")
|
||||
defer delTestFiles(filepaths)
|
||||
readcontent = gfile.GetBinContentsByTwoOffsetsByPath(testpath()+filepaths, 2, 5)
|
||||
|
||||
gtest.Assert(string(readcontent), "cde")
|
||||
|
||||
readcontent = gfile.GetBinContentsByTwoOffsetsByPath("", 2, 5)
|
||||
gtest.Assert(len(readcontent), 0)
|
||||
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
func TestGetNextCharOffsetByPath(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
filepaths string = "/testfile_GetContents.txt" // 文件内容: abcdefghijk
|
||||
localindex int64
|
||||
)
|
||||
createTestFile(filepaths, "abcdefghijk")
|
||||
defer delTestFiles(filepaths)
|
||||
localindex = gfile.GetNextCharOffsetByPath(testpath()+filepaths, 'd', 1)
|
||||
gtest.Assert(localindex, 3)
|
||||
|
||||
localindex = gfile.GetNextCharOffsetByPath("", 'd', 1)
|
||||
gtest.Assert(localindex, -1)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestGetNextCharOffset(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
localindex int64
|
||||
)
|
||||
reader := strings.NewReader("helloword")
|
||||
|
||||
localindex = gfile.GetNextCharOffset(reader, 'w', 1)
|
||||
gtest.Assert(localindex, 5)
|
||||
|
||||
localindex = gfile.GetNextCharOffset(reader, 'j', 1)
|
||||
gtest.Assert(localindex, -1)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestGetBinContentsByTwoOffsets(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
reads []byte
|
||||
)
|
||||
reader := strings.NewReader("helloword")
|
||||
|
||||
reads = gfile.GetBinContentsByTwoOffsets(reader, 1, 3)
|
||||
gtest.Assert(string(reads), "el")
|
||||
|
||||
reads = gfile.GetBinContentsByTwoOffsets(reader, 10, 30)
|
||||
gtest.Assert(string(reads), "")
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestGetBinContentsTilChar(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
reads []byte
|
||||
indexs int64
|
||||
)
|
||||
reader := strings.NewReader("helloword")
|
||||
|
||||
reads, _ = gfile.GetBinContentsTilChar(reader, 'w', 2)
|
||||
gtest.Assert(string(reads), "llow")
|
||||
|
||||
_, indexs = gfile.GetBinContentsTilChar(reader, 'w', 20)
|
||||
gtest.Assert(indexs, -1)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestGetBinContentsTilCharByPath(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
reads []byte
|
||||
indexs int64
|
||||
filepaths string = "/testfile_GetContents.txt"
|
||||
)
|
||||
|
||||
createTestFile(filepaths, "abcdefghijklmn")
|
||||
defer delTestFiles(filepaths)
|
||||
|
||||
reads, _ = gfile.GetBinContentsTilCharByPath(testpath()+filepaths, 'c', 2)
|
||||
gtest.Assert(string(reads), "c")
|
||||
|
||||
reads, _ = gfile.GetBinContentsTilCharByPath(testpath()+filepaths, 'y', 1)
|
||||
gtest.Assert(string(reads), "")
|
||||
|
||||
_, indexs = gfile.GetBinContentsTilCharByPath(testpath()+filepaths, 'x', 1)
|
||||
gtest.Assert(indexs, -1)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestHome(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
reads string
|
||||
err error
|
||||
)
|
||||
|
||||
reads, err = gfile.Home()
|
||||
gtest.Assert(err, nil)
|
||||
gtest.AssertNE(reads, "")
|
||||
|
||||
})
|
||||
}
|
||||
63
g/os/gfile/gfile_search_test.go
Normal file
63
g/os/gfile/gfile_search_test.go
Normal file
@ -0,0 +1,63 @@
|
||||
package gfile_test
|
||||
|
||||
import (
|
||||
"github.com/gogf/gf/g/os/gfile"
|
||||
"github.com/gogf/gf/g/test/gtest"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestSearch(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string = "/testfiless"
|
||||
paths2 string = "./testfile/dirfiles_no"
|
||||
tpath string
|
||||
tpath2 string
|
||||
tempstr string
|
||||
ypaths1 string
|
||||
err error
|
||||
)
|
||||
|
||||
createDir(paths1)
|
||||
defer delTestFiles(paths1)
|
||||
ypaths1 = paths1
|
||||
|
||||
tpath, err = gfile.Search(testpath() + paths1)
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
tpath = filepath.ToSlash(tpath)
|
||||
|
||||
// 自定义优先路径
|
||||
tpath2, err = gfile.Search(testpath() + paths1)
|
||||
gtest.Assert(err, nil)
|
||||
tpath2 = filepath.ToSlash(tpath2)
|
||||
|
||||
tempstr = testpath()
|
||||
paths1 = tempstr + paths1
|
||||
paths1 = filepath.ToSlash(paths1)
|
||||
|
||||
gtest.Assert(tpath, paths1)
|
||||
|
||||
gtest.Assert(tpath2, tpath)
|
||||
|
||||
// 测试给定目录
|
||||
tpath2, err = gfile.Search(paths1, "testfiless")
|
||||
tpath2 = filepath.ToSlash(tpath2)
|
||||
tempss := filepath.ToSlash(paths1)
|
||||
gtest.Assert(tpath2, tempss)
|
||||
|
||||
// 测试当前目录
|
||||
tempstr, _ = filepath.Abs("./")
|
||||
tempstr = testpath()
|
||||
paths1 = tempstr + ypaths1
|
||||
paths1 = filepath.ToSlash(paths1)
|
||||
|
||||
gtest.Assert(tpath2, paths1)
|
||||
|
||||
// 测试目录不存在时
|
||||
_, err = gfile.Search(paths2)
|
||||
gtest.AssertNE(err, nil)
|
||||
|
||||
})
|
||||
}
|
||||
59
g/os/gfile/gfile_size_test.go
Normal file
59
g/os/gfile/gfile_size_test.go
Normal file
@ -0,0 +1,59 @@
|
||||
package gfile_test
|
||||
|
||||
import (
|
||||
"github.com/gogf/gf/g/os/gfile"
|
||||
"github.com/gogf/gf/g/test/gtest"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestSize(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string = "/testfile_t1.txt"
|
||||
sizes int64
|
||||
)
|
||||
|
||||
createTestFile(paths1, "abcdefghijklmn")
|
||||
defer delTestFiles(paths1)
|
||||
|
||||
sizes = gfile.Size(testpath() + paths1)
|
||||
gtest.Assert(sizes, 14)
|
||||
|
||||
sizes = gfile.Size("")
|
||||
gtest.Assert(sizes, 0)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestFormatSize(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
gtest.Assert(gfile.FormatSize(0), "0.00B")
|
||||
gtest.Assert(gfile.FormatSize(16), "16.00B")
|
||||
|
||||
gtest.Assert(gfile.FormatSize(1024), "1.00K")
|
||||
|
||||
gtest.Assert(gfile.FormatSize(16000000), "15.26M")
|
||||
|
||||
gtest.Assert(gfile.FormatSize(1600000000), "1.49G")
|
||||
|
||||
gtest.Assert(gfile.FormatSize(9600000000000), "8.73T")
|
||||
gtest.Assert(gfile.FormatSize(9600000000000000), "8.53P")
|
||||
|
||||
gtest.Assert(gfile.FormatSize(9600000000000000000), "TooLarge")
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestReadableSize(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
|
||||
var (
|
||||
paths1 string = "/testfile_t1.txt"
|
||||
)
|
||||
createTestFile(paths1, "abcdefghijklmn")
|
||||
defer delTestFiles(paths1)
|
||||
gtest.Assert(gfile.ReadableSize(testpath()+paths1), "14.00B")
|
||||
gtest.Assert(gfile.ReadableSize(""), "0.00B")
|
||||
|
||||
})
|
||||
}
|
||||
686
g/os/gfile/gfile_test.go
Normal file
686
g/os/gfile/gfile_test.go
Normal file
@ -0,0 +1,686 @@
|
||||
package gfile_test
|
||||
|
||||
import (
|
||||
"github.com/gogf/gf/g/os/gfile"
|
||||
"github.com/gogf/gf/g/test/gtest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestIsDir(t *testing.T) {
|
||||
|
||||
gtest.Case(t, func() {
|
||||
paths := "/testfile"
|
||||
createDir(paths)
|
||||
defer delTestFiles(paths)
|
||||
|
||||
gtest.Assert(gfile.IsDir(testpath()+paths), true)
|
||||
gtest.Assert(gfile.IsDir("./testfile2"), false)
|
||||
gtest.Assert(gfile.IsDir("./testfile/tt.txt"), false)
|
||||
gtest.Assert(gfile.IsDir(""), false)
|
||||
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
func TestCreate(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
err error
|
||||
filepaths []string
|
||||
fileobj *os.File
|
||||
)
|
||||
|
||||
filepaths = append(filepaths, "/testfile_cc1.txt")
|
||||
filepaths = append(filepaths, "/testfile_cc2.txt")
|
||||
|
||||
for _, v := range filepaths {
|
||||
fileobj, err = gfile.Create(testpath() + v)
|
||||
defer delTestFiles(v)
|
||||
fileobj.Close()
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
}
|
||||
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
func TestOpen(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
err error
|
||||
files []string
|
||||
flags []bool
|
||||
fileobj *os.File
|
||||
)
|
||||
|
||||
file1 := "/testfile_nc1.txt"
|
||||
createTestFile(file1, "")
|
||||
defer delTestFiles(file1)
|
||||
|
||||
files = append(files, file1)
|
||||
flags = append(flags, true)
|
||||
|
||||
files = append(files, "./testfile/file1/c1.txt")
|
||||
flags = append(flags, false)
|
||||
|
||||
for k, v := range files {
|
||||
fileobj, err = gfile.Open(testpath() + v)
|
||||
fileobj.Close()
|
||||
if flags[k] {
|
||||
gtest.Assert(err, nil)
|
||||
} else {
|
||||
gtest.AssertNE(err, nil)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestOpenFile(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
err error
|
||||
files []string
|
||||
flags []bool
|
||||
fileobj *os.File
|
||||
)
|
||||
|
||||
files = append(files, "./testfile/file1/nc1.txt")
|
||||
flags = append(flags, false)
|
||||
|
||||
f1 := "/testfile_tt.txt"
|
||||
createTestFile(f1, "")
|
||||
defer delTestFiles(f1)
|
||||
|
||||
files = append(files, f1)
|
||||
flags = append(flags, true)
|
||||
|
||||
for k, v := range files {
|
||||
fileobj, err = gfile.OpenFile(testpath()+v, os.O_RDWR, 0666)
|
||||
fileobj.Close()
|
||||
if flags[k] {
|
||||
gtest.Assert(err, nil)
|
||||
} else {
|
||||
gtest.AssertNE(err, nil)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestOpenWithFlag(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
err error
|
||||
files []string
|
||||
flags []bool
|
||||
fileobj *os.File
|
||||
)
|
||||
|
||||
file1 := "/testfile_t1.txt"
|
||||
createTestFile(file1, "")
|
||||
defer delTestFiles(file1)
|
||||
files = append(files, file1)
|
||||
flags = append(flags, true)
|
||||
|
||||
files = append(files, "/testfiless/dirfiles/t1_no.txt")
|
||||
flags = append(flags, false)
|
||||
|
||||
for k, v := range files {
|
||||
fileobj, err = gfile.OpenWithFlag(testpath()+v, os.O_RDWR)
|
||||
fileobj.Close()
|
||||
if flags[k] {
|
||||
gtest.Assert(err, nil)
|
||||
} else {
|
||||
gtest.AssertNE(err, nil)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestOpenWithFlagPerm(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
err error
|
||||
files []string
|
||||
flags []bool
|
||||
fileobj *os.File
|
||||
)
|
||||
file1 := "/testfile_nc1.txt"
|
||||
createTestFile(file1, "")
|
||||
defer delTestFiles(file1)
|
||||
files = append(files, file1)
|
||||
flags = append(flags, true)
|
||||
|
||||
files = append(files, "/testfileyy/tt.txt")
|
||||
flags = append(flags, false)
|
||||
|
||||
for k, v := range files {
|
||||
fileobj, err = gfile.OpenWithFlagPerm(testpath()+v, os.O_RDWR, 666)
|
||||
fileobj.Close()
|
||||
if flags[k] {
|
||||
gtest.Assert(err, nil)
|
||||
} else {
|
||||
gtest.AssertNE(err, nil)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestExists(t *testing.T) {
|
||||
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
flag bool
|
||||
files []string
|
||||
flags []bool
|
||||
)
|
||||
|
||||
file1 := "/testfile_GetContents.txt"
|
||||
createTestFile(file1, "")
|
||||
defer delTestFiles(file1)
|
||||
|
||||
files = append(files, file1)
|
||||
flags = append(flags, true)
|
||||
|
||||
files = append(files, "./testfile/havefile1/tt_no.txt")
|
||||
flags = append(flags, false)
|
||||
|
||||
for k, v := range files {
|
||||
flag = gfile.Exists(testpath() + v)
|
||||
if flags[k] {
|
||||
gtest.Assert(flag, true)
|
||||
} else {
|
||||
gtest.Assert(flag, false)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestPwd(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
paths, err := os.Getwd()
|
||||
gtest.Assert(err, nil)
|
||||
gtest.Assert(gfile.Pwd(), paths)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestIsFile(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
flag bool
|
||||
files []string
|
||||
flags []bool
|
||||
)
|
||||
|
||||
file1 := "/testfile_tt.txt"
|
||||
createTestFile(file1, "")
|
||||
defer delTestFiles(file1)
|
||||
files = append(files, file1)
|
||||
flags = append(flags, true)
|
||||
|
||||
dir1 := "/testfiless"
|
||||
createDir(dir1)
|
||||
defer delTestFiles(dir1)
|
||||
files = append(files, dir1)
|
||||
flags = append(flags, false)
|
||||
|
||||
files = append(files, "./testfiledd/tt1.txt")
|
||||
flags = append(flags, false)
|
||||
|
||||
for k, v := range files {
|
||||
flag = gfile.IsFile(testpath() + v)
|
||||
if flags[k] {
|
||||
gtest.Assert(flag, true)
|
||||
} else {
|
||||
gtest.Assert(flag, false)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestInfo(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
err error
|
||||
paths string = "/testfile_t1.txt"
|
||||
files os.FileInfo
|
||||
files2 os.FileInfo
|
||||
)
|
||||
|
||||
createTestFile(paths, "")
|
||||
defer delTestFiles(paths)
|
||||
files, err = gfile.Info(testpath() + paths)
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
files2, err = os.Stat(testpath() + paths)
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
gtest.Assert(files, files2)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestMove(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths string = "/ovetest"
|
||||
filepaths string = "/testfile_ttn1.txt"
|
||||
topath string = "/testfile_ttn2.txt"
|
||||
)
|
||||
createDir("/ovetest")
|
||||
createTestFile(paths+filepaths, "a")
|
||||
|
||||
defer delTestFiles(paths)
|
||||
|
||||
yfile := testpath() + paths + filepaths
|
||||
tofile := testpath() + paths + topath
|
||||
|
||||
gtest.Assert(gfile.Move(yfile, tofile), nil)
|
||||
|
||||
// 检查移动后的文件是否真实存在
|
||||
_, err := os.Stat(tofile)
|
||||
gtest.Assert(os.IsNotExist(err), false)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestRename(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths string = "/testfiles"
|
||||
ypath string = "/testfilettm1.txt"
|
||||
topath string = "/testfilettm2.txt"
|
||||
)
|
||||
createDir(paths)
|
||||
createTestFile(paths+ypath, "a")
|
||||
defer delTestFiles(paths)
|
||||
|
||||
ypath = testpath() + paths + ypath
|
||||
topath = testpath() + paths + topath
|
||||
|
||||
gtest.Assert(gfile.Rename(ypath, topath), nil)
|
||||
gtest.Assert(gfile.IsFile(topath), true)
|
||||
|
||||
gtest.AssertNE(gfile.Rename("", ""), nil)
|
||||
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
func TestCopy(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths string = "/testfile_copyfile1.txt"
|
||||
topath string = "/testfile_copyfile2.txt"
|
||||
)
|
||||
|
||||
createTestFile(paths, "")
|
||||
defer delTestFiles(paths)
|
||||
|
||||
gtest.Assert(gfile.Copy(testpath()+paths, testpath()+topath), nil)
|
||||
defer delTestFiles(topath)
|
||||
|
||||
gtest.Assert(gfile.IsFile(testpath()+topath), true)
|
||||
|
||||
gtest.AssertNE(gfile.Copy("", ""), nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestDirNames(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths string = "/testdirs"
|
||||
err error
|
||||
readlist []string
|
||||
)
|
||||
havelist := []string{
|
||||
"t1.txt",
|
||||
"t2.txt",
|
||||
}
|
||||
|
||||
// 创建测试文件
|
||||
createDir(paths)
|
||||
for _, v := range havelist {
|
||||
createTestFile(paths+"/"+v, "")
|
||||
}
|
||||
defer delTestFiles(paths)
|
||||
|
||||
readlist, err = gfile.DirNames(testpath() + paths)
|
||||
|
||||
gtest.Assert(err, nil)
|
||||
gtest.Assert(havelist, readlist)
|
||||
|
||||
_, err = gfile.DirNames("")
|
||||
gtest.AssertNE(err, nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestGlob(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths string = "/testfiles/*.txt"
|
||||
dirpath string = "/testfiles"
|
||||
err error
|
||||
resultlist []string
|
||||
)
|
||||
|
||||
havelist1 := []string{
|
||||
"t1.txt",
|
||||
"t2.txt",
|
||||
}
|
||||
|
||||
havelist2 := []string{
|
||||
testpath() + "/testfiles/t1.txt",
|
||||
testpath() + "/testfiles/t2.txt",
|
||||
}
|
||||
|
||||
//===============================构建测试文件
|
||||
createDir(dirpath)
|
||||
for _, v := range havelist1 {
|
||||
createTestFile(dirpath+"/"+v, "")
|
||||
}
|
||||
defer delTestFiles(dirpath)
|
||||
|
||||
resultlist, err = gfile.Glob(testpath()+paths, true)
|
||||
gtest.Assert(err, nil)
|
||||
gtest.Assert(resultlist, havelist1)
|
||||
|
||||
resultlist, err = gfile.Glob(testpath()+paths, false)
|
||||
|
||||
gtest.Assert(err, nil)
|
||||
gtest.Assert(formatpaths(resultlist), formatpaths(havelist2))
|
||||
|
||||
_, err = gfile.Glob("", true)
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestRemove(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths string = "/testfile_t1.txt"
|
||||
)
|
||||
createTestFile(paths, "")
|
||||
gtest.Assert(gfile.Remove(testpath()+paths), nil)
|
||||
|
||||
gtest.Assert(gfile.Remove(""), nil)
|
||||
|
||||
defer delTestFiles(paths)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestIsReadable(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string = "/testfile_GetContents.txt"
|
||||
paths2 string = "./testfile_GetContents_no.txt"
|
||||
)
|
||||
|
||||
createTestFile(paths1, "")
|
||||
defer delTestFiles(paths1)
|
||||
|
||||
gtest.Assert(gfile.IsReadable(testpath()+paths1), true)
|
||||
gtest.Assert(gfile.IsReadable(paths2), false)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestIsWritable(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string = "/testfile_GetContents.txt"
|
||||
paths2 string = "./testfile_GetContents_no.txt"
|
||||
)
|
||||
|
||||
createTestFile(paths1, "")
|
||||
defer delTestFiles(paths1)
|
||||
gtest.Assert(gfile.IsWritable(testpath()+paths1), true)
|
||||
gtest.Assert(gfile.IsWritable(paths2), false)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestChmod(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string = "/testfile_GetContents.txt"
|
||||
paths2 string = "./testfile_GetContents_no.txt"
|
||||
)
|
||||
createTestFile(paths1, "")
|
||||
defer delTestFiles(paths1)
|
||||
|
||||
gtest.Assert(gfile.Chmod(testpath()+paths1, 0777), nil)
|
||||
gtest.AssertNE(gfile.Chmod(paths2, 0777), nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestScanDir(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string = "/testfiledirs"
|
||||
files []string
|
||||
err error
|
||||
)
|
||||
|
||||
createDir(paths1)
|
||||
createTestFile(paths1+"/t1.txt", "")
|
||||
createTestFile(paths1+"/t2.txt", "")
|
||||
defer delTestFiles(paths1)
|
||||
|
||||
files, err = gfile.ScanDir(testpath()+paths1, "t*")
|
||||
|
||||
result := []string{
|
||||
testpath() + paths1 + "/t1.txt",
|
||||
testpath() + paths1 + "/t2.txt",
|
||||
}
|
||||
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
gtest.Assert(formatpaths(files), formatpaths(result))
|
||||
|
||||
_, err = gfile.ScanDir("", "t*")
|
||||
gtest.AssertNE(err, nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
// 获取绝对目录地址
|
||||
func TestRealPath(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string = "/testfile_files"
|
||||
readlPath string
|
||||
|
||||
tempstr string
|
||||
)
|
||||
|
||||
createDir(paths1)
|
||||
defer delTestFiles(paths1)
|
||||
|
||||
readlPath = gfile.RealPath("./")
|
||||
|
||||
tempstr, _ = filepath.Abs("./")
|
||||
|
||||
gtest.Assert(readlPath, tempstr)
|
||||
|
||||
gtest.Assert(gfile.RealPath("./nodirs"), "")
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
// 获取当前执行文件的目录
|
||||
func TestSelfPath(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string
|
||||
readlPath string
|
||||
tempstr string
|
||||
)
|
||||
readlPath = gfile.SelfPath()
|
||||
readlPath = filepath.ToSlash(readlPath)
|
||||
|
||||
tempstr, _ = filepath.Abs(os.Args[0])
|
||||
paths1 = filepath.ToSlash(tempstr)
|
||||
paths1 = strings.Replace(paths1, "./", "/", 1)
|
||||
|
||||
gtest.Assert(readlPath, paths1)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestSelfDir(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string
|
||||
readlPath string
|
||||
tempstr string
|
||||
)
|
||||
readlPath = gfile.SelfDir()
|
||||
|
||||
tempstr, _ = filepath.Abs(os.Args[0])
|
||||
paths1 = filepath.Dir(tempstr)
|
||||
|
||||
gtest.Assert(readlPath, paths1)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestBasename(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string = "/testfilerr_GetContents.txt"
|
||||
readlPath string
|
||||
)
|
||||
|
||||
createTestFile(paths1, "")
|
||||
defer delTestFiles(paths1)
|
||||
|
||||
readlPath = gfile.Basename(testpath() + paths1)
|
||||
gtest.Assert(readlPath, "testfilerr_GetContents.txt")
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestDir(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string = "/testfiless"
|
||||
readlPath string
|
||||
)
|
||||
createDir(paths1)
|
||||
defer delTestFiles(paths1)
|
||||
|
||||
readlPath = gfile.Dir(testpath() + paths1)
|
||||
|
||||
gtest.Assert(readlPath, testpath())
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
// 获取文件名
|
||||
func TestExt(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
paths1 string = "/testfile_GetContents.txt"
|
||||
dirpath1 = "/testdirs"
|
||||
)
|
||||
createTestFile(paths1, "")
|
||||
defer delTestFiles(paths1)
|
||||
|
||||
createDir(dirpath1)
|
||||
defer delTestFiles(dirpath1)
|
||||
|
||||
gtest.Assert(gfile.Ext(testpath()+paths1), ".txt")
|
||||
gtest.Assert(gfile.Ext(testpath()+dirpath1), "")
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestTempDir(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
tpath string
|
||||
)
|
||||
|
||||
tpath = gfile.TempDir()
|
||||
gtest.Assert(tpath, os.TempDir())
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestMkdir(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
tpath string = "/testfile/createdir"
|
||||
err error
|
||||
)
|
||||
|
||||
defer delTestFiles("/testfile")
|
||||
|
||||
err = gfile.Mkdir(testpath() + tpath)
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
err = gfile.Mkdir("")
|
||||
gtest.AssertNE(err, nil)
|
||||
|
||||
err = gfile.Mkdir(testpath() + tpath + "2/t1")
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestStat(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
tpath1 string = "/testfile_t1.txt"
|
||||
tpath2 string = "./testfile_t1_no.txt"
|
||||
err error
|
||||
fileiofo os.FileInfo
|
||||
)
|
||||
|
||||
createTestFile(tpath1, "a")
|
||||
defer delTestFiles(tpath1)
|
||||
|
||||
fileiofo, err = gfile.Stat(testpath() + tpath1)
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
gtest.Assert(fileiofo.Size(), 1)
|
||||
|
||||
_, err = gfile.Stat(tpath2)
|
||||
gtest.AssertNE(err, nil)
|
||||
|
||||
})
|
||||
}
|
||||
|
||||
func TestMainPkgPath(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
reads string
|
||||
)
|
||||
|
||||
reads = gfile.MainPkgPath()
|
||||
gtest.Assert(reads, "")
|
||||
|
||||
})
|
||||
}
|
||||
45
g/os/gfile/gfile_time_test.go
Normal file
45
g/os/gfile/gfile_time_test.go
Normal file
@ -0,0 +1,45 @@
|
||||
package gfile_test
|
||||
|
||||
import (
|
||||
"github.com/gogf/gf/g/os/gfile"
|
||||
"github.com/gogf/gf/g/test/gtest"
|
||||
"os"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestMTime(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
|
||||
var (
|
||||
file1 string = "/testfile_t1.txt"
|
||||
err error
|
||||
fileobj os.FileInfo
|
||||
)
|
||||
|
||||
createTestFile(file1, "")
|
||||
defer delTestFiles(file1)
|
||||
fileobj, err = os.Stat(testpath() + file1)
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
gtest.Assert(gfile.MTime(testpath()+file1), fileobj.ModTime().Unix())
|
||||
gtest.Assert(gfile.MTime(""), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestMTimeMillisecond(t *testing.T) {
|
||||
gtest.Case(t, func() {
|
||||
var (
|
||||
file1 string = "/testfile_t1.txt"
|
||||
err error
|
||||
fileobj os.FileInfo
|
||||
)
|
||||
|
||||
createTestFile(file1, "")
|
||||
defer delTestFiles(file1)
|
||||
fileobj, err = os.Stat(testpath() + file1)
|
||||
gtest.Assert(err, nil)
|
||||
|
||||
gtest.AssertGTE(gfile.MTimeMillisecond(testpath()+file1), fileobj.ModTime().Nanosecond()/1000000)
|
||||
gtest.Assert(gfile.MTimeMillisecond(""), 0)
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user