mirrors/kitty
1
0
Fork 0
mirror of https://github.com/kovidgoyal/kitty synced 2026-07-27 18:51:41 +02:00
Code Issues Packages Projects Releases Wiki Activity

Improve testing infra for rsync roundtrip

Browse Source
This commit is contained in:
Kovid Goyal
2023-07-04 05:15:03 +05:30
parent 26c93af565
commit 678ad627b2
2 changed files with 44 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
tools/rsync/api.go
View File

@@ -192,7 +192,7 @@ func (self *Differ) CreateDelta(src io.Reader, output_callback func([]byte) erro
if err = self.finish_signature_data(); err != nil { if err = self.finish_signature_data(); err != nil {
return return
} }
if len(self.signature) == 0 { if self.signature == nil {
return fmt.Errorf("Cannot call CreateDelta() before loading a signature") return fmt.Errorf("Cannot call CreateDelta() before loading a signature")
} }
self.rsync.CreateDelta(src, self.signature, func(op Operation) error { self.rsync.CreateDelta(src, self.signature, func(op Operation) error {

69
tools/rsync/api_test.go
View File

@@ -16,22 +16,13 @@ import (
var _ = fmt.Print var _ = fmt.Print
var _ = cmp.Diff var _ = cmp.Diff
func TestRsyncRoundtrip(t *testing.T) { func run_roundtrip_test(t *testing.T, src_data, changed []byte, num_of_patches, total_patch_size int) {
src_data := make([]byte, 4*1024*1024) using_serialization := false
random.Bytes(src_data) prefix_msg := func() string {
total_patch_size := 0 q := utils.IfElse(using_serialization, "with", "without")
num_of_patches := 8 return fmt.Sprintf("Running %s serialization: src size: %d changed size: %d difference: %d\n", q, len(src_data), len(changed), len(changed)-len(src_data))
random_patch := func(data []byte) (size int) {
if offset := random.Int(len(data)); offset < len(data) {
max_size := utils.Min(257, len(data)-offset)
if size = random.Int(max_size); size > 0 {
total_patch_size += size
random.Bytes(data[offset : offset+size])
}
}
return
} }
test_equal := func(src_data, output []byte) { test_equal := func(src_data, output []byte) {
if !bytes.Equal(src_data, output) { if !bytes.Equal(src_data, output) {
first_diff := utils.Min(len(src_data), len(output)) first_diff := utils.Min(len(src_data), len(output))
@@ -41,15 +32,10 @@ func TestRsyncRoundtrip(t *testing.T) {
break break
} }
} }
t.Fatalf("Patching failed: %d extra_bytes first different byte at: %d", len(output)-len(src_data), first_diff) t.Fatalf("%sPatching failed: %d extra_bytes first different byte at: %d", prefix_msg(), len(output)-len(src_data), first_diff)
} }
} }
changed := slices.Clone(src_data)
for i := 0; i < num_of_patches; i++ {
random_patch(changed)
}
// first try just the engine without serialization // first try just the engine without serialization
p := NewPatcher(int64(len(src_data))) p := NewPatcher(int64(len(src_data)))
signature := make([]BlockHash, 0, 128) signature := make([]BlockHash, 0, 128)
@@ -74,14 +60,14 @@ func TestRsyncRoundtrip(t *testing.T) {
} }
return outputbuf.Bytes() return outputbuf.Bytes()
} }
test_equal(src_data, apply_delta(nil))
test_equal(src_data, apply_delta(signature)) test_equal(src_data, apply_delta(signature))
limit := 2 * (p.rsync.BlockSize * num_of_patches) limit := 2 * (p.rsync.BlockSize * num_of_patches)
if total_data_in_delta > limit { if limit > -1 && total_data_in_delta > limit {
t.Fatalf("Unexpectedly poor delta performance: total_patch_size: %d total_delta_size: %d limit: %d", total_patch_size, total_data_in_delta, limit) t.Fatalf("%sUnexpectedly poor delta performance: total_patch_size: %d total_delta_size: %d limit: %d", prefix_msg(), total_patch_size, total_data_in_delta, limit)
} }
// Now try with serialization // Now try with serialization
using_serialization = true
p = NewPatcher(int64(len(src_data))) p = NewPatcher(int64(len(src_data)))
sigbuf := bytes.Buffer{} sigbuf := bytes.Buffer{}
if err := p.CreateSignature(bytes.NewReader(changed), func(p []byte) error { _, err := sigbuf.Write(p); return err }); err != nil { if err := p.CreateSignature(bytes.NewReader(changed), func(p []byte) error { _, err := sigbuf.Write(p); return err }); err != nil {
@@ -112,8 +98,39 @@ func TestRsyncRoundtrip(t *testing.T) {
} }
test_equal(src_data, outputbuf.Bytes()) test_equal(src_data, outputbuf.Bytes())
if p.total_data_in_delta > limit { if limit > -1 && p.total_data_in_delta > limit {
t.Fatalf("Unexpectedly poor delta performance: total_patch_size: %d total_delta_size: %d limit: %d", total_patch_size, p.total_data_in_delta, limit) t.Fatalf("%sUnexpectedly poor delta performance: total_patch_size: %d total_delta_size: %d limit: %d", prefix_msg(), total_patch_size, p.total_data_in_delta, limit)
} }
} }
func TestRsyncRoundtrip(t *testing.T) {
src_data := make([]byte, 4*1024*1024)
random.Bytes(src_data)
total_patch_size := 0
num_of_patches := 8
random_patch := func(data []byte) (size int) {
if offset := random.Int(len(data)); offset < len(data) {
max_size := utils.Min(257, len(data)-offset)
if size = random.Int(max_size); size > 0 {
total_patch_size += size
random.Bytes(data[offset : offset+size])
}
}
return
}
changed := slices.Clone(src_data)
for i := 0; i < num_of_patches; i++ {
random_patch(changed)
}
run_roundtrip_test(t, src_data, changed, num_of_patches, total_patch_size)
run_roundtrip_test(t, src_data, []byte{}, -1, 0)
run_roundtrip_test(t, src_data, src_data, 0, 0)
// p := NewPatcher(int64(len(src_data)))
// block_size := p.rsync.BlockSize
// run_roundtrip_test(t, src_data, src_data[block_size:], 0, 0)
}