186 lines
4.3 KiB
Go
186 lines
4.3 KiB
Go
// Copyright 2021 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package fuzz
|
|
|
|
import (
|
|
"bytes"
|
|
"testing"
|
|
)
|
|
|
|
type mockRand struct {
|
|
values []int
|
|
counter int
|
|
b bool
|
|
}
|
|
|
|
func (mr *mockRand) uint32() uint32 {
|
|
c := mr.values[mr.counter]
|
|
mr.counter++
|
|
return uint32(c)
|
|
}
|
|
|
|
func (mr *mockRand) intn(n int) int {
|
|
c := mr.values[mr.counter]
|
|
mr.counter++
|
|
return c % n
|
|
}
|
|
|
|
func (mr *mockRand) uint32n(n uint32) uint32 {
|
|
c := mr.values[mr.counter]
|
|
mr.counter++
|
|
return uint32(c) % n
|
|
}
|
|
|
|
func (mr *mockRand) exp2() int {
|
|
c := mr.values[mr.counter]
|
|
mr.counter++
|
|
return c
|
|
}
|
|
|
|
func (mr *mockRand) bool() bool {
|
|
b := mr.b
|
|
mr.b = !mr.b
|
|
return b
|
|
}
|
|
|
|
func (mr *mockRand) save(*uint64, *uint64) {
|
|
panic("unimplemented")
|
|
}
|
|
|
|
func (mr *mockRand) restore(uint64, uint64) {
|
|
panic("unimplemented")
|
|
}
|
|
|
|
func TestByteSliceMutators(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
mutator func(*mutator, []byte) []byte
|
|
randVals []int
|
|
input []byte
|
|
expected []byte
|
|
}{
|
|
{
|
|
name: "byteSliceRemoveBytes",
|
|
mutator: byteSliceRemoveBytes,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{4},
|
|
},
|
|
{
|
|
name: "byteSliceInsertRandomBytes",
|
|
mutator: byteSliceInsertRandomBytes,
|
|
input: make([]byte, 4, 8),
|
|
expected: []byte{3, 4, 5, 0, 0, 0, 0},
|
|
},
|
|
{
|
|
name: "byteSliceDuplicateBytes",
|
|
mutator: byteSliceDuplicateBytes,
|
|
input: append(make([]byte, 0, 13), []byte{1, 2, 3, 4}...),
|
|
expected: []byte{1, 1, 2, 3, 4, 2, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceOverwriteBytes",
|
|
mutator: byteSliceOverwriteBytes,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{1, 1, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceBitFlip",
|
|
mutator: byteSliceBitFlip,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{3, 2, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceXORByte",
|
|
mutator: byteSliceXORByte,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{3, 2, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceSwapByte",
|
|
mutator: byteSliceSwapByte,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{2, 1, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceArithmeticUint8",
|
|
mutator: byteSliceArithmeticUint8,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{255, 2, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceArithmeticUint16",
|
|
mutator: byteSliceArithmeticUint16,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{1, 3, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceArithmeticUint32",
|
|
mutator: byteSliceArithmeticUint32,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{2, 2, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceArithmeticUint64",
|
|
mutator: byteSliceArithmeticUint64,
|
|
input: []byte{1, 2, 3, 4, 5, 6, 7, 8},
|
|
expected: []byte{2, 2, 3, 4, 5, 6, 7, 8},
|
|
},
|
|
{
|
|
name: "byteSliceOverwriteInterestingUint8",
|
|
mutator: byteSliceOverwriteInterestingUint8,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{255, 2, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceOverwriteInterestingUint16",
|
|
mutator: byteSliceOverwriteInterestingUint16,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{255, 127, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceOverwriteInterestingUint32",
|
|
mutator: byteSliceOverwriteInterestingUint32,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{250, 0, 0, 250},
|
|
},
|
|
{
|
|
name: "byteSliceInsertConstantBytes",
|
|
mutator: byteSliceInsertConstantBytes,
|
|
input: append(make([]byte, 0, 8), []byte{1, 2, 3, 4}...),
|
|
expected: []byte{3, 3, 3, 1, 2, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceOverwriteConstantBytes",
|
|
mutator: byteSliceOverwriteConstantBytes,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{3, 3, 3, 4},
|
|
},
|
|
{
|
|
name: "byteSliceShuffleBytes",
|
|
mutator: byteSliceShuffleBytes,
|
|
input: []byte{1, 2, 3, 4},
|
|
expected: []byte{2, 3, 1, 4},
|
|
},
|
|
{
|
|
name: "byteSliceSwapBytes",
|
|
mutator: byteSliceSwapBytes,
|
|
randVals: []int{0, 2, 0, 2},
|
|
input: append(make([]byte, 0, 9), []byte{1, 2, 3, 4}...),
|
|
expected: []byte{3, 2, 1, 4},
|
|
},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
r := &mockRand{values: []int{0, 1, 2, 3, 4, 5}}
|
|
if tc.randVals != nil {
|
|
r.values = tc.randVals
|
|
}
|
|
m := &mutator{r: r}
|
|
b := tc.mutator(m, tc.input)
|
|
if !bytes.Equal(b, tc.expected) {
|
|
t.Errorf("got %x, want %x", b, tc.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|