syncthing/files/set_test.go

595 lines
15 KiB
Go
Raw Normal View History

2014-07-12 22:45:33 +00:00
// Copyright (C) 2014 Jakob Borg and Contributors (see the CONTRIBUTORS file).
// All rights reserved. Use of this source code is governed by an MIT-style
// license that can be found in the LICENSE file.
2014-06-01 20:50:14 +00:00
package files_test
import (
"fmt"
"sort"
"testing"
"github.com/calmh/syncthing/files"
"github.com/calmh/syncthing/lamport"
"github.com/calmh/syncthing/protocol"
2014-07-06 12:46:48 +00:00
"github.com/syndtr/goleveldb/leveldb"
"github.com/syndtr/goleveldb/leveldb/storage"
)
2014-07-06 12:46:48 +00:00
var remoteNode protocol.NodeID
func init() {
remoteNode, _ = protocol.NodeIDFromString("AIR6LPZ-7K4PTTV-UXQSMUU-CPQ5YWH-OEDFIIQ-JUG777G-2YQXXR5-YD6AWQR")
}
2014-07-12 21:06:48 +00:00
func genBlocks(n int) []protocol.BlockInfo {
b := make([]protocol.BlockInfo, n)
2014-07-06 12:46:48 +00:00
for i := range b {
h := make([]byte, 32)
for j := range h {
h[j] = byte(i + j)
}
b[i].Size = uint32(i)
b[i].Hash = h
}
return b
}
2014-07-12 21:06:48 +00:00
func globalList(s *files.Set) []protocol.FileInfo {
var fs []protocol.FileInfo
s.WithGlobal(func(f protocol.FileInfo) bool {
2014-07-06 12:46:48 +00:00
fs = append(fs, f)
return true
})
return fs
}
2014-07-12 21:06:48 +00:00
func haveList(s *files.Set, n protocol.NodeID) []protocol.FileInfo {
var fs []protocol.FileInfo
s.WithHave(n, func(f protocol.FileInfo) bool {
2014-07-06 12:46:48 +00:00
fs = append(fs, f)
return true
})
return fs
}
2014-07-12 21:06:48 +00:00
func needList(s *files.Set, n protocol.NodeID) []protocol.FileInfo {
var fs []protocol.FileInfo
s.WithNeed(n, func(f protocol.FileInfo) bool {
2014-07-06 12:46:48 +00:00
fs = append(fs, f)
return true
})
return fs
}
2014-07-12 21:06:48 +00:00
type fileList []protocol.FileInfo
func (l fileList) Len() int {
return len(l)
}
func (l fileList) Less(a, b int) bool {
return l[a].Name < l[b].Name
}
func (l fileList) Swap(a, b int) {
l[a], l[b] = l[b], l[a]
}
func TestGlobalSet(t *testing.T) {
2014-07-06 12:46:48 +00:00
lamport.Default = lamport.Clock{}
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
t.Fatal(err)
}
m := files.NewSet("test", db)
2014-07-12 21:06:48 +00:00
local0 := []protocol.FileInfo{
protocol.FileInfo{Name: "a", Version: 1000, Blocks: genBlocks(1)},
protocol.FileInfo{Name: "b", Version: 1000, Blocks: genBlocks(2)},
protocol.FileInfo{Name: "c", Version: 1000, Blocks: genBlocks(3)},
protocol.FileInfo{Name: "d", Version: 1000, Blocks: genBlocks(4)},
protocol.FileInfo{Name: "z", Version: 1000, Blocks: genBlocks(8)},
2014-07-06 12:46:48 +00:00
}
2014-07-12 21:06:48 +00:00
local1 := []protocol.FileInfo{
protocol.FileInfo{Name: "a", Version: 1000, Blocks: genBlocks(1)},
protocol.FileInfo{Name: "b", Version: 1000, Blocks: genBlocks(2)},
protocol.FileInfo{Name: "c", Version: 1000, Blocks: genBlocks(3)},
protocol.FileInfo{Name: "d", Version: 1000, Blocks: genBlocks(4)},
2014-07-06 12:46:48 +00:00
}
2014-07-12 21:06:48 +00:00
localTot := []protocol.FileInfo{
2014-07-06 12:46:48 +00:00
local0[0],
local0[1],
local0[2],
local0[3],
2014-07-12 21:06:48 +00:00
protocol.FileInfo{Name: "z", Version: 1001, Flags: protocol.FlagDeleted},
}
2014-07-12 21:06:48 +00:00
remote0 := []protocol.FileInfo{
protocol.FileInfo{Name: "a", Version: 1000, Blocks: genBlocks(1)},
protocol.FileInfo{Name: "b", Version: 1000, Blocks: genBlocks(2)},
protocol.FileInfo{Name: "c", Version: 1002, Blocks: genBlocks(5)},
}
2014-07-12 21:06:48 +00:00
remote1 := []protocol.FileInfo{
protocol.FileInfo{Name: "b", Version: 1001, Blocks: genBlocks(6)},
protocol.FileInfo{Name: "e", Version: 1000, Blocks: genBlocks(7)},
}
2014-07-12 21:06:48 +00:00
remoteTot := []protocol.FileInfo{
2014-07-06 12:46:48 +00:00
remote0[0],
remote1[0],
remote0[2],
remote1[1],
}
2014-07-12 21:06:48 +00:00
expectedGlobal := []protocol.FileInfo{
2014-07-06 12:46:48 +00:00
remote0[0],
remote1[0],
remote0[2],
localTot[3],
remote1[1],
localTot[4],
}
2014-07-12 21:06:48 +00:00
expectedLocalNeed := []protocol.FileInfo{
2014-07-06 12:46:48 +00:00
remote1[0],
remote0[2],
remote1[1],
}
2014-07-12 21:06:48 +00:00
expectedRemoteNeed := []protocol.FileInfo{
2014-07-06 12:46:48 +00:00
local0[3],
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local0)
m.ReplaceWithDelete(protocol.LocalNodeID, local1)
m.Replace(remoteNode, remote0)
m.Update(remoteNode, remote1)
2014-07-06 12:46:48 +00:00
g := globalList(m)
sort.Sort(fileList(g))
2014-07-06 12:46:48 +00:00
if fmt.Sprint(g) != fmt.Sprint(expectedGlobal) {
t.Errorf("Global incorrect;\n A: %v !=\n E: %v", g, expectedGlobal)
}
2014-07-06 12:46:48 +00:00
h := haveList(m, protocol.LocalNodeID)
sort.Sort(fileList(h))
2014-07-06 12:46:48 +00:00
if fmt.Sprint(h) != fmt.Sprint(localTot) {
t.Errorf("Have incorrect;\n A: %v !=\n E: %v", h, localTot)
}
2014-07-06 12:46:48 +00:00
h = haveList(m, remoteNode)
sort.Sort(fileList(h))
2014-07-06 12:46:48 +00:00
if fmt.Sprint(h) != fmt.Sprint(remoteTot) {
t.Errorf("Have incorrect;\n A: %v !=\n E: %v", h, remoteTot)
}
2014-07-06 12:46:48 +00:00
n := needList(m, protocol.LocalNodeID)
sort.Sort(fileList(n))
2014-07-06 12:46:48 +00:00
if fmt.Sprint(n) != fmt.Sprint(expectedLocalNeed) {
t.Errorf("Need incorrect;\n A: %v !=\n E: %v", n, expectedLocalNeed)
}
2014-07-06 12:46:48 +00:00
n = needList(m, remoteNode)
sort.Sort(fileList(n))
2014-07-06 12:46:48 +00:00
if fmt.Sprint(n) != fmt.Sprint(expectedRemoteNeed) {
t.Errorf("Need incorrect;\n A: %v !=\n E: %v", n, expectedRemoteNeed)
}
2014-07-06 12:46:48 +00:00
f := m.Get(protocol.LocalNodeID, "b")
if fmt.Sprint(f) != fmt.Sprint(localTot[1]) {
t.Errorf("Get incorrect;\n A: %v !=\n E: %v", f, localTot[1])
}
2014-07-06 12:46:48 +00:00
f = m.Get(remoteNode, "b")
if fmt.Sprint(f) != fmt.Sprint(remote1[0]) {
t.Errorf("Get incorrect;\n A: %v !=\n E: %v", f, remote1[0])
}
f = m.GetGlobal("b")
2014-07-06 12:46:48 +00:00
if fmt.Sprint(f) != fmt.Sprint(remote1[0]) {
t.Errorf("GetGlobal incorrect;\n A: %v !=\n E: %v", f, remote1[0])
}
2014-07-06 12:46:48 +00:00
f = m.Get(protocol.LocalNodeID, "zz")
if f.Name != "" {
2014-07-12 21:06:48 +00:00
t.Errorf("Get incorrect;\n A: %v !=\n E: %v", f, protocol.FileInfo{})
}
2014-07-06 12:46:48 +00:00
f = m.GetGlobal("zz")
if f.Name != "" {
2014-07-12 21:06:48 +00:00
t.Errorf("GetGlobal incorrect;\n A: %v !=\n E: %v", f, protocol.FileInfo{})
}
2014-07-06 12:46:48 +00:00
av := []protocol.NodeID{protocol.LocalNodeID, remoteNode}
a := m.Availability("a")
if !(len(a) == 2 && (a[0] == av[0] && a[1] == av[1] || a[0] == av[1] && a[1] == av[0])) {
t.Errorf("Availability incorrect;\n A: %v !=\n E: %v", a, av)
}
2014-07-06 12:46:48 +00:00
a = m.Availability("b")
if len(a) != 1 || a[0] != remoteNode {
t.Errorf("Availability incorrect;\n A: %v !=\n E: %v", a, remoteNode)
}
a = m.Availability("d")
if len(a) != 1 || a[0] != protocol.LocalNodeID {
t.Errorf("Availability incorrect;\n A: %v !=\n E: %v", a, protocol.LocalNodeID)
}
}
func TestLocalDeleted(t *testing.T) {
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
t.Fatal(err)
}
m := files.NewSet("test", db)
lamport.Default = lamport.Clock{}
2014-07-12 21:06:48 +00:00
local1 := []protocol.FileInfo{
protocol.FileInfo{Name: "a", Version: 1000},
protocol.FileInfo{Name: "b", Version: 1000},
protocol.FileInfo{Name: "c", Version: 1000},
protocol.FileInfo{Name: "d", Version: 1000},
protocol.FileInfo{Name: "z", Version: 1000, Flags: protocol.FlagDirectory},
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local1)
2014-07-12 21:06:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, []protocol.FileInfo{
local1[0],
2014-04-09 08:24:43 +00:00
// [1] removed
local1[2],
2014-04-09 08:24:43 +00:00
local1[3],
local1[4],
})
2014-07-12 21:06:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, []protocol.FileInfo{
2014-04-09 08:24:43 +00:00
local1[0],
local1[2],
// [3] removed
local1[4],
})
2014-07-12 21:06:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, []protocol.FileInfo{
2014-04-09 08:24:43 +00:00
local1[0],
local1[2],
// [4] removed
})
2014-07-12 21:06:48 +00:00
expectedGlobal1 := []protocol.FileInfo{
local1[0],
2014-07-12 21:06:48 +00:00
protocol.FileInfo{Name: "b", Version: 1001, Flags: protocol.FlagDeleted},
local1[2],
2014-07-12 21:06:48 +00:00
protocol.FileInfo{Name: "d", Version: 1002, Flags: protocol.FlagDeleted},
protocol.FileInfo{Name: "z", Version: 1003, Flags: protocol.FlagDeleted | protocol.FlagDirectory},
}
2014-07-06 12:46:48 +00:00
g := globalList(m)
sort.Sort(fileList(g))
sort.Sort(fileList(expectedGlobal1))
2014-07-06 12:46:48 +00:00
if fmt.Sprint(g) != fmt.Sprint(expectedGlobal1) {
t.Errorf("Global incorrect;\n A: %v !=\n E: %v", g, expectedGlobal1)
}
2014-07-12 21:06:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, []protocol.FileInfo{
local1[0],
2014-04-09 08:24:43 +00:00
// [2] removed
})
2014-07-12 21:06:48 +00:00
expectedGlobal2 := []protocol.FileInfo{
local1[0],
2014-07-12 21:06:48 +00:00
protocol.FileInfo{Name: "b", Version: 1001, Flags: protocol.FlagDeleted},
protocol.FileInfo{Name: "c", Version: 1004, Flags: protocol.FlagDeleted},
protocol.FileInfo{Name: "d", Version: 1002, Flags: protocol.FlagDeleted},
protocol.FileInfo{Name: "z", Version: 1003, Flags: protocol.FlagDeleted | protocol.FlagDirectory},
}
2014-07-06 12:46:48 +00:00
g = globalList(m)
sort.Sort(fileList(g))
sort.Sort(fileList(expectedGlobal2))
2014-07-06 12:46:48 +00:00
if fmt.Sprint(g) != fmt.Sprint(expectedGlobal2) {
t.Errorf("Global incorrect;\n A: %v !=\n E: %v", g, expectedGlobal2)
}
}
2014-04-13 10:41:49 +00:00
func Benchmark10kReplace(b *testing.B) {
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
b.Fatal(err)
}
2014-07-12 21:06:48 +00:00
var local []protocol.FileInfo
for i := 0; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
}
2014-04-13 10:41:49 +00:00
b.ResetTimer()
for i := 0; i < b.N; i++ {
2014-07-06 12:46:48 +00:00
m := files.NewSet("test", db)
m.ReplaceWithDelete(protocol.LocalNodeID, local)
2014-04-13 10:41:49 +00:00
}
}
func Benchmark10kUpdateChg(b *testing.B) {
2014-07-12 21:06:48 +00:00
var remote []protocol.FileInfo
for i := 0; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
remote = append(remote, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
}
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
b.Fatal(err)
}
m := files.NewSet("test", db)
m.Replace(remoteNode, remote)
2014-07-12 21:06:48 +00:00
var local []protocol.FileInfo
2014-04-13 10:41:49 +00:00
for i := 0; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
2014-04-13 10:41:49 +00:00
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local)
2014-04-13 10:41:49 +00:00
b.ResetTimer()
for i := 0; i < b.N; i++ {
2014-04-13 10:41:49 +00:00
b.StopTimer()
for j := range local {
local[j].Version++
}
b.StartTimer()
2014-07-06 12:46:48 +00:00
m.Update(protocol.LocalNodeID, local)
}
}
2014-04-13 10:41:49 +00:00
func Benchmark10kUpdateSme(b *testing.B) {
2014-07-12 21:06:48 +00:00
var remote []protocol.FileInfo
2014-04-13 10:41:49 +00:00
for i := 0; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
remote = append(remote, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
2014-04-13 10:41:49 +00:00
}
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
b.Fatal(err)
}
m := files.NewSet("test", db)
m.Replace(remoteNode, remote)
2014-07-12 21:06:48 +00:00
var local []protocol.FileInfo
for i := 0; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local)
b.ResetTimer()
for i := 0; i < b.N; i++ {
2014-07-06 12:46:48 +00:00
m.Update(protocol.LocalNodeID, local)
}
}
2014-04-13 10:41:49 +00:00
func Benchmark10kNeed2k(b *testing.B) {
2014-07-12 21:06:48 +00:00
var remote []protocol.FileInfo
2014-04-13 10:41:49 +00:00
for i := 0; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
remote = append(remote, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
2014-04-13 10:41:49 +00:00
}
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
b.Fatal(err)
}
m := files.NewSet("test", db)
m.Replace(remoteNode, remote)
2014-07-12 21:06:48 +00:00
var local []protocol.FileInfo
2014-04-13 10:41:49 +00:00
for i := 0; i < 8000; i++ {
2014-07-12 21:06:48 +00:00
local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
}
2014-04-13 10:41:49 +00:00
for i := 8000; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 980})
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local)
b.ResetTimer()
for i := 0; i < b.N; i++ {
2014-07-06 12:46:48 +00:00
fs := needList(m, protocol.LocalNodeID)
2014-04-13 10:41:49 +00:00
if l := len(fs); l != 2000 {
b.Errorf("wrong length %d != 2k", l)
}
}
}
2014-07-06 12:46:48 +00:00
func Benchmark10kHaveFullList(b *testing.B) {
2014-07-12 21:06:48 +00:00
var remote []protocol.FileInfo
2014-04-13 10:41:49 +00:00
for i := 0; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
remote = append(remote, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
2014-04-13 10:41:49 +00:00
}
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
b.Fatal(err)
}
m := files.NewSet("test", db)
m.Replace(remoteNode, remote)
2014-07-12 21:06:48 +00:00
var local []protocol.FileInfo
2014-04-13 10:41:49 +00:00
for i := 0; i < 2000; i++ {
2014-07-12 21:06:48 +00:00
local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
2014-04-13 10:41:49 +00:00
}
for i := 2000; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 980})
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local)
2014-04-13 10:41:49 +00:00
b.ResetTimer()
for i := 0; i < b.N; i++ {
2014-07-06 12:46:48 +00:00
fs := haveList(m, protocol.LocalNodeID)
2014-04-13 10:41:49 +00:00
if l := len(fs); l != 10000 {
b.Errorf("wrong length %d != 10k", l)
}
}
}
func Benchmark10kGlobal(b *testing.B) {
2014-07-12 21:06:48 +00:00
var remote []protocol.FileInfo
for i := 0; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
remote = append(remote, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
2014-04-13 10:41:49 +00:00
}
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
b.Fatal(err)
}
m := files.NewSet("test", db)
m.Replace(remoteNode, remote)
2014-04-13 10:41:49 +00:00
2014-07-12 21:06:48 +00:00
var local []protocol.FileInfo
2014-04-13 10:41:49 +00:00
for i := 0; i < 2000; i++ {
2014-07-12 21:06:48 +00:00
local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 1000})
2014-04-13 10:41:49 +00:00
}
for i := 2000; i < 10000; i++ {
2014-07-12 21:06:48 +00:00
local = append(local, protocol.FileInfo{Name: fmt.Sprintf("file%d", i), Version: 980})
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local)
b.ResetTimer()
for i := 0; i < b.N; i++ {
2014-07-06 12:46:48 +00:00
fs := globalList(m)
2014-04-13 10:41:49 +00:00
if l := len(fs); l != 10000 {
b.Errorf("wrong length %d != 10k", l)
}
}
}
func TestGlobalReset(t *testing.T) {
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
t.Fatal(err)
}
m := files.NewSet("test", db)
2014-07-12 21:06:48 +00:00
local := []protocol.FileInfo{
protocol.FileInfo{Name: "a", Version: 1000},
protocol.FileInfo{Name: "b", Version: 1000},
protocol.FileInfo{Name: "c", Version: 1000},
protocol.FileInfo{Name: "d", Version: 1000},
}
2014-07-12 21:06:48 +00:00
remote := []protocol.FileInfo{
protocol.FileInfo{Name: "a", Version: 1000},
protocol.FileInfo{Name: "b", Version: 1001},
protocol.FileInfo{Name: "c", Version: 1002},
protocol.FileInfo{Name: "e", Version: 1000},
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local)
g := globalList(m)
sort.Sort(fileList(g))
2014-07-06 12:46:48 +00:00
if fmt.Sprint(g) != fmt.Sprint(local) {
t.Errorf("Global incorrect;\n%v !=\n%v", g, local)
}
2014-07-06 12:46:48 +00:00
m.Replace(remoteNode, remote)
m.Replace(remoteNode, nil)
2014-07-06 12:46:48 +00:00
g = globalList(m)
sort.Sort(fileList(g))
2014-07-06 12:46:48 +00:00
if fmt.Sprint(g) != fmt.Sprint(local) {
t.Errorf("Global incorrect;\n%v !=\n%v", g, local)
}
}
func TestNeed(t *testing.T) {
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
t.Fatal(err)
}
m := files.NewSet("test", db)
2014-07-12 21:06:48 +00:00
local := []protocol.FileInfo{
protocol.FileInfo{Name: "a", Version: 1000},
protocol.FileInfo{Name: "b", Version: 1000},
protocol.FileInfo{Name: "c", Version: 1000},
protocol.FileInfo{Name: "d", Version: 1000},
}
2014-07-12 21:06:48 +00:00
remote := []protocol.FileInfo{
protocol.FileInfo{Name: "a", Version: 1000},
protocol.FileInfo{Name: "b", Version: 1001},
protocol.FileInfo{Name: "c", Version: 1002},
protocol.FileInfo{Name: "e", Version: 1000},
}
2014-07-12 21:06:48 +00:00
shouldNeed := []protocol.FileInfo{
protocol.FileInfo{Name: "b", Version: 1001},
protocol.FileInfo{Name: "c", Version: 1002},
protocol.FileInfo{Name: "e", Version: 1000},
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local)
m.Replace(remoteNode, remote)
2014-07-06 12:46:48 +00:00
need := needList(m, protocol.LocalNodeID)
2014-04-09 08:24:43 +00:00
sort.Sort(fileList(need))
sort.Sort(fileList(shouldNeed))
2014-07-06 12:46:48 +00:00
if fmt.Sprint(need) != fmt.Sprint(shouldNeed) {
t.Errorf("Need incorrect;\n%v !=\n%v", need, shouldNeed)
}
}
func TestLocalVersion(t *testing.T) {
2014-07-06 12:46:48 +00:00
db, err := leveldb.Open(storage.NewMemStorage(), nil)
if err != nil {
t.Fatal(err)
}
m := files.NewSet("test", db)
2014-07-12 21:06:48 +00:00
local1 := []protocol.FileInfo{
protocol.FileInfo{Name: "a", Version: 1000},
protocol.FileInfo{Name: "b", Version: 1000},
protocol.FileInfo{Name: "c", Version: 1000},
protocol.FileInfo{Name: "d", Version: 1000},
}
2014-07-12 21:06:48 +00:00
local2 := []protocol.FileInfo{
local1[0],
// [1] deleted
local1[2],
2014-07-12 21:06:48 +00:00
protocol.FileInfo{Name: "d", Version: 1002},
protocol.FileInfo{Name: "e", Version: 1000},
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local1)
c0 := m.LocalVersion(protocol.LocalNodeID)
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local2)
c1 := m.LocalVersion(protocol.LocalNodeID)
if !(c1 > c0) {
t.Fatal("Local version number should have incremented")
}
2014-07-06 12:46:48 +00:00
m.ReplaceWithDelete(protocol.LocalNodeID, local2)
c2 := m.LocalVersion(protocol.LocalNodeID)
if c2 != c1 {
t.Fatal("Local version number should be unchanged")
}
}