Merge pull request #23 from Snider/feature-add-tdd-tests
feat: Add comprehensive TDD tests for crypt package
This commit is contained in:
Snider
GitHub
commit
8e9a7d71fa
10 changed files with 582 additions and 476 deletions
|
|
@ -182,14 +182,14 @@ func demoRSA() {
|
|||
// 2. Encrypt a message
|
||||
message := []byte("This is a secret message for RSA.")
|
||||
fmt.Printf("\nOriginal message: %s\n", message)
|
||||
ciphertext, err := cryptService.EncryptRSA(publicKey, message)
|
||||
ciphertext, err := cryptService.EncryptRSA(publicKey, message, nil)
|
||||
if err != nil {
|
||||
log.Fatalf("Failed to encrypt with RSA: %v", err)
|
||||
}
|
||||
fmt.Printf("Encrypted ciphertext (base64): %s\n", base64.StdEncoding.EncodeToString(ciphertext))
|
||||
|
||||
// 3. Decrypt the message
|
||||
decrypted, err := cryptService.DecryptRSA(privateKey, ciphertext)
|
||||
decrypted, err := cryptService.DecryptRSA(privateKey, ciphertext, nil)
|
||||
if err != nil {
|
||||
log.Fatalf("Failed to decrypt with RSA: %v", err)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,109 +0,0 @@
|
|||
package crypt
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
var service = NewService()
|
||||
|
||||
// --- Hashing Tests ---
|
||||
|
||||
func TestHash_Good(t *testing.T) {
|
||||
payload := "hello"
|
||||
// Test all supported hash types
|
||||
for _, hashType := range []HashType{LTHN, SHA512, SHA256, SHA1, MD5} {
|
||||
hash := service.Hash(hashType, payload)
|
||||
assert.NotEmpty(t, hash, "Hash should not be empty for type %s", hashType)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHash_Bad(t *testing.T) {
|
||||
// Using an unsupported hash type should default to SHA256
|
||||
hash := service.Hash("unsupported", "hello")
|
||||
expectedHash := service.Hash(SHA256, "hello")
|
||||
assert.Equal(t, expectedHash, hash)
|
||||
}
|
||||
|
||||
func TestHash_Ugly(t *testing.T) {
|
||||
// Test with potentially problematic inputs
|
||||
testCases := []string{
|
||||
"", // Empty string
|
||||
" ", // Whitespace
|
||||
"\x00\x01\x02\x03\x04", // Null bytes
|
||||
strings.Repeat("a", 1024*1024), // Large payload (1MB)
|
||||
"こんにちは", // Unicode characters
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
for _, hashType := range []HashType{LTHN, SHA512, SHA256, SHA1, MD5} {
|
||||
hash := service.Hash(hashType, tc)
|
||||
assert.NotEmpty(t, hash, "Hash for ugly input should not be empty for type %s", hashType)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- Checksum Tests ---
|
||||
|
||||
// Luhn Tests
|
||||
func TestLuhn_Good(t *testing.T) {
|
||||
assert.True(t, service.Luhn("79927398713"))
|
||||
}
|
||||
|
||||
func TestLuhn_Bad(t *testing.T) {
|
||||
assert.False(t, service.Luhn("79927398714"), "Should fail for incorrect checksum")
|
||||
assert.False(t, service.Luhn("7992739871a"), "Should fail for non-numeric input")
|
||||
}
|
||||
|
||||
func TestLuhn_Ugly(t *testing.T) {
|
||||
assert.False(t, service.Luhn(""), "Should be false for empty string")
|
||||
assert.False(t, service.Luhn(" 1 2 3 "), "Should handle spaces but result in false")
|
||||
}
|
||||
|
||||
// Fletcher16 Tests
|
||||
func TestFletcher16_Good(t *testing.T) {
|
||||
assert.Equal(t, uint16(0xC8F0), service.Fletcher16("abcde"))
|
||||
assert.Equal(t, uint16(0x2057), service.Fletcher16("abcdef"))
|
||||
assert.Equal(t, uint16(0x0627), service.Fletcher16("abcdefgh"))
|
||||
}
|
||||
|
||||
func TestFletcher16_Bad(t *testing.T) {
|
||||
// No obviously "bad" inputs that don't fall into "ugly"
|
||||
// For Fletcher, any string is a valid input.
|
||||
}
|
||||
|
||||
func TestFletcher16_Ugly(t *testing.T) {
|
||||
assert.Equal(t, uint16(0), service.Fletcher16(""), "Checksum of empty string should be 0")
|
||||
}
|
||||
|
||||
// Fletcher32 Tests
|
||||
func TestFletcher32_Good(t *testing.T) {
|
||||
assert.Equal(t, uint32(0xF04FC729), service.Fletcher32("abcde"))
|
||||
assert.Equal(t, uint32(0x56502D2A), service.Fletcher32("abcdef"))
|
||||
assert.Equal(t, uint32(0xEBE19591), service.Fletcher32("abcdefgh"))
|
||||
}
|
||||
|
||||
func TestFletcher32_Bad(t *testing.T) {
|
||||
// Any string is a valid input.
|
||||
}
|
||||
|
||||
func TestFletcher32_Ugly(t *testing.T) {
|
||||
assert.Equal(t, uint32(0), service.Fletcher32(""), "Checksum of empty string should be 0")
|
||||
}
|
||||
|
||||
// Fletcher64 Tests
|
||||
func TestFletcher64_Good(t *testing.T) {
|
||||
assert.Equal(t, uint64(0xc8c6c527646362c6), service.Fletcher64("abcde"))
|
||||
assert.Equal(t, uint64(0xc8c72b276463c8c6), service.Fletcher64("abcdef"))
|
||||
assert.Equal(t, uint64(0x312e2b28cccac8c6), service.Fletcher64("abcdefgh"))
|
||||
}
|
||||
|
||||
func TestFletcher64_Bad(t *testing.T) {
|
||||
// Any string is a valid input.
|
||||
}
|
||||
|
||||
func TestFletcher64_Ugly(t *testing.T) {
|
||||
assert.Equal(t, uint64(0), service.Fletcher64(""), "Checksum of empty string should be 0")
|
||||
}
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
package enchantrix_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/Snider/Enchantrix/pkg/enchantrix"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestTransmute(t *testing.T) {
|
||||
data := []byte("hello")
|
||||
sigils := []enchantrix.Sigil{
|
||||
&enchantrix.ReverseSigil{},
|
||||
&enchantrix.HexSigil{},
|
||||
}
|
||||
result, err := enchantrix.Transmute(data, sigils)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "6f6c6c6568", string(result))
|
||||
}
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
package enchantrix_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/Snider/Enchantrix/pkg/enchantrix"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestNewSigil(t *testing.T) {
|
||||
t.Run("ValidSigils", func(t *testing.T) {
|
||||
validNames := []string{
|
||||
"reverse", "hex", "base64", "gzip", "json", "json-indent",
|
||||
"md4", "md5", "sha1", "sha224", "sha256", "sha384", "sha512",
|
||||
"ripemd160", "sha3-224", "sha3-256", "sha3-384", "sha3-512",
|
||||
"sha512-224", "sha512-256", "blake2s-256", "blake2b-256",
|
||||
"blake2b-384", "blake2b-512",
|
||||
}
|
||||
for _, name := range validNames {
|
||||
sigil, err := enchantrix.NewSigil(name)
|
||||
assert.NoError(t, err)
|
||||
assert.NotNil(t, sigil)
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("InvalidSigil", func(t *testing.T) {
|
||||
sigil, err := enchantrix.NewSigil("invalid-sigil-name")
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, sigil)
|
||||
assert.Contains(t, err.Error(), "unknown sigil name")
|
||||
})
|
||||
}
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
package enchantrix_test
|
||||
|
||||
import (
|
||||
"crypto"
|
||||
"encoding/hex"
|
||||
"testing"
|
||||
|
||||
"github.com/Snider/Enchantrix/pkg/enchantrix"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
func TestReverseSigil(t *testing.T) {
|
||||
s := &enchantrix.ReverseSigil{}
|
||||
data := []byte("hello")
|
||||
reversed, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "olleh", string(reversed))
|
||||
original, err := s.Out(reversed)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "hello", string(original))
|
||||
}
|
||||
|
||||
func TestHexSigil(t *testing.T) {
|
||||
s := &enchantrix.HexSigil{}
|
||||
data := []byte("hello")
|
||||
encoded, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "68656c6c6f", string(encoded))
|
||||
decoded, err := s.Out(encoded)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "hello", string(decoded))
|
||||
}
|
||||
|
||||
func TestBase64Sigil(t *testing.T) {
|
||||
s := &enchantrix.Base64Sigil{}
|
||||
data := []byte("hello")
|
||||
encoded, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "aGVsbG8=", string(encoded))
|
||||
decoded, err := s.Out(encoded)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "hello", string(decoded))
|
||||
}
|
||||
|
||||
func TestGzipSigil(t *testing.T) {
|
||||
s := &enchantrix.GzipSigil{}
|
||||
data := []byte("hello")
|
||||
compressed, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
assert.NotEqual(t, data, compressed)
|
||||
decompressed, err := s.Out(compressed)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "hello", string(decompressed))
|
||||
}
|
||||
|
||||
func TestJSONSigil(t *testing.T) {
|
||||
s := &enchantrix.JSONSigil{Indent: true}
|
||||
data := []byte(`{"hello":"world"}`)
|
||||
indented, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "{\n \"hello\": \"world\"\n}", string(indented))
|
||||
s.Indent = false
|
||||
compacted, err := s.In(indented)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, `{"hello":"world"}`, string(compacted))
|
||||
}
|
||||
|
||||
func TestHashSigil(t *testing.T) {
|
||||
s := enchantrix.NewHashSigil(crypto.SHA256)
|
||||
data := []byte("hello")
|
||||
hashed, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
expectedHash := "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
|
||||
assert.Equal(t, expectedHash, hex.EncodeToString(hashed))
|
||||
unhashed, err := s.Out(hashed)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, hashed, unhashed)
|
||||
}
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
package trix
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func FuzzDecode(f *testing.F) {
|
||||
// Seed with a valid encoded Trix object
|
||||
validTrix := &Trix{
|
||||
Header: map[string]interface{}{"content_type": "text/plain"},
|
||||
Payload: []byte("hello world"),
|
||||
}
|
||||
validEncoded, _ := Encode(validTrix, "FUZZ")
|
||||
f.Add(validEncoded)
|
||||
|
||||
// Seed with the corrupted header length from the ugly test
|
||||
var buf []byte
|
||||
buf = append(buf, []byte("UGLY")...)
|
||||
buf = append(buf, byte(Version))
|
||||
buf = append(buf, []byte{0, 0, 3, 232}...) // BigEndian representation of 1000
|
||||
buf = append(buf, []byte("{}")...)
|
||||
buf = append(buf, []byte("payload")...)
|
||||
f.Add(buf)
|
||||
|
||||
// Seed with a short, invalid input
|
||||
f.Add([]byte("short"))
|
||||
|
||||
f.Fuzz(func(t *testing.T, data []byte) {
|
||||
// The fuzzer will generate random data here.
|
||||
// We just need to call our function and make sure it doesn't panic.
|
||||
// The fuzzer will report any crashes as failures.
|
||||
_, _ = Decode(data, "FUZZ")
|
||||
})
|
||||
}
|
||||
|
|
@ -1,202 +0,0 @@
|
|||
package trix
|
||||
|
||||
import (
|
||||
"io"
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"github.com/Snider/Enchantrix/pkg/crypt"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
// TestTrixEncodeDecode_Good tests the ideal "happy path" scenario for encoding and decoding.
|
||||
func TestTrixEncodeDecode_Good(t *testing.T) {
|
||||
header := map[string]interface{}{
|
||||
"content_type": "application/octet-stream",
|
||||
"encryption_algorithm": "chacha20poly1035",
|
||||
"nonce": "AAECAwQFBgcICQoLDA0ODxAREhMUFRY=",
|
||||
"created_at": "2025-10-30T12:00:00Z",
|
||||
}
|
||||
payload := []byte("This is a secret message.")
|
||||
trix := &Trix{Header: header, Payload: payload}
|
||||
magicNumber := "TRIX"
|
||||
|
||||
encoded, err := Encode(trix, magicNumber)
|
||||
assert.NoError(t, err)
|
||||
|
||||
decoded, err := Decode(encoded, magicNumber)
|
||||
assert.NoError(t, err)
|
||||
|
||||
assert.True(t, reflect.DeepEqual(trix.Header, decoded.Header))
|
||||
assert.Equal(t, trix.Payload, decoded.Payload)
|
||||
}
|
||||
|
||||
// TestTrixEncodeDecode_Bad tests expected failure scenarios with well-formed but invalid inputs.
|
||||
func TestTrixEncodeDecode_Bad(t *testing.T) {
|
||||
t.Run("MismatchedMagicNumber", func(t *testing.T) {
|
||||
trix := &Trix{Header: map[string]interface{}{}, Payload: []byte("payload")}
|
||||
encoded, err := Encode(trix, "GOOD")
|
||||
assert.NoError(t, err)
|
||||
|
||||
_, err = Decode(encoded, "BAD!")
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "invalid magic number")
|
||||
})
|
||||
|
||||
t.Run("InvalidMagicNumberLength", func(t *testing.T) {
|
||||
trix := &Trix{Header: map[string]interface{}{}, Payload: []byte("payload")}
|
||||
_, err := Encode(trix, "TOOLONG")
|
||||
assert.EqualError(t, err, "trix: magic number must be 4 bytes long")
|
||||
|
||||
_, err = Decode([]byte{}, "SHORT")
|
||||
assert.EqualError(t, err, "trix: magic number must be 4 bytes long")
|
||||
})
|
||||
|
||||
t.Run("MalformedHeaderJSON", func(t *testing.T) {
|
||||
// Create a Trix struct with a header that cannot be marshaled to JSON.
|
||||
header := map[string]interface{}{
|
||||
"unsupported": make(chan int), // Channels cannot be JSON-encoded
|
||||
}
|
||||
trix := &Trix{Header: header, Payload: []byte("payload")}
|
||||
_, err := Encode(trix, "TRIX")
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "json: unsupported type")
|
||||
})
|
||||
}
|
||||
|
||||
// TestTrixEncodeDecode_Ugly tests malicious or malformed inputs designed to cause crashes or panics.
|
||||
func TestTrixEncodeDecode_Ugly(t *testing.T) {
|
||||
magicNumber := "UGLY"
|
||||
|
||||
t.Run("CorruptedHeaderLength", func(t *testing.T) {
|
||||
// Manually construct a byte slice where the header length is larger than the actual data.
|
||||
var buf []byte
|
||||
buf = append(buf, []byte(magicNumber)...) // Magic Number
|
||||
buf = append(buf, byte(Version)) // Version
|
||||
// Header length of 1000, but the header is only 2 bytes long.
|
||||
buf = append(buf, []byte{0, 0, 3, 232}...) // BigEndian representation of 1000
|
||||
buf = append(buf, []byte("{}")...) // A minimal valid JSON header
|
||||
buf = append(buf, []byte("payload")...)
|
||||
|
||||
_, err := Decode(buf, magicNumber)
|
||||
assert.Error(t, err)
|
||||
assert.Equal(t, err, io.ErrUnexpectedEOF)
|
||||
})
|
||||
|
||||
t.Run("DataTooShort", func(t *testing.T) {
|
||||
// Data is too short to contain even the magic number.
|
||||
data := []byte("BAD")
|
||||
_, err := Decode(data, magicNumber)
|
||||
assert.Error(t, err)
|
||||
})
|
||||
|
||||
t.Run("EmptyPayload", func(t *testing.T) {
|
||||
data := []byte{}
|
||||
_, err := Decode(data, magicNumber)
|
||||
assert.Error(t, err)
|
||||
})
|
||||
|
||||
t.Run("FuzzedJSON", func(t *testing.T) {
|
||||
// A header that is technically valid but contains unexpected types.
|
||||
header := map[string]interface{}{
|
||||
"payload": map[string]interface{}{"nested": 123},
|
||||
}
|
||||
payload := []byte("some data")
|
||||
trix := &Trix{Header: header, Payload: payload}
|
||||
|
||||
encoded, err := Encode(trix, magicNumber)
|
||||
assert.NoError(t, err)
|
||||
|
||||
decoded, err := Decode(encoded, magicNumber)
|
||||
assert.NoError(t, err)
|
||||
assert.NotNil(t, decoded)
|
||||
})
|
||||
}
|
||||
|
||||
// --- Sigil Tests ---
|
||||
|
||||
func TestPackUnpack_Good(t *testing.T) {
|
||||
originalPayload := []byte("hello world")
|
||||
trix := &Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: originalPayload,
|
||||
InSigils: []string{"reverse", "reverse"}, // Double reverse should be original
|
||||
}
|
||||
|
||||
err := trix.Pack()
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, originalPayload, trix.Payload) // Should be back to the original
|
||||
|
||||
err = trix.Unpack()
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, originalPayload, trix.Payload) // Should be back to the original again
|
||||
}
|
||||
|
||||
func TestPackUnpack_Bad(t *testing.T) {
|
||||
trix := &Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: []byte("some data"),
|
||||
InSigils: []string{"reverse", "invalid-sigil-name"},
|
||||
}
|
||||
|
||||
err := trix.Pack()
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "unknown sigil name")
|
||||
}
|
||||
|
||||
// --- Checksum Tests ---
|
||||
|
||||
func TestChecksum_Good(t *testing.T) {
|
||||
trix := &Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: []byte("hello world"),
|
||||
ChecksumAlgo: crypt.SHA256,
|
||||
}
|
||||
encoded, err := Encode(trix, "CHCK")
|
||||
assert.NoError(t, err)
|
||||
|
||||
decoded, err := Decode(encoded, "CHCK")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, trix.Payload, decoded.Payload)
|
||||
}
|
||||
|
||||
func TestChecksum_Bad(t *testing.T) {
|
||||
trix := &Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: []byte("hello world"),
|
||||
ChecksumAlgo: crypt.SHA256,
|
||||
}
|
||||
encoded, err := Encode(trix, "CHCK")
|
||||
assert.NoError(t, err)
|
||||
|
||||
// Tamper with the payload
|
||||
encoded[len(encoded)-1] = 0
|
||||
|
||||
_, err = Decode(encoded, "CHCK")
|
||||
assert.Error(t, err)
|
||||
assert.Equal(t, ErrChecksumMismatch, err)
|
||||
}
|
||||
|
||||
func TestChecksum_Ugly(t *testing.T) {
|
||||
t.Run("MissingAlgoInHeader", func(t *testing.T) {
|
||||
trix := &Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: []byte("hello world"),
|
||||
ChecksumAlgo: crypt.SHA256,
|
||||
}
|
||||
encoded, err := Encode(trix, "UGLY")
|
||||
assert.NoError(t, err)
|
||||
|
||||
// Manually decode to tamper with the header
|
||||
decoded, err := Decode(encoded, "UGLY")
|
||||
assert.NoError(t, err)
|
||||
delete(decoded.Header, "checksum_algo")
|
||||
|
||||
// Re-encode with the tampered header
|
||||
tamperedEncoded, err := Encode(decoded, "UGLY")
|
||||
assert.NoError(t, err)
|
||||
|
||||
_, err = Decode(tamperedEncoded, "UGLY")
|
||||
assert.Error(t, err)
|
||||
})
|
||||
}
|
||||
169
tdd/crypt/crypt_test.go
Normal file
169
tdd/crypt/crypt_test.go
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
package crypt_test
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/Snider/Enchantrix/pkg/crypt"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
var service = crypt.NewService()
|
||||
|
||||
// --- Hashing Tests ---
|
||||
|
||||
func TestHash_Good(t *testing.T) {
|
||||
payload := "hello"
|
||||
// Test all supported hash types
|
||||
for _, hashType := range []crypt.HashType{crypt.LTHN, crypt.SHA512, crypt.SHA256, crypt.SHA1, crypt.MD5} {
|
||||
hash := service.Hash(hashType, payload)
|
||||
assert.NotEmpty(t, hash, "Hash should not be empty for type %s", hashType)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHash_Bad(t *testing.T) {
|
||||
// Using an unsupported hash type should default to SHA256
|
||||
hash := service.Hash("unsupported", "hello")
|
||||
expectedHash := service.Hash(crypt.SHA256, "hello")
|
||||
assert.Equal(t, expectedHash, hash)
|
||||
}
|
||||
|
||||
func TestHash_Ugly(t *testing.T) {
|
||||
// Test with potentially problematic inputs
|
||||
testCases := []string{
|
||||
"", // Empty string
|
||||
" ", // Whitespace
|
||||
"\x00\x01\x02\x03\x04", // Null bytes
|
||||
strings.Repeat("a", 1024*1024), // Large payload (1MB)
|
||||
"こんにちは", // Unicode characters
|
||||
}
|
||||
|
||||
for _, tc := range testCases {
|
||||
for _, hashType := range []crypt.HashType{crypt.LTHN, crypt.SHA512, crypt.SHA256, crypt.SHA1, crypt.MD5} {
|
||||
hash := service.Hash(hashType, tc)
|
||||
assert.NotEmpty(t, hash, "Hash for ugly input should not be empty for type %s", hashType)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// --- Checksum Tests ---
|
||||
|
||||
// Luhn Tests
|
||||
func TestLuhn_Good(t *testing.T) {
|
||||
assert.True(t, service.Luhn("79927398713"))
|
||||
}
|
||||
|
||||
func TestLuhn_Bad(t *testing.T) {
|
||||
assert.False(t, service.Luhn("79927398714"), "Should fail for incorrect checksum")
|
||||
assert.False(t, service.Luhn("7992739871a"), "Should fail for non-numeric input")
|
||||
assert.False(t, service.Luhn("1"), "Should be false for single digit")
|
||||
}
|
||||
|
||||
func TestLuhn_Ugly(t *testing.T) {
|
||||
assert.False(t, service.Luhn(""), "Should be false for empty string")
|
||||
assert.False(t, service.Luhn(" 1 2 3 "), "Should handle spaces but result in false")
|
||||
assert.False(t, service.Luhn("!@#$%^&*()"), "Should be false for special characters")
|
||||
}
|
||||
|
||||
// Fletcher16 Tests
|
||||
func TestFletcher16_Good(t *testing.T) {
|
||||
assert.Equal(t, uint16(0xC8F0), service.Fletcher16("abcde"))
|
||||
assert.Equal(t, uint16(0x2057), service.Fletcher16("abcdef"))
|
||||
assert.Equal(t, uint16(0x0627), service.Fletcher16("abcdefgh"))
|
||||
}
|
||||
|
||||
func TestFletcher16_Ugly(t *testing.T) {
|
||||
assert.Equal(t, uint16(0), service.Fletcher16(""), "Checksum of empty string should be 0")
|
||||
assert.Equal(t, uint16(0), service.Fletcher16("\x00"), "Checksum of null byte should be 0")
|
||||
}
|
||||
|
||||
// Fletcher32 Tests
|
||||
func TestFletcher32_Good(t *testing.T) {
|
||||
assert.Equal(t, uint32(0xF04FC729), service.Fletcher32("abcde"))
|
||||
assert.Equal(t, uint32(0x56502D2A), service.Fletcher32("abcdef"))
|
||||
assert.Equal(t, uint32(0xEBE19591), service.Fletcher32("abcdefgh"))
|
||||
}
|
||||
|
||||
func TestFletcher32_Ugly(t *testing.T) {
|
||||
assert.Equal(t, uint32(0), service.Fletcher32(""), "Checksum of empty string should be 0")
|
||||
// Test odd length string to check padding
|
||||
assert.NotEqual(t, uint32(0), service.Fletcher32("a"), "Checksum of odd length string")
|
||||
}
|
||||
|
||||
// Fletcher64 Tests
|
||||
func TestFletcher64_Good(t *testing.T) {
|
||||
assert.Equal(t, uint64(0xc8c6c527646362c6), service.Fletcher64("abcde"))
|
||||
assert.Equal(t, uint64(0xc8c72b276463c8c6), service.Fletcher64("abcdef"))
|
||||
assert.Equal(t, uint64(0x312e2b28cccac8c6), service.Fletcher64("abcdefgh"))
|
||||
}
|
||||
|
||||
func TestFletcher64_Ugly(t *testing.T) {
|
||||
assert.Equal(t, uint64(0), service.Fletcher64(""), "Checksum of empty string should be 0")
|
||||
// Test different length strings to check padding
|
||||
assert.NotEqual(t, uint64(0), service.Fletcher64("a"), "Checksum of length 1 string")
|
||||
assert.NotEqual(t, uint64(0), service.Fletcher64("ab"), "Checksum of length 2 string")
|
||||
assert.NotEqual(t, uint64(0), service.Fletcher64("abc"), "Checksum of length 3 string")
|
||||
}
|
||||
|
||||
|
||||
// --- RSA Tests ---
|
||||
|
||||
func TestRSA_Good(t *testing.T) {
|
||||
pubKey, privKey, err := service.GenerateRSAKeyPair(2048)
|
||||
assert.NoError(t, err)
|
||||
assert.NotNil(t, pubKey)
|
||||
assert.NotNil(t, privKey)
|
||||
|
||||
// Test encryption and decryption
|
||||
message := []byte("secret message")
|
||||
label := []byte("test label")
|
||||
ciphertext, err := service.EncryptRSA(pubKey, message, label)
|
||||
assert.NoError(t, err)
|
||||
plaintext, err := service.DecryptRSA(privKey, ciphertext, label)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, message, plaintext)
|
||||
}
|
||||
|
||||
func TestRSA_Bad(t *testing.T) {
|
||||
// Test with a key size that is too small
|
||||
_, _, err := service.GenerateRSAKeyPair(1024)
|
||||
assert.Error(t, err)
|
||||
|
||||
// Test decryption with the wrong key
|
||||
pubKey, privKey, err := service.GenerateRSAKeyPair(2048)
|
||||
assert.NoError(t, err)
|
||||
_, otherPrivKey, err := service.GenerateRSAKeyPair(2048)
|
||||
assert.NoError(t, err)
|
||||
message := []byte("secret message")
|
||||
ciphertext, err := service.EncryptRSA(pubKey, message, nil)
|
||||
assert.NoError(t, err)
|
||||
_, err = service.DecryptRSA(otherPrivKey, ciphertext, nil)
|
||||
assert.Error(t, err)
|
||||
|
||||
// Test decryption with wrong label
|
||||
label1 := []byte("label1")
|
||||
label2 := []byte("label2")
|
||||
ciphertext, err = service.EncryptRSA(pubKey, message, label1)
|
||||
assert.NoError(t, err)
|
||||
_, err = service.DecryptRSA(privKey, ciphertext, label2)
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
func TestRSA_Ugly(t *testing.T) {
|
||||
// Test with malformed keys
|
||||
_, err := service.EncryptRSA([]byte("not a real key"), []byte("message"), nil)
|
||||
assert.Error(t, err)
|
||||
|
||||
_, err = service.DecryptRSA([]byte("not a real key"), []byte("message"), nil)
|
||||
assert.Error(t, err)
|
||||
|
||||
// Test with empty message
|
||||
pubKey, privKey, err := service.GenerateRSAKeyPair(2048)
|
||||
assert.NoError(t, err)
|
||||
message := []byte("")
|
||||
ciphertext, err := service.EncryptRSA(pubKey, message, nil)
|
||||
assert.NoError(t, err)
|
||||
plaintext, err := service.DecryptRSA(privKey, ciphertext, nil)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, message, plaintext)
|
||||
}
|
||||
159
tdd/enchantrix/enchantrix_test.go
Normal file
159
tdd/enchantrix/enchantrix_test.go
Normal file
|
|
@ -0,0 +1,159 @@
|
|||
package enchantrix_test
|
||||
|
||||
import (
|
||||
"crypto"
|
||||
"encoding/hex"
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"github.com/Snider/Enchantrix/pkg/enchantrix"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
// --- Transmute Tests ---
|
||||
|
||||
func TestTransmute_Good(t *testing.T) {
|
||||
data := []byte("hello")
|
||||
sigils := []enchantrix.Sigil{
|
||||
&enchantrix.ReverseSigil{},
|
||||
&enchantrix.HexSigil{},
|
||||
}
|
||||
result, err := enchantrix.Transmute(data, sigils)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "6f6c6c6568", string(result))
|
||||
}
|
||||
|
||||
type errorSigil struct{}
|
||||
|
||||
func (s *errorSigil) In(data []byte) ([]byte, error) {
|
||||
return nil, errors.New("sigil error")
|
||||
}
|
||||
func (s *errorSigil) Out(data []byte) ([]byte, error) {
|
||||
return nil, errors.New("sigil error")
|
||||
}
|
||||
|
||||
func TestTransmute_Bad(t *testing.T) {
|
||||
data := []byte("hello")
|
||||
sigils := []enchantrix.Sigil{
|
||||
&enchantrix.ReverseSigil{},
|
||||
&errorSigil{},
|
||||
}
|
||||
_, err := enchantrix.Transmute(data, sigils)
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
// --- Factory Tests ---
|
||||
|
||||
func TestNewSigil_Good(t *testing.T) {
|
||||
validNames := []string{
|
||||
"reverse", "hex", "base64", "gzip", "json", "json-indent",
|
||||
"md4", "md5", "sha1", "sha224", "sha256", "sha384", "sha512",
|
||||
"ripemd160", "sha3-224", "sha3-256", "sha3-384", "sha3-512",
|
||||
"sha512-224", "sha512-256", "blake2s-256", "blake2b-256",
|
||||
"blake2b-384", "blake2b-512",
|
||||
}
|
||||
for _, name := range validNames {
|
||||
sigil, err := enchantrix.NewSigil(name)
|
||||
assert.NoError(t, err, "Failed to create sigil: %s", name)
|
||||
assert.NotNil(t, sigil, "Sigil should not be nil for name: %s", name)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewSigil_Bad(t *testing.T) {
|
||||
sigil, err := enchantrix.NewSigil("invalid-sigil-name")
|
||||
assert.Error(t, err)
|
||||
assert.Nil(t, sigil)
|
||||
assert.Contains(t, err.Error(), "unknown sigil name")
|
||||
}
|
||||
|
||||
// --- Sigil Tests ---
|
||||
|
||||
func TestReverseSigil(t *testing.T) {
|
||||
s := &enchantrix.ReverseSigil{}
|
||||
data := []byte("hello")
|
||||
reversed, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "olleh", string(reversed))
|
||||
original, err := s.Out(reversed)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "hello", string(original))
|
||||
|
||||
// Ugly - empty string
|
||||
empty := []byte("")
|
||||
reversedEmpty, err := s.In(empty)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "", string(reversedEmpty))
|
||||
}
|
||||
|
||||
func TestHexSigil(t *testing.T) {
|
||||
s := &enchantrix.HexSigil{}
|
||||
data := []byte("hello")
|
||||
encoded, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "68656c6c6f", string(encoded))
|
||||
decoded, err := s.Out(encoded)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "hello", string(decoded))
|
||||
|
||||
// Bad - invalid hex string
|
||||
_, err = s.Out([]byte("not hex"))
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
func TestBase64Sigil(t *testing.T) {
|
||||
s := &enchantrix.Base64Sigil{}
|
||||
data := []byte("hello")
|
||||
encoded, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "aGVsbG8=", string(encoded))
|
||||
decoded, err := s.Out(encoded)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "hello", string(decoded))
|
||||
|
||||
// Bad - invalid base64 string
|
||||
_, err = s.Out([]byte("not base64"))
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
func TestGzipSigil(t *testing.T) {
|
||||
s := &enchantrix.GzipSigil{}
|
||||
data := []byte("hello")
|
||||
compressed, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
assert.NotEqual(t, data, compressed)
|
||||
decompressed, err := s.Out(compressed)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "hello", string(decompressed))
|
||||
|
||||
// Bad - invalid gzip data
|
||||
_, err = s.Out([]byte("not gzip"))
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
func TestJSONSigil(t *testing.T) {
|
||||
s := &enchantrix.JSONSigil{Indent: true}
|
||||
data := []byte(`{"hello":"world"}`)
|
||||
indented, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, "{\n \"hello\": \"world\"\n}", string(indented))
|
||||
s.Indent = false
|
||||
compacted, err := s.In(indented)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, `{"hello":"world"}`, string(compacted))
|
||||
|
||||
// Bad - invalid json
|
||||
_, err = s.In([]byte("not json"))
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
func TestHashSigil(t *testing.T) {
|
||||
s := enchantrix.NewHashSigil(crypto.SHA256)
|
||||
data := []byte("hello")
|
||||
hashed, err := s.In(data)
|
||||
assert.NoError(t, err)
|
||||
expectedHash := "2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824"
|
||||
assert.Equal(t, expectedHash, hex.EncodeToString(hashed))
|
||||
unhashed, err := s.Out(hashed)
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, hashed, unhashed) // Out is a no-op
|
||||
}
|
||||
252
tdd/trix/trix_test.go
Normal file
252
tdd/trix/trix_test.go
Normal file
|
|
@ -0,0 +1,252 @@
|
|||
package trix_test
|
||||
|
||||
import (
|
||||
"io"
|
||||
"reflect"
|
||||
"testing"
|
||||
|
||||
"github.com/Snider/Enchantrix/pkg/crypt"
|
||||
"github.com/Snider/Enchantrix/pkg/trix"
|
||||
"github.com/stretchr/testify/assert"
|
||||
)
|
||||
|
||||
// TestTrixEncodeDecode_Good tests the ideal "happy path" scenario for encoding and decoding.
|
||||
func TestTrixEncodeDecode_Good(t *testing.T) {
|
||||
header := map[string]interface{}{
|
||||
"content_type": "application/octet-stream",
|
||||
"encryption_algorithm": "chacha20poly1035",
|
||||
"nonce": "AAECAwQFBgcICQoLDA0ODxAREhMUFRY=",
|
||||
"created_at": "2025-10-30T12:00:00Z",
|
||||
}
|
||||
payload := []byte("This is a secret message.")
|
||||
trixOb := &trix.Trix{Header: header, Payload: payload}
|
||||
magicNumber := "TRIX"
|
||||
|
||||
encoded, err := trix.Encode(trixOb, magicNumber)
|
||||
assert.NoError(t, err)
|
||||
|
||||
decoded, err := trix.Decode(encoded, magicNumber)
|
||||
assert.NoError(t, err)
|
||||
|
||||
assert.True(t, reflect.DeepEqual(trixOb.Header, decoded.Header))
|
||||
assert.Equal(t, trixOb.Payload, decoded.Payload)
|
||||
}
|
||||
|
||||
// TestTrixEncodeDecode_Bad tests expected failure scenarios with well-formed but invalid inputs.
|
||||
func TestTrixEncodeDecode_Bad(t *testing.T) {
|
||||
t.Run("MismatchedMagicNumber", func(t *testing.T) {
|
||||
trixOb := &trix.Trix{Header: map[string]interface{}{}, Payload: []byte("payload")}
|
||||
encoded, err := trix.Encode(trixOb, "GOOD")
|
||||
assert.NoError(t, err)
|
||||
|
||||
_, err = trix.Decode(encoded, "BAD!")
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "invalid magic number")
|
||||
})
|
||||
|
||||
t.Run("InvalidMagicNumberLength", func(t *testing.T) {
|
||||
trixOb := &trix.Trix{Header: map[string]interface{}{}, Payload: []byte("payload")}
|
||||
_, err := trix.Encode(trixOb, "TOOLONG")
|
||||
assert.EqualError(t, err, "trix: magic number must be 4 bytes long")
|
||||
|
||||
_, err = trix.Decode([]byte{}, "SHORT")
|
||||
assert.EqualError(t, err, "trix: magic number must be 4 bytes long")
|
||||
})
|
||||
|
||||
t.Run("MalformedHeaderJSON", func(t *testing.T) {
|
||||
// Create a Trix struct with a header that cannot be marshaled to JSON.
|
||||
header := map[string]interface{}{
|
||||
"unsupported": make(chan int), // Channels cannot be JSON-encoded
|
||||
}
|
||||
trixOb := &trix.Trix{Header: header, Payload: []byte("payload")}
|
||||
_, err := trix.Encode(trixOb, "TRIX")
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "json: unsupported type")
|
||||
})
|
||||
|
||||
t.Run("HeaderTooLarge", func(t *testing.T) {
|
||||
data := make([]byte, trix.MaxHeaderSize+10)
|
||||
trixOb := &trix.Trix{
|
||||
Header: map[string]interface{}{"large": string(data)},
|
||||
Payload: []byte("payload"),
|
||||
}
|
||||
encoded, err := trix.Encode(trixOb, "TRIX")
|
||||
assert.NoError(t, err)
|
||||
|
||||
_, err = trix.Decode(encoded, "TRIX")
|
||||
assert.ErrorIs(t, err, trix.ErrHeaderTooLarge)
|
||||
})
|
||||
}
|
||||
|
||||
// TestTrixEncodeDecode_Ugly tests malicious or malformed inputs designed to cause crashes or panics.
|
||||
func TestTrixEncodeDecode_Ugly(t *testing.T) {
|
||||
magicNumber := "UGLY"
|
||||
|
||||
t.Run("CorruptedHeaderLength", func(t *testing.T) {
|
||||
// Manually construct a byte slice where the header length is larger than the actual data.
|
||||
var buf []byte
|
||||
buf = append(buf, []byte(magicNumber)...) // Magic Number
|
||||
buf = append(buf, byte(trix.Version)) // Version
|
||||
buf = append(buf, []byte{0, 0, 3, 232}...) // BigEndian representation of 1000
|
||||
buf = append(buf, []byte("{}")...) // A minimal valid JSON header
|
||||
buf = append(buf, []byte("payload")...)
|
||||
|
||||
_, err := trix.Decode(buf, magicNumber)
|
||||
assert.Error(t, err)
|
||||
assert.Equal(t, err, io.ErrUnexpectedEOF)
|
||||
})
|
||||
|
||||
t.Run("DataTooShort", func(t *testing.T) {
|
||||
data := []byte("BAD")
|
||||
_, err := trix.Decode(data, magicNumber)
|
||||
assert.Error(t, err)
|
||||
})
|
||||
|
||||
t.Run("EmptyPayload", func(t *testing.T) {
|
||||
data := []byte{}
|
||||
_, err := trix.Decode(data, magicNumber)
|
||||
assert.Error(t, err)
|
||||
})
|
||||
|
||||
t.Run("FuzzedJSON", func(t *testing.T) {
|
||||
header := map[string]interface{}{
|
||||
"payload": map[string]interface{}{"nested": 123},
|
||||
}
|
||||
payload := []byte("some data")
|
||||
trixOb := &trix.Trix{Header: header, Payload: payload}
|
||||
|
||||
encoded, err := trix.Encode(trixOb, magicNumber)
|
||||
assert.NoError(t, err)
|
||||
|
||||
decoded, err := trix.Decode(encoded, magicNumber)
|
||||
assert.NoError(t, err)
|
||||
assert.NotNil(t, decoded)
|
||||
})
|
||||
}
|
||||
|
||||
// --- Sigil Tests ---
|
||||
|
||||
func TestPackUnpack_Good(t *testing.T) {
|
||||
originalPayload := []byte("hello world")
|
||||
trixOb := &trix.Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: originalPayload,
|
||||
InSigils: []string{"reverse", "reverse"}, // Double reverse should be original
|
||||
}
|
||||
|
||||
err := trixOb.Pack()
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, originalPayload, trixOb.Payload)
|
||||
|
||||
err = trixOb.Unpack()
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, originalPayload, trixOb.Payload)
|
||||
}
|
||||
|
||||
func TestPackUnpack_Bad(t *testing.T) {
|
||||
trixOb := &trix.Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: []byte("some data"),
|
||||
InSigils: []string{"reverse", "invalid-sigil-name"},
|
||||
}
|
||||
|
||||
err := trixOb.Pack()
|
||||
assert.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "unknown sigil name")
|
||||
|
||||
trixOb.InSigils = []string{"hex"}
|
||||
trixOb.Payload = []byte("not hex")
|
||||
err = trixOb.Unpack()
|
||||
assert.Error(t, err)
|
||||
}
|
||||
|
||||
func TestPackUnpack_Ugly(t *testing.T) {
|
||||
trixOb := &trix.Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: nil, // Nil payload
|
||||
InSigils: []string{"reverse"},
|
||||
}
|
||||
err := trixOb.Pack()
|
||||
assert.NoError(t, err) // Should handle nil payload gracefully
|
||||
|
||||
err = trixOb.Unpack()
|
||||
assert.NoError(t, err)
|
||||
}
|
||||
|
||||
// --- Checksum Tests ---
|
||||
|
||||
func TestChecksum_Good(t *testing.T) {
|
||||
trixOb := &trix.Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: []byte("hello world"),
|
||||
ChecksumAlgo: crypt.SHA256,
|
||||
}
|
||||
encoded, err := trix.Encode(trixOb, "CHCK")
|
||||
assert.NoError(t, err)
|
||||
|
||||
decoded, err := trix.Decode(encoded, "CHCK")
|
||||
assert.NoError(t, err)
|
||||
assert.Equal(t, trixOb.Payload, decoded.Payload)
|
||||
}
|
||||
|
||||
func TestChecksum_Bad(t *testing.T) {
|
||||
trixOb := &trix.Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: []byte("hello world"),
|
||||
ChecksumAlgo: crypt.SHA256,
|
||||
}
|
||||
encoded, err := trix.Encode(trixOb, "CHCK")
|
||||
assert.NoError(t, err)
|
||||
|
||||
encoded[len(encoded)-1] = 0 // Tamper with the payload
|
||||
|
||||
_, err = trix.Decode(encoded, "CHCK")
|
||||
assert.ErrorIs(t, err, trix.ErrChecksumMismatch)
|
||||
}
|
||||
|
||||
func TestChecksum_Ugly(t *testing.T) {
|
||||
t.Run("MissingAlgoInHeader", func(t *testing.T) {
|
||||
trixOb := &trix.Trix{
|
||||
Header: map[string]interface{}{},
|
||||
Payload: []byte("hello world"),
|
||||
ChecksumAlgo: crypt.SHA256,
|
||||
}
|
||||
encoded, err := trix.Encode(trixOb, "UGLY")
|
||||
assert.NoError(t, err)
|
||||
|
||||
decoded, err := trix.Decode(encoded, "UGLY")
|
||||
assert.NoError(t, err)
|
||||
delete(decoded.Header, "checksum_algo")
|
||||
|
||||
tamperedEncoded, err := trix.Encode(decoded, "UGLY")
|
||||
assert.NoError(t, err)
|
||||
|
||||
_, err = trix.Decode(tamperedEncoded, "UGLY")
|
||||
assert.Error(t, err)
|
||||
})
|
||||
}
|
||||
|
||||
// --- Fuzz Tests ---
|
||||
|
||||
func FuzzDecode(f *testing.F) {
|
||||
validTrix := &trix.Trix{
|
||||
Header: map[string]interface{}{"content_type": "text/plain"},
|
||||
Payload: []byte("hello world"),
|
||||
}
|
||||
validEncoded, _ := trix.Encode(validTrix, "FUZZ")
|
||||
f.Add(validEncoded)
|
||||
|
||||
var buf []byte
|
||||
buf = append(buf, []byte("UGLY")...)
|
||||
buf = append(buf, byte(trix.Version))
|
||||
buf = append(buf, []byte{0, 0, 3, 232}...)
|
||||
buf = append(buf, []byte("{}")...)
|
||||
buf = append(buf, []byte("payload")...)
|
||||
f.Add(buf)
|
||||
|
||||
f.Add([]byte("short"))
|
||||
|
||||
f.Fuzz(func(t *testing.T, data []byte) {
|
||||
_, _ = trix.Decode(data, "FUZZ")
|
||||
})
|
||||
}
|
||||
Loading…
Add table
Reference in a new issue