113 lines
2.5 KiB
Go
113 lines
2.5 KiB
Go
package encoder
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"local/encryptor"
|
|
"os"
|
|
"path"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func benchmarkBopOp(bop BOP, op int, l int, b *testing.B) {
|
|
dir, err := os.Getwd()
|
|
if err != nil {
|
|
b.Fatalf("cannot get wd: %v", err)
|
|
}
|
|
input, err := ioutil.ReadFile(path.Join(dir, "bop.go"))
|
|
if err != nil {
|
|
b.Fatalf("cannot read bop.go: %v", err)
|
|
}
|
|
for len(input) < l {
|
|
input = append(input, input...)
|
|
}
|
|
if len(input) > l {
|
|
input = input[:l]
|
|
}
|
|
switch op {
|
|
case 0:
|
|
case 1:
|
|
input = bop.Wrap(input)
|
|
}
|
|
b.N = 4
|
|
b.Run(fmt.Sprintf("%T-%v-%v", bop, op, len(input)), func(b *testing.B) {
|
|
for i := 0; i < b.N; i++ {
|
|
switch op {
|
|
case 0:
|
|
bop.Wrap([]byte(string(input)))
|
|
case 1:
|
|
bop.Unwrap([]byte(string(input)))
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
func Test_BOPs_Mem(t *testing.T) {
|
|
cases := []struct {
|
|
bop BOP
|
|
}{
|
|
{bop: &AES{Key: []byte("hello")}},
|
|
{bop: &PAR2{}},
|
|
{bop: &LZ4{}},
|
|
{bop: &Zipper{}},
|
|
}
|
|
|
|
base := 50000000
|
|
scale := 10
|
|
for _, c := range cases {
|
|
memoryRatioByOp := [4]float64{}
|
|
for op := 0; op < 4; op++ {
|
|
l := base
|
|
if op > 1 {
|
|
l *= scale
|
|
}
|
|
//name := fmt.Sprintf("%T-%d-%d", c.bop, op%2, l)
|
|
result := testing.Benchmark(func(b *testing.B) {
|
|
b.ReportAllocs()
|
|
b.SetBytes(1)
|
|
benchmarkBopOp(c.bop, op%2, l, b)
|
|
})
|
|
if result.MemBytes > 0 {
|
|
memoryRatioByOp[op] = float64(result.MemBytes) / float64(l)
|
|
}
|
|
//t.Logf("%s: %v", name, memoryRatioByOp[op])
|
|
}
|
|
for i := 0; i < 2; i++ {
|
|
t.Logf("%T-%d: %v -> %v (%v MB)", c.bop, i, memoryRatioByOp[i], memoryRatioByOp[i+2], memoryRatioByOp[i+2]*float64(scale)*float64(base)/1000/1000)
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_BOPs(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
bop BOP
|
|
}{
|
|
{name: "zipper", bop: &Zipper{}},
|
|
{name: "snapper", bop: &snapper{}},
|
|
{name: "symC", bop: &symCryptor{encryptor.NewEncryptor("", "")}},
|
|
{name: "asymC", bop: &asymCryptor{encryptor.NewEncryptor("", "")}},
|
|
{name: "salter", bop: &Salter{}},
|
|
{name: "lz4", bop: &LZ4{}},
|
|
{name: "aes", bop: &AES{Key: []byte("hello")}},
|
|
{name: "par2", bop: &PAR2{}},
|
|
{name: "b64", bop: &Base64{}},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
input := []byte(strings.Repeat("Hello world", 100))
|
|
encoded := c.bop.Wrap(input)
|
|
decoded := c.bop.Unwrap(encoded)
|
|
if string(input) != string(decoded) {
|
|
t.Errorf("BOP %v failed: len(inp)=%v, len(enc)=%v, len(dec)=%v", c.name, len(input), len(encoded), len(decoded))
|
|
}
|
|
}
|
|
}
|
|
|
|
func Test_AES_Padding(t *testing.T) {
|
|
for i := 0; i < 100; i++ {
|
|
t.Logf("%v => %v", i, len((&AES{}).getPadding(int64(i))))
|
|
}
|
|
}
|