commit 1f6bf5bab7957b38b24fe0e54136158d7fad1aeb · seiso.moe/magna

+16 -12

errors_test.go

···

       1
       1
        
       package magna

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"fmt"

     

       4
       5
        
       	"testing"

     

       5
       6
        
       

     

       6
       7
        
       	"github.com/stretchr/testify/assert"

     
···

       13
       14
        
       		offset   int

     

       14
       15
        
       		expected string

     

       15
       16
        
       	}{

     

       16
       16
       -
       		{"basic overflow", 10, 15, "magna: offset 15 is past the buffer length 10"},

     

       17
       17
       -
       		{"zero length", 0, 5, "magna: offset 5 is past the buffer length 0"},

     

       18
       18
       -
       		{"negative offset", 10, -1, "magna: offset -1 is past the buffer length 10"},

     

       17
       17
       +
       		{"PositiveOffset", 10, 15, "magna: offset 15 is past the buffer length 10"},

     

       18
       18
       +
       		{"ZeroLengthBuffer", 0, 5, "magna: offset 5 is past the buffer length 0"},

     

       19
       19
       +
       		{"NegativeOffset", 10, -1, "magna: offset -1 is past the buffer length 10"},

     

       20
       20
       +
       		{"EqualOffset", 10, 10, "magna: offset 10 is past the buffer length 10"},

     

       19
       21
        
       	}

     

       20
       22
        
       

     

       21
       23
        
       	for _, tt := range tests {

     
···

       32
       34
        
       		length   int

     

       33
       35
        
       		expected string

     

       34
       36
        
       	}{

     

       35
       35
       -
       		{"zero length", 0, "magna: received invalid label length 0"},

     

       36
       36
       -
       		{"negative length", -1, "magna: received invalid label length -1"},

     

       37
       37
       -
       		{"large length", 1000, "magna: received invalid label length 1000"},

     

       37
       37
       +
       		{"LengthTooLarge", 64, "magna: received invalid label length 64"},

     

       38
       38
       +
       		{"LengthZero", 0, "magna: received invalid label length 0"},

     

       39
       39
       +
       		{"NegativeLength", -1, "magna: received invalid label length -1"},

     

       38
       40
        
       	}

     

       39
       41
        
       

     

       40
       42
        
       	for _, tt := range tests {

     
···

       46
       48
        
       }

     

       47
       49
        
       

     

       48
       50
        
       func TestDomainCompressionError(t *testing.T) {

     

       49
       49
       -
       	err := &DomainCompressionError{}

     

       50
       50
       -
       	expected := "magna: loop detected in domain compression"

     

       51
       51
       -
       	assert.Equal(t, expected, err.Error())

     

       51
       51
       +
       	t.Run("Standard", func(t *testing.T) {

     

       52
       52
       +
       		err := &DomainCompressionError{}

     

       53
       53
       +
       		expected := "magna: loop detected in domain compression"

     

       54
       54
       +
       		assert.Equal(t, expected, err.Error(), "Error() output mismatch")

     

       55
       55
       +
       	})

     

       52
       56
        
       }

     

       53
       57
        
       

     

       54
       58
        
       func TestMagnaError(t *testing.T) {

     
···

       57
       61
        
       		message  string

     

       58
       62
        
       		expected string

     

       59
       63
        
       	}{

     

       60
       60
       -
       		{"empty message", "", "magna: "},

     

       61
       61
       -
       		{"basic message", "test error", "magna: test error"},

     

       62
       62
       -
       		{"message with punctuation", "error: invalid input!", "magna: error: invalid input!"},

     

       64
       64
       +
       		{"EmptyMessage", "", "magna: "},

     

       65
       65
       +
       		{"SimpleMessage", "test error", "magna: test error"},

     

       66
       66
       +
       		{"MessageWithPunctuation", "error: invalid input!", "magna: error: invalid input!"},

     

       63
       67
        
       	}

     

       64
       68
        
       

     

       65
       69
        
       	for _, tt := range tests {

+2 -1

message.go

···

       58
       58
        
       // TODO: set truncation bit if over 512 and udp is protocol

     

       59
       59
        
       func (m *Message) Encode() []byte {

     

       60
       60
        
       	m.offsets = make(map[string]uint16)

     

       61
       61
       -
       	bytes := m.Header.Encode()

     

       61
       61
       +
       	bytes := make([]byte, 0, 512)

     

       62
       62
       +
       	bytes = append(bytes, m.Header.Encode()...)

     

       62
       63
        
       

     

       63
       64
        
       	for _, question := range m.Question {

     

       64
       65
        
       		bytes = question.Encode(bytes, &m.offsets)