1% Regression tests for Scapy regarding fields
2
3############
4############
5+ Tests on basic fields
6
7#= Field class
8#~ core field
9#Field("foo", None, fmt="H").i2m(None,0xabcdef)
10#assert( _ == b"\xcd\xef" )
11#Field("foo", None, fmt="<I").i2m(None,0x12cdef)
12#assert( _ == b"\xef\xcd\x12\x00" )
13#Field("foo", None, fmt="B").addfield(None, "FOO", 0x12)
14#assert( _ == b"FOO\x12" )
15#Field("foo", None, fmt="I").getfield(None, b"\x12\x34\x56\x78ABCD")
16#assert( _ == ("ABCD",0x12345678) )
17#
18#= ConditionnalField class
19#~ core field
20#False
21
22
23= Simple tests
24
25assert LELongField("test", None).addfield(None, b"", 0x44434241) == b'ABCD\x00\x00\x00\x00'
26
27= MACField class
28~ core field
29m = MACField("foo", None)
30m.i2m(None, None)
31assert( _ == b"\x00\x00\x00\x00\x00\x00" )
32m.getfield(None, b"\xc0\x01\xbe\xef\xba\xbeABCD")
33assert( _ == (b"ABCD","c0:01:be:ef:ba:be") )
34m.addfield(None, b"FOO", "c0:01:be:ef:ba:be")
35assert( _ == b"FOO\xc0\x01\xbe\xef\xba\xbe" )
36
37= SourceMACField, ARPSourceMACField
38conf.route.add(net="1.2.3.4/32", dev=conf.iface)
39p = Ether() / ARP(pdst="1.2.3.4")
40assert p.src == p.hwsrc == p[ARP].hwsrc == get_if_hwaddr(conf.iface)
41conf.route.delt(net="1.2.3.4/32")
42
43= IPField class
44~ core field
45
46if WINDOWS:
47    route_add_loopback()
48
49i = IPField("foo", None)
50i.i2m(None, "1.2.3.4")
51assert( _ == b"\x01\x02\x03\x04" )
52i.i2m(None, "255.255.255.255")
53assert( _ == b"\xff\xff\xff\xff" )
54i.m2i(None, b"\x01\x02\x03\x04")
55assert( _ == "1.2.3.4" )
56i.getfield(None, b"\x01\x02\x03\x04ABCD")
57assert( _ == (b"ABCD","1.2.3.4") )
58i.addfield(None, b"FOO", "1.2.3.4")
59assert( _ == b"FOO\x01\x02\x03\x04" )
60
61= SourceIPField
62~ core field
63defaddr = conf.route.route('0.0.0.0')[1]
64class Test(Packet): fields_desc = [SourceIPField("sourceip", None)]
65
66assert Test().sourceip == defaddr
67assert Test(raw(Test())).sourceip == defaddr
68
69assert IP(dst="0.0.0.0").src == defaddr
70assert IP(raw(IP(dst="0.0.0.0"))).src == defaddr
71assert IP(dst="0.0.0.0/31").src == defaddr
72assert IP(raw(IP(dst="0.0.0.0/31"))).src == defaddr
73
74
75#= ByteField
76#~ core field
77#b = ByteField("foo", None)
78#b.i2m("
79#b.getfield
80
81
82############
83############
84+ Tests on ActionField
85
86= Creation of a layer with ActionField
87~ field actionfield
88
89from __future__ import print_function
90
91class TestAction(Packet):
92    __slots__ = ["_val", "_fld", "_priv1", "_priv2"]
93    name = "TestAction"
94    fields_desc = [ ActionField(ByteField("tst", 3), "my_action", priv1=1, priv2=2) ]
95    def __init__(self, *args, **kargs):
96        self._val, self._fld, self._priv1, self._priv2 = None, None, None, None
97        super(TestAction, self).__init__(*args, **kargs)
98    def my_action(self, val, fld, priv1, priv2):
99        print("Action (%i)!" % val)
100        self._val, self._fld, self._priv1, self._priv2 = val, fld, priv1, priv2
101
102= Triggering action
103~ field actionfield
104
105t = TestAction()
106assert(t._val == t._fld == t._priv1 == t._priv2 == None)
107t.tst=42
108assert(t._priv1 == 1)
109assert(t._priv2 == 2)
110assert(t._val == 42)
111
112
113############
114############
115+ Tests on FieldLenField
116
117= Creation of a layer with FieldLenField
118~ field
119class TestFLenF(Packet):
120    fields_desc = [ FieldLenField("len", None, length_of="str", fmt="B", adjust=lambda pkt,x:x+1),
121                    StrLenField("str", "default", length_from=lambda pkt:pkt.len-1,) ]
122
123= Assembly of an empty packet
124~ field
125TestFLenF()
126raw(_)
127_ == b"\x08default"
128
129= Assembly of non empty packet
130~ field
131TestFLenF(str="123")
132raw(_)
133_ == b"\x04123"
134
135= Disassembly
136~ field
137TestFLenF(b"\x04ABCDEFGHIJKL")
138_
139_.len == 4 and _.str == b"ABC" and Raw in _
140
141
142= BitFieldLenField test
143~ field
144class TestBFLenF(Packet):
145    fields_desc = [ BitFieldLenField("len", None, 4, length_of="str" , adjust=lambda pkt,x:x+1),
146                    BitField("nothing",0xfff, 12),
147                    StrLenField("str", "default", length_from=lambda pkt:pkt.len-1, ) ]
148
149a=TestBFLenF()
150raw(a)
151assert( _ == b"\x8f\xffdefault" )
152
153a.str=""
154raw(a)
155assert( _ == b"\x1f\xff" )
156
157TestBFLenF(b"\x1f\xff@@")
158assert( _.len == 1 and _.str == b"" and Raw in _ and _[Raw].load == b"@@" )
159
160TestBFLenF(b"\x6f\xffabcdeFGH")
161assert( _.len == 6 and _.str == b"abcde" and Raw in _ and _[Raw].load == b"FGH" )
162
163
164
165############
166############
167+ Tests on FieldListField
168
169= Creation of a layer
170~ field
171class TestFLF(Packet):
172    name="test"
173    fields_desc = [ FieldLenField("len", None, count_of="lst", fmt="B"),
174                    FieldListField("lst", None, IntField("elt",0), count_from=lambda pkt:pkt.len)
175                   ]
176
177= Assembly of an empty packet
178~ field
179a = TestFLF()
180raw(a)
181
182= Assembly of a non-empty packet
183~ field
184a = TestFLF()
185a.lst = [7,65539]
186ls(a)
187raw(a)
188import struct
189_ == struct.pack("!BII", 2,7,65539)
190
191= Disassemble
192~ field
193import struct
194TestFLF(b"\x00\x11\x12")
195assert(_.len == 0 and Raw in _ and _[Raw].load == b"\x11\x12")
196TestFLF(struct.pack("!BIII",3,1234,2345,12345678))
197assert(_.len == 3 and _.lst == [1234,2345,12345678])
198
199= Manipulate
200~ field
201a = TestFLF(lst=[4])
202raw(a)
203assert(_ == b"\x01\x00\x00\x00\x04")
204a.lst.append(1234)
205TestFLF(raw(a))
206a.show2()
207a.len=7
208raw(a)
209assert(_ == b"\x07\x00\x00\x00\x04\x00\x00\x04\xd2")
210a.len=2
211a.lst=[1,2,3,4,5]
212TestFLF(raw(a))
213assert(Raw in _ and _[Raw].load == b'\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05')
214
215
216############
217############
218+ PacketListField
219
220= Create a layer
221~ field lengthfield
222class TestPLF(Packet):
223    name="test"
224    fields_desc=[ FieldLenField("len", None, count_of="plist"),
225                  PacketListField("plist", None, IP, count_from=lambda pkt:pkt.len,) ]
226
227= Test the PacketListField assembly
228~ field lengthfield
229x=TestPLF()
230raw(x)
231_ == b"\x00\x00"
232
233= Test the PacketListField assembly 2
234~ field lengthfield
235x=TestPLF()
236x.plist=[IP()/TCP(), IP()/UDP()]
237raw(x)
238_.startswith(b'\x00\x02E')
239
240= Test disassembly
241~ field lengthfield
242x=TestPLF(plist=[IP()/TCP(seq=1234567), IP()/UDP()])
243TestPLF(raw(x))
244_.show()
245IP in _ and TCP in _ and UDP in _ and _[TCP].seq == 1234567
246
247= Nested PacketListField
248~ field lengthfield
249y=IP()/TCP(seq=111111)/TestPLF(plist=[IP()/TCP(seq=222222),IP()/UDP()])
250TestPLF(plist=[y,IP()/TCP(seq=333333)])
251_.show()
252IP in _ and TCP in _ and UDP in _ and _[TCP].seq == 111111 and _[TCP:2].seq==222222 and _[TCP:3].seq == 333333
253
254############
255############
256+ PacketListField tests
257
258= Create a layer
259~ field lengthfield
260class TestPLF(Packet):
261    name="test"
262    fields_desc=[ FieldLenField("len", None, count_of="plist"),
263                  PacketListField("plist", None, IP, count_from=lambda pkt:pkt.len) ]
264
265= Test the PacketListField assembly
266~ field lengthfield
267x=TestPLF()
268raw(x)
269_ == b"\x00\x00"
270
271= Test the PacketListField assembly 2
272~ field lengthfield
273x=TestPLF()
274x.plist=[IP()/TCP(), IP()/UDP()]
275raw(x)
276_.startswith(b'\x00\x02E')
277
278= Test disassembly
279~ field lengthfield
280x=TestPLF(plist=[IP()/TCP(seq=1234567), IP()/UDP()])
281TestPLF(raw(x))
282_.show()
283IP in _ and TCP in _ and UDP in _ and _[TCP].seq == 1234567
284
285= Nested PacketListField
286~ field lengthfield
287y=IP()/TCP(seq=111111)/TestPLF(plist=[IP()/TCP(seq=222222),IP()/UDP()])
288TestPLF(plist=[y,IP()/TCP(seq=333333)])
289_.show()
290IP in _ and TCP in _ and UDP in _ and _[TCP].seq == 111111 and _[TCP:2].seq==222222 and _[TCP:3].seq == 333333
291
292= Complex packet
293~ field lengthfield ccc
294class TestPkt(Packet):
295    fields_desc = [ ByteField("f1",65),
296                    ShortField("f2",0x4244) ]
297    def extract_padding(self, p):
298        return "", p
299
300class TestPLF2(Packet):
301    fields_desc = [ FieldLenField("len1", None, count_of="plist", fmt="H",
302                                  adjust=lambda pkt, x: x + 2),
303                    FieldLenField("len2", None, length_of="plist", fmt="I",
304                                  adjust=lambda pkt, x: (x + 1) // 2),
305                    PacketListField("plist", None, TestPkt,
306                                    length_from=lambda x: (x.len2 * 2) // 3 * 3) ]
307
308a=TestPLF2()
309raw(a)
310assert( _ == b"\x00\x02\x00\x00\x00\x00" )
311
312a.plist=[TestPkt(),TestPkt(f1=100)]
313raw(a)
314assert(_ == b'\x00\x04\x00\x00\x00\x03ABDdBD')
315
316a /= "123456"
317b = TestPLF2(raw(a))
318b.show()
319assert(b.len1 == 4 and b.len2 == 3)
320assert(b[TestPkt].f1 == 65 and b[TestPkt].f2 == 0x4244)
321assert(b[TestPkt:2].f1 == 100)
322assert(Raw in b and b[Raw].load == b"123456")
323
324a.plist.append(TestPkt(f1=200))
325b = TestPLF2(raw(a))
326b.show()
327assert(b.len1 == 5 and b.len2 == 5)
328assert(b[TestPkt].f1 == 65 and b[TestPkt].f2 == 0x4244)
329assert(b[TestPkt:2].f1 == 100)
330assert(b[TestPkt:3].f1 == 200)
331assert(b.getlayer(TestPkt,4) is None)
332assert(Raw in b and b[Raw].load == b"123456")
333hexdiff(a,b)
334assert( raw(a) == raw(b) )
335
336############
337############
338+ Tests on TCPOptionsField
339
340= Test calls on TCPOptionsField.getfield
341
342assert TCPOptionsField("test", "").getfield(TCP(dataofs=0), "") == ('', [])
343
344
345############
346############
347+ PacketListField tests
348
349= Create a layer
350~ field lengthfield
351class TestPLF(Packet):
352    name="test"
353    fields_desc=[ FieldLenField("len", None, count_of="plist"),
354                  PacketListField("plist", None, IP, count_from=lambda pkt:pkt.len) ]
355
356= Test the PacketListField assembly
357~ field lengthfield
358x=TestPLF()
359raw(x)
360_ == b"\x00\x00"
361
362= Test the PacketListField assembly 2
363~ field lengthfield
364x=TestPLF()
365x.plist=[IP()/TCP(), IP()/UDP()]
366raw(x)
367_.startswith(b'\x00\x02E')
368
369= Test disassembly
370~ field lengthfield
371x=TestPLF(plist=[IP()/TCP(seq=1234567), IP()/UDP()])
372TestPLF(raw(x))
373_.show()
374IP in _ and TCP in _ and UDP in _ and _[TCP].seq == 1234567
375
376= Nested PacketListField
377~ field lengthfield
378y=IP()/TCP(seq=111111)/TestPLF(plist=[IP()/TCP(seq=222222),IP()/UDP()])
379TestPLF(plist=[y,IP()/TCP(seq=333333)])
380_.show()
381IP in _ and TCP in _ and UDP in _ and _[TCP].seq == 111111 and _[TCP:2].seq==222222 and _[TCP:3].seq == 333333
382
383= Complex packet
384~ field lengthfield ccc
385class TestPkt(Packet):
386    fields_desc = [ ByteField("f1",65),
387                    ShortField("f2",0x4244) ]
388    def extract_padding(self, p):
389        return "", p
390
391class TestPLF2(Packet):
392    fields_desc = [ FieldLenField("len1", None, count_of="plist",fmt="H",
393                                  adjust=lambda pkt,x: x + 2),
394                    FieldLenField("len2", None, length_of="plist", fmt="I",
395                                  adjust=lambda pkt, x: (x + 1) // 2),
396                    PacketListField("plist", None, TestPkt,
397                                    length_from=lambda x: (x.len2 * 2) // 3 *3) ]
398
399a=TestPLF2()
400raw(a)
401assert( _ == b"\x00\x02\x00\x00\x00\x00" )
402
403a.plist=[TestPkt(),TestPkt(f1=100)]
404raw(a)
405assert(_ == b'\x00\x04\x00\x00\x00\x03ABDdBD')
406
407a /= "123456"
408b = TestPLF2(raw(a))
409b.show()
410assert(b.len1 == 4 and b.len2 == 3)
411assert(b[TestPkt].f1 == 65 and b[TestPkt].f2 == 0x4244)
412assert(b[TestPkt:2].f1 == 100)
413assert(Raw in b and b[Raw].load == b"123456")
414
415a.plist.append(TestPkt(f1=200))
416b = TestPLF2(raw(a))
417b.show()
418assert(b.len1 == 5 and b.len2 == 5)
419assert(b[TestPkt].f1 == 65 and b[TestPkt].f2 == 0x4244)
420assert(b[TestPkt:2].f1 == 100)
421assert(b[TestPkt:3].f1 == 200)
422assert(b.getlayer(TestPkt,4) is None)
423assert(Raw in b and b[Raw].load == b"123456")
424hexdiff(a,b)
425assert( raw(a) == raw(b) )
426
427= Create layers for heterogeneous PacketListField
428~ field lengthfield
429TestPLFH1 = type('TestPLFH1', (Packet,), {
430    'name': 'test1',
431    'fields_desc': [ByteField('data', 0)],
432    'guess_payload_class': lambda self, p: conf.padding_layer,
433    }
434)
435TestPLFH2 = type('TestPLFH2', (Packet,), {
436    'name': 'test2',
437    'fields_desc': [ShortField('data', 0)],
438    'guess_payload_class': lambda self, p: conf.padding_layer,
439    }
440)
441class TestPLFH3(Packet):
442    name = 'test3'
443    fields_desc = [
444        PacketListField(
445            'data', [],
446            next_cls_cb=lambda pkt, lst, p, remain: pkt.detect_next_packet(lst, p, remain)
447        )
448    ]
449    def detect_next_packet(self, lst, p, remain):
450        if len(remain) < 3:
451            return None
452        if isinstance(p, type(None)):
453            return TestPLFH1
454        if p.data & 3 == 1:
455            return TestPLFH1
456        if p.data & 3 == 2:
457            return TestPLFH2
458        return None
459
460= Test heterogeneous PacketListField
461~ field lengthfield
462
463p = TestPLFH3(b'\x02\x01\x01\xc1\x02\x80\x04toto')
464assert(isinstance(p.data[0], TestPLFH1))
465assert(p.data[0].data == 0x2)
466assert(isinstance(p.data[1], TestPLFH2))
467assert(p.data[1].data == 0x101)
468assert(isinstance(p.data[2], TestPLFH1))
469assert(p.data[2].data == 0xc1)
470assert(isinstance(p.data[3], TestPLFH1))
471assert(p.data[3].data == 0x2)
472assert(isinstance(p.data[4], TestPLFH2))
473assert(p.data[4].data == 0x8004)
474assert(isinstance(p.payload, conf.raw_layer))
475assert(p.payload.load == b'toto')
476
477p = TestPLFH3(b'\x02\x01\x01\xc1\x02\x80\x02to')
478assert(isinstance(p.data[0], TestPLFH1))
479assert(p.data[0].data == 0x2)
480assert(isinstance(p.data[1], TestPLFH2))
481assert(p.data[1].data == 0x101)
482assert(isinstance(p.data[2], TestPLFH1))
483assert(p.data[2].data == 0xc1)
484assert(isinstance(p.data[3], TestPLFH1))
485assert(p.data[3].data == 0x2)
486assert(isinstance(p.data[4], TestPLFH2))
487assert(p.data[4].data == 0x8002)
488assert(isinstance(p.payload, conf.raw_layer))
489assert(p.payload.load == b'to')
490
491= Create layers for heterogeneous PacketListField with memory
492~ field lengthfield
493TestPLFH4 = type('TestPLFH4', (Packet,), {
494    'name': 'test4',
495    'fields_desc': [ByteField('data', 0)],
496    'guess_payload_class': lambda self, p: conf.padding_layer,
497    }
498)
499TestPLFH5 = type('TestPLFH5', (Packet,), {
500    'name': 'test5',
501    'fields_desc': [ShortField('data', 0)],
502    'guess_payload_class': lambda self, p: conf.padding_layer,
503    }
504)
505class TestPLFH6(Packet):
506    __slots__ = ['_memory']
507    name = 'test6'
508    fields_desc = [
509        PacketListField(
510            'data', [],
511            next_cls_cb=lambda pkt, lst, p, remain: pkt.detect_next_packet(lst, p, remain)
512        )
513    ]
514    def detect_next_packet(self, lst, p, remain):
515        if isinstance(p, type(None)):
516            self._memory = [TestPLFH4] * 3 + [TestPLFH5]
517        try:
518            return self._memory.pop(0)
519        except IndexError:
520            return None
521
522= Test heterogeneous PacketListField with memory
523~ field lengthfield
524
525p = TestPLFH6(b'\x01\x02\x03\xc1\x02toto')
526assert(isinstance(p.data[0], TestPLFH4))
527assert(p.data[0].data == 0x1)
528assert(isinstance(p.data[1], TestPLFH4))
529assert(p.data[1].data == 0x2)
530assert(isinstance(p.data[2], TestPLFH4))
531assert(p.data[2].data == 0x3)
532assert(isinstance(p.data[3], TestPLFH5))
533assert(p.data[3].data == 0xc102)
534assert(isinstance(p.payload, conf.raw_layer))
535assert(p.payload.load == b'toto')
536
537
538############
539############
540+ Tests on MultiFlagsField
541
542= Test calls on MultiFlagsField.any2i
543~ multiflagsfield
544
545import collections
546MockPacket = collections.namedtuple('MockPacket', ['type'])
547
548f = MultiFlagsField('flags', set(), 3, {
549        0: {
550            0: MultiFlagsEntry('A', 'OptionA'),
551            1: MultiFlagsEntry('B', 'OptionB'),
552        },
553        1: {
554            0: MultiFlagsEntry('+', 'Plus'),
555            1: MultiFlagsEntry('*', 'Star'),
556        },
557    },
558    depends_on=lambda x: x.type
559)
560
561mp = MockPacket(0)
562x = f.any2i(mp, set())
563assert(isinstance(x, set))
564assert(len(x) == 0)
565x = f.any2i(mp, {'A'})
566assert(isinstance(x, set))
567assert(len(x) == 1)
568assert('A' in x)
569assert('B' not in x)
570assert('+' not in x)
571x = f.any2i(mp, {'A', 'B'})
572assert(isinstance(x, set))
573assert(len(x) == 2)
574assert('A' in x)
575assert('B' in x)
576assert('+' not in x)
577assert('*' not in x)
578x = f.any2i(mp, 3)
579assert(isinstance(x, set))
580assert(len(x) == 2)
581assert('A' in x)
582assert('B' in x)
583assert('+' not in x)
584assert('*' not in x)
585x = f.any2i(mp, 7)
586assert(isinstance(x, set))
587assert(len(x) == 3)
588assert('A' in x)
589assert('B' in x)
590assert('bit 2' in x)
591assert('+' not in x)
592assert('*' not in x)
593mp = MockPacket(1)
594x = f.any2i(mp, {'+', '*'})
595assert(isinstance(x, set))
596assert(len(x) == 2)
597assert('+' in x)
598assert('*' in x)
599assert('A' not in x)
600assert('B' not in x)
601try:
602    x = f.any2i(mp, {'A'})
603    ret = False
604except AssertionError:
605    ret = True
606
607assert(ret)
608#Following test demonstrate a non-sensical yet acceptable usage :(
609x = f.any2i(None, {'Toto'})
610assert('Toto' in x)
611
612= Test calls on MultiFlagsField.i2m
613~ multiflagsfield
614
615import collections
616MockPacket = collections.namedtuple('MockPacket', ['type'])
617
618f = MultiFlagsField('flags', set(), 3, {
619        0: {
620            0: MultiFlagsEntry('A', 'OptionA'),
621            1: MultiFlagsEntry('B', 'OptionB'),
622        },
623        1: {
624            0: MultiFlagsEntry('+', 'Plus'),
625            1: MultiFlagsEntry('*', 'Star'),
626        },
627    },
628    depends_on=lambda x: x.type
629)
630
631mp = MockPacket(0)
632x = f.i2m(mp, set())
633assert(isinstance(x, six.integer_types))
634assert(x == 0)
635x = f.i2m(mp, {'A'})
636assert(isinstance(x, six.integer_types))
637assert(x == 1)
638x = f.i2m(mp, {'A', 'B'})
639assert(isinstance(x, six.integer_types))
640assert(x == 3)
641x = f.i2m(mp, {'A', 'B', 'bit 2'})
642assert(isinstance(x, six.integer_types))
643assert(x == 7)
644try:
645    x = f.i2m(mp, {'+'})
646    ret = False
647except:
648    ret = True
649
650assert(ret)
651
652= Test calls on MultiFlagsField.m2i
653~ multiflagsfield
654
655import collections
656MockPacket = collections.namedtuple('MockPacket', ['type'])
657
658f = MultiFlagsField('flags', set(), 3, {
659        0: {
660            0: MultiFlagsEntry('A', 'OptionA'),
661            1: MultiFlagsEntry('B', 'OptionB'),
662        },
663        1: {
664            0: MultiFlagsEntry('+', 'Plus'),
665            1: MultiFlagsEntry('*', 'Star'),
666        },
667    },
668    depends_on=lambda x: x.type
669)
670
671mp = MockPacket(0)
672x = f.m2i(mp, 2)
673assert(isinstance(x, set))
674assert(len(x) == 1)
675assert('B' in x)
676assert('A' not in x)
677assert('*' not in x)
678
679x = f.m2i(mp, 7)
680assert(isinstance(x, set))
681assert('B' in x)
682assert('A' in x)
683assert('bit 2' in x)
684assert('*' not in x)
685assert('+' not in x)
686x = f.m2i(mp, 0)
687assert(len(x) == 0)
688mp = MockPacket(1)
689x = f.m2i(mp, 2)
690assert(isinstance(x, set))
691assert(len(x) == 1)
692assert('*' in x)
693assert('+' not in x)
694assert('B' not in x)
695
696= Test calls on MultiFlagsField.i2repr
697~ multiflagsfield
698
699import collections, re
700MockPacket = collections.namedtuple('MockPacket', ['type'])
701
702f = MultiFlagsField('flags', set(), 3, {
703        0: {
704            0: MultiFlagsEntry('A', 'OptionA'),
705            1: MultiFlagsEntry('B', 'OptionB'),
706        },
707        1: {
708            0: MultiFlagsEntry('+', 'Plus'),
709            1: MultiFlagsEntry('*', 'Star'),
710        },
711    },
712    depends_on=lambda x: x.type
713)
714
715mp = MockPacket(0)
716x = f.i2repr(mp, {'A', 'B'})
717assert(re.match(r'^.*OptionA \(A\).*$', x) is not None)
718assert(re.match(r'^.*OptionB \(B\).*$', x) is not None)
719mp = MockPacket(1)
720x = f.i2repr(mp, {'*', '+', 'bit 2'})
721assert(re.match(r'^.*Star \(\*\).*$', x) is not None)
722assert(re.match(r'^.*Plus \(\+\).*$', x) is not None)
723assert(re.match(r'^.*bit 2.*$', x) is not None)
724
725############
726############
727+ EnumField tests
728
729= EnumField tests initialization
730
731# Basic EnumField
732f = EnumField('test', 0, {0: 'Foo', 1: 'Bar'})
733# Reverse i2s/s2i
734rf = EnumField('test', 0, {'Foo': 0, 'Bar': 1})
735# EnumField initialized with a list
736lf = EnumField('test', 0, ['Foo', 'Bar'])
737# EnumField with i2s_cb/s2i_cb
738fcb = EnumField('test', 0, (
739        lambda x: 'Foo' if x == 0 else 'Bar' if 1 <= x <= 10 else repr(x),
740        lambda x: 0 if x == 'Foo' else 1 if x == 'Bar' else int(x),
741    )
742)
743
744def expect_exception(e, c):
745    try:
746        eval(c)
747        return False
748    except e:
749        return True
750
751
752= EnumField.any2i_one
753~ field enumfield
754
755assert(f.any2i_one(None, 'Foo') == 0)
756assert(f.any2i_one(None, 'Bar') == 1)
757assert(f.any2i_one(None, 2) == 2)
758expect_exception(KeyError, 'f.any2i_one(None, "Baz")')
759
760assert(rf.any2i_one(None, 'Foo') == 0)
761assert(rf.any2i_one(None, 'Bar') == 1)
762assert(rf.any2i_one(None, 2) == 2)
763expect_exception(KeyError, 'rf.any2i_one(None, "Baz")')
764
765assert(lf.any2i_one(None, 'Foo') == 0)
766assert(lf.any2i_one(None, 'Bar') == 1)
767assert(lf.any2i_one(None, 2) == 2)
768expect_exception(KeyError, 'lf.any2i_one(None, "Baz")')
769
770assert(fcb.any2i_one(None, 'Foo') == 0)
771assert(fcb.any2i_one(None, 'Bar') == 1)
772assert(fcb.any2i_one(None, 5) == 5)
773expect_exception(ValueError, 'fcb.any2i_one(None, "Baz")')
774
775True
776
777= EnumField.any2i
778~ field enumfield
779
780assert(f.any2i(None, 'Foo') == 0)
781assert(f.any2i(None, 'Bar') == 1)
782assert(f.any2i(None, 2) == 2)
783expect_exception(KeyError, 'f.any2i(None, "Baz")')
784assert(f.any2i(None, ['Foo', 'Bar', 2]) == [0, 1, 2])
785
786assert(rf.any2i(None, 'Foo') == 0)
787assert(rf.any2i(None, 'Bar') == 1)
788assert(rf.any2i(None, 2) == 2)
789expect_exception(KeyError, 'rf.any2i(None, "Baz")')
790assert(rf.any2i(None, ['Foo', 'Bar', 2]) == [0, 1, 2])
791
792assert(lf.any2i(None, 'Foo') == 0)
793assert(lf.any2i(None, 'Bar') == 1)
794assert(lf.any2i(None, 2) == 2)
795expect_exception(KeyError, 'lf.any2i(None, "Baz")')
796assert(lf.any2i(None, ['Foo', 'Bar', 2]) == [0, 1, 2])
797
798assert(fcb.any2i(None, 'Foo') == 0)
799assert(fcb.any2i(None, 'Bar') == 1)
800assert(fcb.any2i(None, 5) == 5)
801expect_exception(ValueError, 'fcb.any2i(None, "Baz")')
802assert(f.any2i(None, ['Foo', 'Bar', 5]) == [0, 1, 5])
803
804True
805
806= EnumField.i2repr_one
807~ field enumfield
808
809assert(f.i2repr_one(None, 0) == 'Foo')
810assert(f.i2repr_one(None, 1) == 'Bar')
811expect_exception(KeyError, 'f.i2repr_one(None, 2)')
812
813assert(rf.i2repr_one(None, 0) == 'Foo')
814assert(rf.i2repr_one(None, 1) == 'Bar')
815expect_exception(KeyError, 'rf.i2repr_one(None, 2)')
816
817assert(lf.i2repr_one(None, 0) == 'Foo')
818assert(lf.i2repr_one(None, 1) == 'Bar')
819expect_exception(KeyError, 'lf.i2repr_one(None, 2)')
820
821assert(fcb.i2repr_one(None, 0) == 'Foo')
822assert(fcb.i2repr_one(None, 1) == 'Bar')
823assert(fcb.i2repr_one(None, 5) == 'Bar')
824assert(fcb.i2repr_one(None, 11) == repr(11))
825
826conf.noenum.add(f, rf, lf, fcb)
827
828assert(f.i2repr_one(None, 0) == repr(0))
829assert(f.i2repr_one(None, 1) == repr(1))
830assert(f.i2repr_one(None, 2) == repr(2))
831
832assert(rf.i2repr_one(None, 0) == repr(0))
833assert(rf.i2repr_one(None, 1) == repr(1))
834assert(rf.i2repr_one(None, 2) == repr(2))
835
836assert(lf.i2repr_one(None, 0) == repr(0))
837assert(lf.i2repr_one(None, 1) == repr(1))
838assert(lf.i2repr_one(None, 2) == repr(2))
839
840assert(fcb.i2repr_one(None, 0) == repr(0))
841assert(fcb.i2repr_one(None, 1) == repr(1))
842assert(fcb.i2repr_one(None, 5) == repr(5))
843assert(fcb.i2repr_one(None, 11) == repr(11))
844
845conf.noenum.remove(f, rf, lf, fcb)
846
847assert(f.i2repr_one(None, RandNum(0, 10)) == '<RandNum>')
848assert(rf.i2repr_one(None, RandNum(0, 10)) == '<RandNum>')
849assert(lf.i2repr_one(None, RandNum(0, 10)) == '<RandNum>')
850assert(fcb.i2repr_one(None, RandNum(0, 10)) == '<RandNum>')
851
852True
853
854= EnumField.i2repr
855~ field enumfield
856
857assert(f.i2repr(None, 0) == 'Foo')
858assert(f.i2repr(None, 1) == 'Bar')
859expect_exception(KeyError, 'f.i2repr(None, 2)')
860assert(f.i2repr(None, [0, 1]) == ['Foo', 'Bar'])
861
862assert(rf.i2repr(None, 0) == 'Foo')
863assert(rf.i2repr(None, 1) == 'Bar')
864expect_exception(KeyError, 'rf.i2repr(None, 2)')
865assert(rf.i2repr(None, [0, 1]) == ['Foo', 'Bar'])
866
867assert(lf.i2repr(None, 0) == 'Foo')
868assert(lf.i2repr(None, 1) == 'Bar')
869expect_exception(KeyError, 'lf.i2repr(None, 2)')
870assert(lf.i2repr(None, [0, 1]) == ['Foo', 'Bar'])
871
872assert(fcb.i2repr(None, 0) == 'Foo')
873assert(fcb.i2repr(None, 1) == 'Bar')
874assert(fcb.i2repr(None, 5) == 'Bar')
875assert(fcb.i2repr(None, 11) == repr(11))
876assert(fcb.i2repr(None, [0, 1, 5, 11]) == ['Foo', 'Bar', 'Bar', repr(11)])
877
878conf.noenum.add(f, rf, lf, fcb)
879
880assert(f.i2repr(None, 0) == repr(0))
881assert(f.i2repr(None, 1) == repr(1))
882assert(f.i2repr(None, 2) == repr(2))
883assert(f.i2repr(None, [0, 1, 2]) == [repr(0), repr(1), repr(2)])
884
885assert(rf.i2repr(None, 0) == repr(0))
886assert(rf.i2repr(None, 1) == repr(1))
887assert(rf.i2repr(None, 2) == repr(2))
888assert(rf.i2repr(None, [0, 1, 2]) == [repr(0), repr(1), repr(2)])
889
890assert(lf.i2repr(None, 0) == repr(0))
891assert(lf.i2repr(None, 1) == repr(1))
892assert(lf.i2repr(None, 2) == repr(2))
893assert(lf.i2repr(None, [0, 1, 2]) == [repr(0), repr(1), repr(2)])
894
895assert(fcb.i2repr(None, 0) == repr(0))
896assert(fcb.i2repr(None, 1) == repr(1))
897assert(fcb.i2repr(None, 5) == repr(5))
898assert(fcb.i2repr(None, 11) == repr(11))
899assert(fcb.i2repr(None, [0, 1, 5, 11]) == [repr(0), repr(1), repr(5), repr(11)])
900
901conf.noenum.remove(f, rf, lf, fcb)
902
903assert(f.i2repr_one(None, RandNum(0, 10)) == '<RandNum>')
904assert(rf.i2repr_one(None, RandNum(0, 10)) == '<RandNum>')
905assert(lf.i2repr_one(None, RandNum(0, 10)) == '<RandNum>')
906assert(fcb.i2repr_one(None, RandNum(0, 10)) == '<RandNum>')
907
908True
909
910############
911############
912+ CharEnumField tests
913
914= Building expect_exception handler
915~ field charenumfield
916
917def expect_exception(e, c):
918    try:
919        eval(c)
920        return False
921    except e:
922        return True
923
924
925= CharEnumField tests initialization
926~ field charenumfield
927
928fc = CharEnumField('test', 'f', {'f': 'Foo', 'b': 'Bar'})
929fcb = CharEnumField('test', 'a', (
930    lambda x: 'Foo' if x == 'a' else 'Bar' if x == 'b' else 'Baz',
931    lambda x: 'a' if x == 'Foo' else 'b' if x == 'Bar' else ''
932))
933
934True
935
936= CharEnumField.any2i_one
937~ field charenumfield
938
939assert(fc.any2i_one(None, 'Foo') == 'f')
940assert(fc.any2i_one(None, 'Bar') == 'b')
941expect_exception(KeyError, 'fc.any2i_one(None, "Baz")')
942
943assert(fcb.any2i_one(None, 'Foo') == 'a')
944assert(fcb.any2i_one(None, 'Bar') == 'b')
945assert(fcb.any2i_one(None, 'Baz') == '')
946
947True
948
949############
950############
951+ XShortEnumField tests
952
953= Building expect_exception handler
954~ field xshortenumfield
955
956def expect_exception(e, c):
957    try:
958        eval(c)
959        return False
960    except e:
961        return True
962
963
964= XShortEnumField tests initialization
965~ field xshortenumfield
966
967f = XShortEnumField('test', 0, {0: 'Foo', 1: 'Bar'})
968fcb = XShortEnumField('test', 0, (
969    lambda x: 'Foo' if x == 0 else 'Bar' if x == 1 else lhex(x),
970    lambda x: x
971))
972
973True
974
975= XShortEnumField.i2repr_one
976~ field xshortenumfield
977
978assert(f.i2repr_one(None, 0) == 'Foo')
979assert(f.i2repr_one(None, 1) == 'Bar')
980assert(f.i2repr_one(None, 0xff) == '0xff')
981
982assert(f.i2repr_one(None, 0) == 'Foo')
983assert(f.i2repr_one(None, 1) == 'Bar')
984assert(f.i2repr_one(None, 0xff) == '0xff')
985
986True
987
988############
989############
990+ DNSStrField tests
991
992= Raise exception - test data
993
994dnsf = DNSStrField("test", "")
995assert(dnsf.getfield("", b"\x01x\x00") == (b"", b"x."))
996
997try:
998    dnsf.getfield("", b"\xff")
999    assert(False)
1000except (Scapy_Exception, IndexError):
1001    pass
1002