112 lines
2.0 KiB
Go
112 lines
2.0 KiB
Go
// +build windows
|
|
|
|
package tools
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/git-lfs/git-lfs/errors"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestCloneFile(t *testing.T) {
|
|
testDir := os.Getenv("REFS_TEST_DIR")
|
|
if testDir == "" {
|
|
testDir, _ = Getwd()
|
|
}
|
|
|
|
t.Logf("testing on: %s", testDir)
|
|
|
|
supported, err := CheckCloneFileSupported(testDir)
|
|
if err != nil || !supported {
|
|
t.Skip(err)
|
|
}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
size int64
|
|
}{
|
|
{"Small", 123},
|
|
{"Smaller than 4K", 4*1024 - 1},
|
|
{"Equal to 4K", 4 * 1024},
|
|
{"Larger than 4K", 4*1024 + 1},
|
|
{"Smaller than 64K", 64*1024 - 1},
|
|
{"Equal to 64K", 64 * 1024},
|
|
{"Larger than 64K", 64*1024 + 1},
|
|
{"Large", 12345678},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
as := assert.New(t)
|
|
|
|
src, err := ioutil.TempFile(testDir, tc.name+"_src")
|
|
as.NoError(err)
|
|
dst, err := ioutil.TempFile(testDir, tc.name+"_dst")
|
|
as.NoError(err)
|
|
|
|
srcHash, err := fillFile(src, tc.size)
|
|
as.NoError(err)
|
|
|
|
ok, err := CloneFile(dst, src)
|
|
as.NoError(err)
|
|
as.True(ok)
|
|
|
|
sha := sha256.New()
|
|
dst.Seek(0, io.SeekStart)
|
|
io.Copy(sha, dst)
|
|
dstHash := hex.EncodeToString(sha.Sum(nil))
|
|
|
|
as.Equal(srcHash, dstHash)
|
|
})
|
|
}
|
|
}
|
|
|
|
func fillFile(target *os.File, size int64) (hash string, err error) {
|
|
str := make([]byte, 1024)
|
|
for i := 0; i < 1023; i++ {
|
|
str[i] = fmt.Sprintf("%x", i%16)[0]
|
|
}
|
|
str[1023] = '\n'
|
|
|
|
for i := int64(0); i < size; i += 1024 {
|
|
_, err := target.Write(str)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
err = target.Truncate(size)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
err = target.Sync()
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
_, err = target.Seek(0, io.SeekStart)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
sha := sha256.New()
|
|
copySize, err := io.Copy(sha, target)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if size != copySize {
|
|
return "", errors.New("size mismatch")
|
|
}
|
|
|
|
return hex.EncodeToString(sha.Sum(nil)), nil
|
|
}
|