1 package ber
2
3 import (
4 "bytes"
5 "io"
6 "math"
7 "testing"
8 )
9
10 func TestEncodeDecodeInteger(t *testing.T) {
11 for _, v := range []int64{0, 10, 128, 1024, math.MaxInt64, -1, -100, -128, -1024, math.MinInt64} {
12 enc := encodeInteger(v)
13 dec, err := ParseInt64(enc)
14 if err != nil {
15 t.Fatalf("Error decoding %d : %s", v, err)
16 }
17 if v != dec {
18 t.Errorf("TestEncodeDecodeInteger failed for %d (got %d)", v, dec)
19 }
20 }
21 }
22
23 func TestBoolean(t *testing.T) {
24 packet := NewBoolean(ClassUniversal, TypePrimitive, TagBoolean, true, "first Packet, True")
25
26 newBoolean, ok := packet.Value.(bool)
27 if !ok || newBoolean != true {
28 t.Error("error during creating packet")
29 }
30
31 encodedPacket := packet.Bytes()
32
33 newPacket := DecodePacket(encodedPacket)
34
35 newBoolean, ok = newPacket.Value.(bool)
36 if !ok || newBoolean != true {
37 t.Error("error during decoding packet")
38 }
39 }
40
41 func TestLDAPBoolean(t *testing.T) {
42 packet := NewLDAPBoolean(ClassUniversal, TypePrimitive, TagBoolean, true, "first Packet, True")
43
44 newBoolean, ok := packet.Value.(bool)
45 if !ok || newBoolean != true {
46 t.Error("error during creating packet")
47 }
48
49 encodedPacket := packet.Bytes()
50
51 newPacket := DecodePacket(encodedPacket)
52
53 newBoolean, ok = newPacket.Value.(bool)
54 if !ok || newBoolean != true {
55 t.Error("error during decoding packet")
56 }
57 }
58
59 func TestInteger(t *testing.T) {
60 var value int64 = 10
61
62 packet := NewInteger(ClassUniversal, TypePrimitive, TagInteger, value, "Integer, 10")
63
64 {
65 newInteger, ok := packet.Value.(int64)
66 if !ok || newInteger != value {
67 t.Error("error creating packet")
68 }
69 }
70
71 encodedPacket := packet.Bytes()
72
73 newPacket := DecodePacket(encodedPacket)
74
75 {
76 newInteger, ok := newPacket.Value.(int64)
77 if !ok || newInteger != value {
78 t.Error("error decoding packet")
79 }
80 }
81 }
82
83 func TestString(t *testing.T) {
84 value := "Hic sunt dracones"
85
86 packet := NewString(ClassUniversal, TypePrimitive, TagOctetString, value, "String")
87
88 newValue, ok := packet.Value.(string)
89 if !ok || newValue != value {
90 t.Error("error during creating packet")
91 }
92
93 encodedPacket := packet.Bytes()
94
95 newPacket := DecodePacket(encodedPacket)
96
97 newValue, ok = newPacket.Value.(string)
98 if !ok || newValue != value {
99 t.Error("error during decoding packet")
100 }
101 }
102
103 func TestSequenceAndAppendChild(t *testing.T) {
104 values := []string{
105 "HIC SVNT LEONES",
106 "Iñtërnâtiônàlizætiøn",
107 "Terra Incognita",
108 }
109
110 sequence := NewSequence("a sequence")
111 for _, s := range values {
112 sequence.AppendChild(NewString(ClassUniversal, TypePrimitive, TagOctetString, s, "String"))
113 }
114
115 if len(sequence.Children) != len(values) {
116 t.Errorf("wrong length for children array should be %d, got %d", len(values), len(sequence.Children))
117 }
118
119 encodedSequence := sequence.Bytes()
120
121 decodedSequence := DecodePacket(encodedSequence)
122 if len(decodedSequence.Children) != len(values) {
123 t.Errorf("wrong length for children array should be %d => %d", len(values), len(decodedSequence.Children))
124 }
125
126 for i, s := range values {
127 if decodedSequence.Children[i].Value.(string) != s {
128 t.Errorf("expected %d to be %q, got %q", i, s, decodedSequence.Children[i].Value.(string))
129 }
130 }
131 }
132
133 func TestReadPacket(t *testing.T) {
134 packet := NewString(ClassUniversal, TypePrimitive, TagOctetString, "Ad impossibilia nemo tenetur", "string")
135 var buffer io.ReadWriter = new(bytes.Buffer)
136
137 if _, err := buffer.Write(packet.Bytes()); err != nil {
138 t.Error("error writing packet", err)
139 }
140
141 newPacket, err := ReadPacket(buffer)
142 if err != nil {
143 t.Error("error during ReadPacket", err)
144 }
145 newPacket.ByteValue = nil
146 if !bytes.Equal(newPacket.ByteValue, packet.ByteValue) {
147 t.Error("packets should be the same")
148 }
149 }
150
151 func TestBinaryInteger(t *testing.T) {
152
153 data := []struct {
154 v int64
155 e []byte
156 }{
157 {v: 0, e: []byte{0x02, 0x01, 0x00}},
158 {v: 127, e: []byte{0x02, 0x01, 0x7F}},
159 {v: 128, e: []byte{0x02, 0x02, 0x00, 0x80}},
160 {v: 256, e: []byte{0x02, 0x02, 0x01, 0x00}},
161 {v: -128, e: []byte{0x02, 0x01, 0x80}},
162 {v: -129, e: []byte{0x02, 0x02, 0xFF, 0x7F}},
163 {v: math.MaxInt64, e: []byte{0x02, 0x08, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}},
164 {v: math.MinInt64, e: []byte{0x02, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
165 }
166
167 for _, d := range data {
168 if b := NewInteger(ClassUniversal, TypePrimitive, TagInteger, d.v, "").Bytes(); !bytes.Equal(d.e, b) {
169 t.Errorf("Wrong binary generated for %d : got % X, expected % X", d.v, b, d.e)
170 }
171 }
172 }
173
174 func TestBinaryOctetString(t *testing.T) {
175
176
177 if !bytes.Equal([]byte{0x04, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}, NewString(ClassUniversal, TypePrimitive, TagOctetString, "\x01\x23\x45\x67\x89\xab\xcd\xef", "").Bytes()) {
178 t.Error("wrong binary generated")
179 }
180 }
181
182
183 func buff(bs ...byte) *bytes.Reader {
184 return bytes.NewReader(bs)
185 }
186
187 func TestEOF(t *testing.T) {
188 _, err := ReadPacket(buff())
189 if err != io.EOF {
190 t.Errorf("empty buffer: expected EOF, got %s", err)
191 }
192
193
194 testCases := []struct {
195 name string
196 buf *bytes.Reader
197 }{
198 {"primitive", buff(0x04, 0x0a, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9)},
199 {"constructed", buff(0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02)},
200 {"constructed indefinite length", buff(0x30, 0x80, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02, 0x00, 0x00)},
201 }
202 for _, tc := range testCases {
203 _, err := ReadPacket(tc.buf)
204 if err != nil {
205 t.Errorf("%s: expected no error, got %s", tc.name, err)
206 }
207
208 _, err = ReadPacket(tc.buf)
209 if err != io.EOF {
210 t.Errorf("%s: expected EOF, got %s", tc.name, err)
211 }
212 }
213
214
215 testCases = []struct {
216 name string
217 buf *bytes.Reader
218 }{
219 {"truncated tag", buff(0x1f, 0xff)},
220 {"tag and no length", buff(0x04)},
221 {"truncated length", buff(0x04, 0x82, 0x02)},
222 {"header with no content", buff(0x04, 0x0a)},
223 {"header with truncated content", buff(0x04, 0x0a, 0, 1, 2)},
224
225 {"constructed missing content", buff(0x30, 0x06)},
226 {"constructed only first child", buff(0x30, 0x06, 0x02, 0x01, 0x01)},
227 {"constructed truncated", buff(0x30, 0x06, 0x02, 0x01, 0x01, 0x02, 0x01)},
228
229 {"indefinite missing eoc", buff(0x30, 0x80, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02)},
230 {"indefinite truncated eoc", buff(0x30, 0x80, 0x02, 0x01, 0x01, 0x02, 0x01, 0x02, 0x00)},
231 }
232 for _, tc := range testCases {
233 _, err := ReadPacket(tc.buf)
234 if err != io.ErrUnexpectedEOF {
235 t.Errorf("%s: expected UnexpectedEOF, got %s", tc.name, err)
236 }
237 }
238 }
239
View as plain text