test/lua/tvb.lua

   1 ----------------------------------------
   2 -- script-name: tvb.lua
   3 -- This tests the Tvb/TvbRange and proto_add_XXX_item API.
   4 ----------------------------------------
   5 local testlib = require("testlib")
   6
   7 local FRAME = "frame"
   8 local OTHER = "other"
   9
  10 -- expected number of runs per type
  11 --
  12 -- CHANGE THIS TO MATCH HOW MANY TESTS THERE ARE
  13 --
  14 -- The number of tests in a specific category (other than FRAME) is the
  15 -- number of times execute() is called by any function below testing().
  16 -- From the user's perspective, it can be calculated with the following
  17 -- formula:
  18 --
  19 -- N = number of execute() you call +
  20 --     number of verifyFields() * (1 + number of fields) +
  21 --     number of verifyResults() * (1 + 2 * number of values)
  22 --
  23 -- if one happens to know the number of fields and the number of values.
  24 --
  25 local n_frames = 1
  26 local taptests = { [FRAME]=n_frames, [OTHER]=391*n_frames }
  27
  28 testlib.init(taptests)
  29
  30 ------------- test script ------------
  31
  32 ----------------------------------------
  33 -- creates a Proto object for our testing
  34 local test_proto = Proto("test","Test Protocol")
  35
  36 local numinits = 0
  37 function test_proto.init()
  38     numinits = numinits + 1
  39     if numinits == 2 then
  40         testlib.getResults()
  41     end
  42 end
  43
  44
  45 ----------------------------------------
  46 -- a table of all of our Protocol's fields
  47 range_string = {
  48   { 0, 200, "The first part" },
  49   { 201, 233, "The second part" },
  50   { 234, 255, "The last part" },
  51 }
  52
  53 local testfield =
  54 {
  55     basic =
  56     {
  57         STRING         = ProtoField.string ("test.basic.string",  "Basic string"),
  58         BOOLEAN        = ProtoField.bool   ("test.basic.boolean", "Basic boolean", 16, {"yes","no"}, 0x0001),
  59         UINT8          = ProtoField.uint8  ("test.basic.uint8",   "Basic uint8 with range string", base.RANGE_STRING, range_string ),
  60         UINT16         = ProtoField.uint16 ("test.basic.uint16",  "Basic uint16"),
  61         UINT32         = ProtoField.uint32 ("test.basic.uint32",  "Basic uint32 test with a unit string", base.UINT_STRING, { "femtoFarads" }),
  62         INT24          = ProtoField.int24  ("test.basic.uint24",  "Basic uint24"),
  63         BYTES          = ProtoField.bytes  ("test.basic.bytes",   "Basic Bytes"),
  64         UINT_BYTES     = ProtoField.ubytes ("test.basic.ubytes",  "Basic Uint Bytes"),
  65         OID            = ProtoField.oid    ("test.basic.oid",     "Basic OID"),
  66         REL_OID        = ProtoField.rel_oid("test.basic.rel_oid", "Basic Relative OID"),
  67         ABSOLUTE_LOCAL = ProtoField.absolute_time("test.basic.absolute.local","Basic absolute local"),
  68         ABSOLUTE_UTC   = ProtoField.absolute_time("test.basic.absolute.utc",  "Basic absolute utc", base.UTC),
  69         IPv4           = ProtoField.ipv4   ("test.basic.ipv4",    "Basic ipv4 address"),
  70         IPv6           = ProtoField.ipv6   ("test.basic.ipv6",    "Basic ipv6 address"),
  71         ETHER          = ProtoField.ether  ("test.basic.ether",   "Basic ethernet address"),
  72         -- GUID           = ProtoField.guid   ("test.basic.guid",    "Basic GUID"),
  73     },
  74
  75     time =
  76     {
  77         ABSOLUTE_LOCAL = ProtoField.absolute_time("test.time.absolute.local","Time absolute local"),
  78         ABSOLUTE_UTC   = ProtoField.absolute_time("test.time.absolute.utc",  "Time absolute utc", base.UTC),
  79     },
  80
  81     bytes =
  82     {
  83         BYTES      = ProtoField.bytes  ("test.bytes.bytes",   "Bytes"),
  84         UINT_BYTES = ProtoField.ubytes ("test.bytes.ubytes",  "Uint Bytes"),
  85         OID        = ProtoField.oid    ("test.bytes.oid",     "OID"),
  86         REL_OID    = ProtoField.rel_oid("test.bytes.rel_oid", "Relative OID"),
  87         -- GUID       = ProtoField.guid   ("test.bytes.guid",    "GUID"),
  88     },
  89 }
  90
  91 -- create a flat array table of the above that can be registered
  92 local pfields = {}
  93 for _,t in pairs(testfield) do
  94     for k,v in pairs(t) do
  95         pfields[#pfields+1] = v
  96     end
  97 end
  98
  99 -- register them
 100 test_proto.fields = pfields
 101
 102 print("test_proto ProtoFields registered")
 103
 104
 105 local getfield =
 106 {
 107     basic =
 108     {
 109         STRING         = Field.new ("test.basic.string"),
 110         BOOLEAN        = Field.new ("test.basic.boolean"),
 111         UINT8          = Field.new ("test.basic.uint8"),
 112         UINT16         = Field.new ("test.basic.uint16"),
 113         INT24          = Field.new ("test.basic.uint24"),
 114         BYTES          = Field.new ("test.basic.bytes"),
 115         UINT_BYTES     = Field.new ("test.basic.ubytes"),
 116         OID            = Field.new ("test.basic.oid"),
 117         REL_OID        = Field.new ("test.basic.rel_oid"),
 118         ABSOLUTE_LOCAL = Field.new ("test.basic.absolute.local"),
 119         ABSOLUTE_UTC   = Field.new ("test.basic.absolute.utc"),
 120         IPv4           = Field.new ("test.basic.ipv4"),
 121         IPv6           = Field.new ("test.basic.ipv6"),
 122         ETHER          = Field.new ("test.basic.ether"),
 123         -- GUID           = Field.new ("test.basic.guid"),
 124     },
 125
 126     time =
 127     {
 128         ABSOLUTE_LOCAL = Field.new ("test.time.absolute.local"),
 129         ABSOLUTE_UTC   = Field.new ("test.time.absolute.utc"),
 130     },
 131
 132     bytes =
 133     {
 134         BYTES      = Field.new ("test.bytes.bytes"),
 135         UINT_BYTES = Field.new ("test.bytes.ubytes"),
 136         OID        = Field.new ("test.bytes.oid"),
 137         REL_OID    = Field.new ("test.bytes.rel_oid"),
 138         -- GUID       = Field.new ("test.bytes.guid"),
 139     },
 140 }
 141
 142 print("test_proto Fields created")
 143
 144 local function addMatchFields(match_fields, ... )
 145     match_fields[#match_fields + 1] = { ... }
 146 end
 147
 148 local function getFieldInfos(name)
 149     local base, field = name:match("([^.]+)%.(.+)")
 150     if not base or not field then
 151         error("failed to get base.field from '" .. name .. "'")
 152     end
 153     local t = { getfield[base][field]() }
 154     return t
 155 end
 156
 157 local function verifyFields(name, match_fields)
 158     local finfos = getFieldInfos(name)
 159
 160     testlib.test(OTHER, "verify-fields-size-" .. name, #finfos == #match_fields,
 161              "#finfos=" .. #finfos .. ", #match_fields=" .. #match_fields)
 162
 163     for i, t in ipairs(match_fields) do
 164         if type(t) ~= 'table' then
 165             error("verifyFields didn't get a table inside the matches table")
 166         end
 167         if #t ~= 1 then
 168             error("verifyFields matches table's table is not size 1")
 169         end
 170         local result = finfos[i]()
 171         local value  = t[1]
 172         print(
 173                 name .. " got:",
 174                 "\n\tfinfos [" .. i .. "]='" .. tostring( result ) .. "'",
 175                 "\n\tmatches[" .. i .. "]='" .. tostring( value  ) .. "'"
 176              )
 177         testlib.test(OTHER, "verify-fields-value-" .. name .. "-" .. i, result == value )
 178     end
 179 end
 180
 181
 182 local function addMatchValues(match_values, ... )
 183     match_values[#match_values + 1] = { ... }
 184 end
 185
 186 local function addMatchFieldValues(match_fields, match_values, match_both, ...)
 187     addMatchFields(match_fields, match_both)
 188     addMatchValues(match_values, match_both, ...)
 189 end
 190
 191 local result_values = {}
 192 local function resetResults()
 193     result_values = {}
 194 end
 195
 196 local function treeAddPField(...)
 197     local t = { pcall ( TreeItem.add_packet_field, ... ) }
 198     if t[1] == nil then
 199         return nil, t[2]
 200     end
 201     -- it gives back a TreeItem, then the results
 202     if typeof(t[2]) ~= 'TreeItem' then
 203         return nil, "did not get a TreeItem returned from TreeItem.add_packet_field, "..
 204                     "got a '" .. typeof(t[2]) .."'"
 205     end
 206
 207     if #t ~= 4 then
 208         return nil, "did not get 3 return values from TreeItem.add_packet_field"
 209     end
 210
 211     result_values[#result_values + 1] = { t[3], t[4] }
 212
 213     return true
 214 end
 215
 216 local function verifyResults(name, match_values)
 217     testlib.test(OTHER, "verify-results-size-" .. name, #result_values == #match_values,
 218              "#result_values=" .. #result_values ..
 219              ", #match_values=" .. #match_values)
 220
 221     for j, t in ipairs(match_values) do
 222         if type(t) ~= 'table' then
 223             error("verifyResults didn't get a table inside the matches table")
 224         end
 225         for i, match in ipairs(t) do
 226             local r = result_values[j][i]
 227             print(
 228                     name .. " got:",
 229                     "\n\tresults[" .. j .. "][" .. i .. "]='" .. tostring( r ) .. "'",
 230                     "\n\tmatches[" .. j .. "][" .. i .. "]='" .. tostring( match ) .. "'"
 231                  )
 232             local result_type, match_type
 233             if type(match) == 'userdata' then
 234                 match_type = typeof(match)
 235             else
 236                 match_type = type(match)
 237             end
 238             if type(r) == 'userdata' then
 239                 result_type = typeof(r)
 240             else
 241                 result_type = type(r)
 242             end
 243             testlib.test(OTHER, "verify-results-type-" .. name .. "-" .. i, result_type == match_type )
 244             testlib.test(OTHER, "verify-results-value-" .. name .. "-" .. i, r == match )
 245         end
 246     end
 247 end
 248
 249 -- Compute the difference in seconds between local time and UTC
 250 -- from http://lua-users.org/wiki/TimeZone
 251 local function get_timezone()
 252   local now = os.time()
 253   return os.difftime(now, os.time(os.date("!*t", now)))
 254 end
 255 local timezone = get_timezone()
 256 print ("timezone = " .. timezone)
 257
 258 ----------------------------------------
 259 -- The following creates the callback function for the dissector.
 260 -- The 'tvbuf' is a Tvb object, 'pktinfo' is a Pinfo object, and 'root' is a TreeItem object.
 261 function test_proto.dissector(tvbuf,pktinfo,root)
 262
 263     testlib.countPacket(FRAME)
 264     testlib.countPacket(OTHER)
 265
 266     testlib.testing(OTHER, "Basic string")
 267
 268     local tree = root:add(test_proto, tvbuf:range(0,tvbuf:len()))
 269
 270     -- create a fake Tvb to use for testing
 271     local teststring = "this is the string for the first test"
 272     local bytearray  = ByteArray.new(teststring, true)
 273     local tvb_string = bytearray:tvb("Basic string")
 274
 275     local function callTreeAdd(tree,...)
 276         tree:add(...)
 277     end
 278
 279     local string_match_fields = {}
 280
 281     testlib.test(OTHER, "basic-tvb_get_string", tvb_string:range():string() == teststring )
 282
 283     testlib.test(OTHER, "basic-string", tree:add(testfield.basic.STRING, tvb_string:range(0,tvb_string:len())) ~= nil )
 284     addMatchFields(string_match_fields, teststring)
 285
 286     testlib.test(OTHER, "basic-string", pcall (callTreeAdd, tree, testfield.basic.STRING, tvb_string:range() ) )
 287     addMatchFields(string_match_fields, teststring)
 288
 289     verifyFields("basic.STRING", string_match_fields)
 290
 291 ----------------------------------------
 292     testlib.testing(OTHER, "Basic boolean")
 293
 294     local barray_bytes_hex  = "00FF00018000"
 295     local barray_bytes      = ByteArray.new(barray_bytes_hex)
 296     local tvb_bytes         = barray_bytes:tvb("Basic bytes")
 297     local bool_match_fields = {}
 298
 299     testlib.test(OTHER, "basic-boolean", pcall (callTreeAdd, tree, testfield.basic.BOOLEAN, tvb_bytes:range(0,2)) )
 300     addMatchFields(bool_match_fields, true)
 301
 302     testlib.test(OTHER, "basic-boolean", pcall (callTreeAdd, tree, testfield.basic.BOOLEAN, tvb_bytes:range(2,2)) )
 303     addMatchFields(bool_match_fields, true)
 304
 305     testlib.test(OTHER, "basic-boolean", pcall (callTreeAdd, tree, testfield.basic.BOOLEAN, tvb_bytes:range(4,2)) )
 306     addMatchFields(bool_match_fields, false)
 307
 308     verifyFields("basic.BOOLEAN", bool_match_fields )
 309
 310 ----------------------------------------
 311     testlib.testing(OTHER, "Basic uint16")
 312
 313     local uint16_match_fields = {}
 314
 315     testlib.test(OTHER, "basic-uint16", pcall (callTreeAdd, tree, testfield.basic.UINT16, tvb_bytes:range(0,2)) )
 316     addMatchFields(uint16_match_fields, 255)
 317
 318     testlib.test(OTHER, "basic-uint16", pcall (callTreeAdd, tree, testfield.basic.UINT16, tvb_bytes:range(2,2)) )
 319     addMatchFields(uint16_match_fields, 1)
 320
 321     testlib.test(OTHER, "basic-uint16", pcall (callTreeAdd, tree, testfield.basic.UINT16, tvb_bytes:range(4,2)) )
 322     addMatchFields(uint16_match_fields, 32768)
 323
 324     verifyFields("basic.UINT16", uint16_match_fields)
 325
 326 ----------------------------------------
 327     testlib.testing(OTHER, "Basic uint16-le")
 328
 329     local function callTreeAddLE(tree,...)
 330         tree:add_le(...)
 331     end
 332
 333     testlib.test(OTHER, "basic-uint16-le", pcall (callTreeAddLE, tree, testfield.basic.UINT16, tvb_bytes:range(0,2)) )
 334     addMatchFields(uint16_match_fields, 65280)
 335
 336     testlib.test(OTHER, "basic-uint16-le", pcall (callTreeAddLE, tree, testfield.basic.UINT16, tvb_bytes:range(2,2)) )
 337     addMatchFields(uint16_match_fields, 256)
 338
 339     testlib.test(OTHER, "basic-uint16-le", pcall (callTreeAddLE, tree, testfield.basic.UINT16, tvb_bytes:range(4,2)) )
 340     addMatchFields(uint16_match_fields, 128)
 341
 342     verifyFields("basic.UINT16", uint16_match_fields)
 343
 344 ----------------------------------------
 345     testlib.testing(OTHER, "Basic int24")
 346
 347     local int24_match_fields = {}
 348
 349     testlib.test(OTHER, "basic-int24", pcall (callTreeAdd, tree, testfield.basic.INT24, tvb_bytes:range(0,3)) )
 350     addMatchFields(int24_match_fields, 65280)
 351
 352     testlib.test(OTHER, "basic-int24", pcall (callTreeAdd, tree, testfield.basic.INT24, tvb_bytes:range(3,3)) )
 353     addMatchFields(int24_match_fields, 98304)
 354
 355     verifyFields("basic.INT24", int24_match_fields)
 356
 357 ----------------------------------------
 358     testlib.testing(OTHER, "Basic int24-le")
 359
 360     testlib.test(OTHER, "basic-int24", pcall (callTreeAddLE, tree, testfield.basic.INT24, tvb_bytes:range(0,3)) )
 361     addMatchFields(int24_match_fields, 65280)
 362
 363     testlib.test(OTHER, "basic-int24", pcall (callTreeAddLE, tree, testfield.basic.INT24, tvb_bytes:range(3,3)) )
 364     addMatchFields(int24_match_fields, 32769)
 365
 366     verifyFields("basic.INT24", int24_match_fields)
 367
 368 ----------------------------------------
 369     testlib.testing(OTHER, "Basic bytes")
 370
 371     local bytes_match_fields = {}
 372
 373     testlib.test(OTHER, "basic-tvb_get_string_bytes",
 374              string.lower(tostring(tvb_bytes:range():bytes())) == string.lower(barray_bytes_hex))
 375
 376     testlib.test(OTHER, "basic-bytes", pcall (callTreeAdd, tree, testfield.basic.BYTES, tvb_bytes:range()) )
 377     addMatchFields(bytes_match_fields, barray_bytes)
 378
 379     -- TODO: it's silly that tree:add_packet_field() requires an encoding argument
 380     --  need to fix that separately in a bug fix
 381     testlib.test(OTHER, "add_pfield-bytes", treeAddPField(tree, testfield.basic.BYTES,
 382                                                tvb_bytes:range(), ENC_BIG_ENDIAN))
 383     addMatchFields(bytes_match_fields, barray_bytes)
 384
 385     verifyFields("basic.BYTES", bytes_match_fields)
 386
 387 ----------------------------------------
 388     testlib.testing(OTHER, "Basic uint bytes")
 389
 390     local len_string        = string.format("%02x", barray_bytes:len())
 391     local barray_uint_bytes = ByteArray.new(len_string) .. barray_bytes
 392     local tvb_uint_bytes    = barray_uint_bytes:tvb("Basic UINT_BYTES")
 393     local uint_bytes_match_fields = {}
 394
 395     testlib.test(OTHER, "basic-uint-bytes", pcall (callTreeAdd, tree, testfield.basic.UINT_BYTES,
 396                                         tvb_uint_bytes:range(0,1)) )
 397     addMatchFields(uint_bytes_match_fields, barray_bytes)
 398
 399     testlib.test(OTHER, "add_pfield-uint-bytes", treeAddPField(tree, testfield.basic.UINT_BYTES,
 400                                                     tvb_uint_bytes:range(0,1), ENC_BIG_ENDIAN) )
 401     addMatchFields(uint_bytes_match_fields, barray_bytes)
 402
 403     verifyFields("basic.UINT_BYTES", uint_bytes_match_fields)
 404
 405 ----------------------------------------
 406     testlib.testing(OTHER, "Basic OID")
 407
 408     -- note: the tvb being dissected and compared isn't actually a valid OID.
 409     -- tree:add() and tree:add_packet-field() don't care about its validity right now.
 410
 411     local oid_match_fields = {}
 412
 413     testlib.test(OTHER, "basic-oid", pcall(callTreeAdd, tree, testfield.basic.OID, tvb_bytes:range()) )
 414     addMatchFields(oid_match_fields, barray_bytes)
 415
 416     testlib.test(OTHER, "add_pfield-oid", treeAddPField(tree, testfield.basic.OID,
 417                                              tvb_bytes:range(), ENC_BIG_ENDIAN) )
 418     addMatchFields(oid_match_fields, barray_bytes)
 419
 420     verifyFields("basic.OID", oid_match_fields)
 421
 422 ----------------------------------------
 423     testlib.testing(OTHER, "Basic REL_OID")
 424
 425     -- note: the tvb being dissected and compared isn't actually a valid OID.
 426     -- tree:add() and tree:add_packet-field() don't care about its validity right now.
 427
 428     local rel_oid_match_fields = {}
 429
 430     testlib.test(OTHER, "basic-rel-oid", pcall(callTreeAdd, tree, testfield.basic.REL_OID, tvb_bytes:range()))
 431     addMatchFields(rel_oid_match_fields, barray_bytes)
 432
 433     testlib.test(OTHER, "add_pfield-rel_oid", treeAddPField(tree, testfield.basic.REL_OID,
 434                                                  tvb_bytes:range(), ENC_BIG_ENDIAN) )
 435     addMatchFields(rel_oid_match_fields, barray_bytes)
 436
 437     verifyFields("basic.REL_OID", rel_oid_match_fields)
 438
 439     -- TODO: a FT_GUID is not really a ByteArray, so we can't simply treat it as one
 440     -- local barray_guid       = ByteArray.new("00FF0001 80001234 567890AB CDEF00FF")
 441     -- local tvb_guid          = barray_guid:tvb("Basic GUID")
 442     -- local guid_match_fields = {}
 443
 444     -- testlib.test(OTHER, "basic-guid", pcall(callTreeAdd, tree, testfield.basic.GUID, tvb_guid:range()) )
 445     -- addMatchFields(guid_match_fields, barray_guid)
 446
 447     -- testlib.test(OTHER, "add_pfield-guid", treeAddPField(tree, testfield.basic.GUID,
 448     --                                          tvb_guid:range(), ENC_BIG_ENDIAN) )
 449     -- addMatchFields(guid_match_fields, barray_guid)
 450
 451     -- verifyFields("basic.GUID", guid_match_fields)
 452
 453 ----------------------------------------
 454     testlib.testing(OTHER, "tree:add ipv6")
 455
 456     local tvb = ByteArray.new("20010db8 00000000 0000ff00 00428329"):tvb("IPv6")
 457     local IPv6 = testfield.basic.IPv6
 458     local ipv6_match_fields = {}
 459
 460     testlib.test(OTHER, "ipv6", pcall (callTreeAdd, tree, IPv6, tvb:range(0,16)))
 461     addMatchFields(ipv6_match_fields, Address.ipv6('2001:0db8:0000:0000:0000:ff00:0042:8329'))
 462
 463     verifyFields("basic.IPv6", ipv6_match_fields)
 464
 465 ----------------------------------------
 466     testlib.testing(OTHER, "tree:add ipv4")
 467
 468     local tvb = ByteArray.new("7f000001"):tvb("IPv4")
 469     local IPv4 = testfield.basic.IPv4
 470     local ipv4_match_fields = {}
 471
 472     testlib.test(OTHER, "ipv4", pcall (callTreeAdd, tree, IPv4, tvb:range(0,4)))
 473     addMatchFields(ipv4_match_fields, Address.ip('127.0.0.1'))
 474
 475     -- TODO: currently, tree:add_le only works for numeric values, not IPv4
 476     -- addresses. Test this in the future.
 477
 478     -- testlib.test(OTHER, "ipv4", pcall (callTreeAddLE, tree, IPv4, tvb:range(0,4)))
 479     -- addMatchFields(ipv4_match_fields, Address.ip('1.0.0.127'))
 480
 481     verifyFields("basic.IPv4", ipv4_match_fields)
 482
 483 ----------------------------------------
 484     testlib.testing(OTHER, "tree:add ether")
 485
 486     local tvb = ByteArray.new("010203040506"):tvb("Ether")
 487     local tvb0 = ByteArray.new("000000000000"):tvb("Ether0")
 488     local ether = testfield.basic.ETHER
 489     local ether_match_fields = {}
 490
 491     testlib.test(OTHER, "ether", pcall (callTreeAdd, tree, ether, tvb:range(0,6)))
 492     addMatchFields(ether_match_fields, Address.ether('01:02:03:04:05:06'))
 493
 494     testlib.test(OTHER, "ether0", pcall (callTreeAdd, tree, ether, tvb0:range(0,6)))
 495     addMatchFields(ether_match_fields, Address.ether('11:22:33'))
 496
 497     verifyFields("basic.ETHER", ether_match_fields)
 498
 499 ----------------------------------------
 500     testlib.testing(OTHER, "tree:add_packet_field Bytes")
 501
 502     resetResults()
 503     bytes_match_fields = {}
 504     local bytes_match_values = {}
 505
 506     -- something to make this easier to read
 507     local function addMatch(...)
 508         addMatchFieldValues(bytes_match_fields, bytes_match_values, ...)
 509     end
 510
 511     local bytesstring1 =   "deadbeef0123456789DEADBEEFabcdef"
 512     local bytesstring = ByteArray.new(bytesstring1) -- the binary version of above, for comparing
 513     local bytestvb1 = ByteArray.new(bytesstring1, true):tvb("Bytes hex-string 1")
 514     local bytesstring2 = "  de:ad:be:ef:01:23:45:67:89:DE:AD:BE:EF:ab:cd:ef"
 515     local bytestvb2 = ByteArray.new(bytesstring2 .. "-f0-00 foobar", true):tvb("Bytes hex-string 2")
 516
 517     local bytestvb1_decode = bytestvb1:range():bytes(ENC_STR_HEX + ENC_SEP_NONE + ENC_SEP_COLON + ENC_SEP_DASH)
 518     testlib.test(OTHER, "tvb_get_string_bytes", string.lower(tostring(bytestvb1_decode)) == string.lower(tostring(bytesstring1)))
 519
 520     testlib.test(OTHER, "add_pfield-bytes1", treeAddPField(tree, testfield.bytes.BYTES,
 521                                                bytestvb1:range(),
 522                                                ENC_STR_HEX + ENC_SEP_NONE +
 523                                                ENC_SEP_COLON + ENC_SEP_DASH))
 524     addMatch(bytesstring, string.len(bytesstring1))
 525
 526     testlib.test(OTHER, "add_pfield-bytes2", treeAddPField(tree, testfield.bytes.BYTES,
 527                                                bytestvb2:range(),
 528                                                ENC_STR_HEX + ENC_SEP_NONE +
 529                                                ENC_SEP_COLON + ENC_SEP_DASH))
 530     addMatch(bytesstring, string.len(bytesstring2))
 531
 532     verifyResults("add_pfield-bytes", bytes_match_values)
 533     verifyFields("bytes.BYTES", bytes_match_fields)
 534
 535     -- extra test of ByteArray
 536     local b64padded = ByteArray.new("dGVzdA==", true):base64_decode():raw()
 537     local b64unpadded = ByteArray.new("dGVzdA", true):base64_decode():raw()
 538     testlib.test(OTHER, "bytearray_base64_padded", b64padded == "test")
 539     testlib.test(OTHER, "bytearray_base64_unpadded", b64unpadded == "test")
 540
 541
 542 ----------------------------------------
 543     testlib.testing(OTHER, "tree:add_packet_field OID")
 544
 545     resetResults()
 546     bytes_match_fields = {}
 547     bytes_match_values = {}
 548
 549     testlib.test(OTHER, "add_pfield-oid1", treeAddPField(tree, testfield.bytes.OID,
 550                                                bytestvb1:range(),
 551                                                ENC_STR_HEX + ENC_SEP_NONE +
 552                                                ENC_SEP_COLON + ENC_SEP_DASH))
 553     addMatch(bytesstring, string.len(bytesstring1))
 554
 555     testlib.test(OTHER, "add_pfield-oid2", treeAddPField(tree, testfield.bytes.OID,
 556                                                bytestvb2:range(),
 557                                                ENC_STR_HEX + ENC_SEP_NONE +
 558                                                ENC_SEP_COLON + ENC_SEP_DASH))
 559     addMatch(bytesstring, string.len(bytesstring2))
 560
 561     verifyResults("add_pfield-oid", bytes_match_values)
 562     verifyFields("bytes.OID", bytes_match_fields)
 563
 564
 565 ----------------------------------------
 566     testlib.testing(OTHER, "tree:add_packet_field REL_OID")
 567
 568     resetResults()
 569     bytes_match_fields = {}
 570     bytes_match_values = {}
 571
 572     testlib.test(OTHER, "add_pfield-rel_oid1", treeAddPField(tree, testfield.bytes.REL_OID,
 573                                                bytestvb1:range(),
 574                                                ENC_STR_HEX + ENC_SEP_NONE +
 575                                                ENC_SEP_COLON + ENC_SEP_DASH))
 576     addMatch(bytesstring, string.len(bytesstring1))
 577
 578     testlib.test(OTHER, "add_pfield-rel_oid2", treeAddPField(tree, testfield.bytes.REL_OID,
 579                                                bytestvb2:range(),
 580                                                ENC_STR_HEX + ENC_SEP_NONE +
 581                                                ENC_SEP_COLON + ENC_SEP_DASH))
 582     addMatch(bytesstring, string.len(bytesstring2))
 583
 584     verifyResults("add_pfield-rel_oid", bytes_match_values)
 585     verifyFields("bytes.REL_OID", bytes_match_fields)
 586
 587
 588 ----------------------------------------
 589     testlib.testing(OTHER, "tree:add Time")
 590
 591     local tvb = ByteArray.new("00000000 00000000 0000FF0F 00FF000F"):tvb("Time")
 592     local ALOCAL = testfield.time.ABSOLUTE_LOCAL
 593     local alocal_match_fields = {}
 594
 595     testlib.test(OTHER, "time-local",    pcall (callTreeAdd,   tree, ALOCAL, tvb:range(0,8)) )
 596     addMatchFields(alocal_match_fields, NSTime())
 597
 598     testlib.test(OTHER, "time-local",    pcall (callTreeAdd,   tree, ALOCAL, tvb:range(8,8)) )
 599     addMatchFields(alocal_match_fields, NSTime( 0x0000FF0F, 0x00FF000F) )
 600
 601     testlib.test(OTHER, "time-local-le", pcall (callTreeAddLE, tree, ALOCAL, tvb:range(0,8)) )
 602     addMatchFields(alocal_match_fields, NSTime())
 603
 604     testlib.test(OTHER, "time-local-le", pcall (callTreeAddLE, tree, ALOCAL, tvb:range(8,8)) )
 605     addMatchFields(alocal_match_fields, NSTime( 0x0FFF0000, 0x0F00FF00 ) )
 606
 607     verifyFields("time.ABSOLUTE_LOCAL", alocal_match_fields)
 608
 609     local AUTC = testfield.time.ABSOLUTE_UTC
 610     local autc_match_fields = {}
 611
 612     testlib.test(OTHER, "time-utc",    pcall (callTreeAdd,   tree, AUTC, tvb:range(0,8)) )
 613     addMatchFields(autc_match_fields, NSTime())
 614
 615     testlib.test(OTHER, "time-utc",    pcall (callTreeAdd,   tree, AUTC, tvb:range(8,8)) )
 616     addMatchFields(autc_match_fields, NSTime( 0x0000FF0F, 0x00FF000F) )
 617
 618     testlib.test(OTHER, "time-utc-le", pcall (callTreeAddLE, tree, AUTC, tvb:range(0,8)) )
 619     addMatchFields(autc_match_fields, NSTime())
 620
 621     testlib.test(OTHER, "time-utc-le", pcall (callTreeAddLE, tree, AUTC, tvb:range(8,8)) )
 622     addMatchFields(autc_match_fields, NSTime( 0x0FFF0000, 0x0F00FF00 ) )
 623
 624     verifyFields("time.ABSOLUTE_UTC", autc_match_fields )
 625
 626 ----------------------------------------
 627     testlib.testing(OTHER, "tree:add_packet_field Time bytes")
 628
 629     resetResults()
 630     local autc_match_values = {}
 631
 632     -- something to make this easier to read
 633     addMatch = function(...)
 634         addMatchFieldValues(autc_match_fields, autc_match_values, ...)
 635     end
 636
 637     -- tree:add_packet_field(ALOCAL, tvb:range(0,8), ENC_BIG_ENDIAN)
 638     testlib.test(OTHER, "add_pfield-time-bytes-local",    treeAddPField ( tree, AUTC, tvb:range(0,8), ENC_BIG_ENDIAN) )
 639     addMatch( NSTime(), 8)
 640
 641     testlib.test(OTHER, "add_pfield-time-bytes-local",    treeAddPField ( tree, AUTC, tvb:range(8,8), ENC_BIG_ENDIAN) )
 642     addMatch( NSTime( 0x0000FF0F, 0x00FF000F), 16)
 643
 644     testlib.test(OTHER, "add_pfield-time-bytes-local-le", treeAddPField ( tree, AUTC, tvb:range(0,8), ENC_LITTLE_ENDIAN) )
 645     addMatch( NSTime(), 8)
 646
 647     testlib.test(OTHER, "add_pfield-time-bytes-local-le", treeAddPField ( tree, AUTC, tvb:range(8,8), ENC_LITTLE_ENDIAN) )
 648     addMatch( NSTime( 0x0FFF0000, 0x0F00FF00 ), 16)
 649
 650     verifyFields("time.ABSOLUTE_UTC", autc_match_fields)
 651
 652     verifyResults("add_pfield-time-bytes-local", autc_match_values)
 653
 654 ----------------------------------------
 655     testlib.testing(OTHER, "tree:add_packet_field Time string ENC_ISO_8601_DATE_TIME")
 656
 657     resetResults()
 658     autc_match_values = {}
 659
 660     local datetimestring1 =   "2013-03-01T22:14:48+00:00" -- this is 1362176088 seconds epoch time
 661     local tvb1 = ByteArray.new(datetimestring1, true):tvb("Date_Time string 1")
 662     local datetimestring2 = "  2013-03-02T03:14:48+05:00" -- this is 1362176088 seconds epoch time
 663     local tvb2 = ByteArray.new(datetimestring2 .. "  foobar", true):tvb("Date_Time string 2")
 664     local datetimestring3 = "  2013-03-01T16:44-05:30"    -- this is 1362176040 seconds epoch time
 665     local tvb3 = ByteArray.new(datetimestring3, true):tvb("Date_Time string 3")
 666     local datetimestring4 =   "2013-03-02T01:44:00+03:30" -- this is 1362176040 seconds epoch time
 667     local tvb4 = ByteArray.new(datetimestring4, true):tvb("Date_Time string 4")
 668     local datetimestring5 =   "2013-03-01T22:14:48Z"      -- this is 1362176088 seconds epoch time
 669     local tvb5 = ByteArray.new(datetimestring5, true):tvb("Date_Time string 5")
 670     local datetimestring6 =   "2013-03-01T22:14Z"         -- this is 1362176040 seconds epoch time
 671     local tvb6 = ByteArray.new(datetimestring6, true):tvb("Date_Time string 6")
 672
 673     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb1:range(), ENC_ISO_8601_DATE_TIME) )
 674     addMatch( NSTime( 1362176088, 0), string.len(datetimestring1))
 675
 676     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb2:range(), ENC_ISO_8601_DATE_TIME) )
 677     addMatch( NSTime( 1362176088, 0), string.len(datetimestring2))
 678
 679     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb3:range(), ENC_ISO_8601_DATE_TIME) )
 680     addMatch( NSTime( 1362176040, 0), string.len(datetimestring3))
 681
 682     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb4:range(), ENC_ISO_8601_DATE_TIME) )
 683     addMatch( NSTime( 1362176040, 0), string.len(datetimestring4))
 684
 685     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb5:range(), ENC_ISO_8601_DATE_TIME) )
 686     addMatch( NSTime( 1362176088, 0), string.len(datetimestring5))
 687
 688     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb6:range(), ENC_ISO_8601_DATE_TIME) )
 689     addMatch( NSTime( 1362176040, 0), string.len(datetimestring6))
 690
 691     verifyFields("time.ABSOLUTE_UTC", autc_match_fields)
 692
 693     verifyResults("add_pfield-datetime-local", autc_match_values)
 694
 695 ----------------------------------------
 696     testlib.testing(OTHER, "tree:add_packet_field Time string ENC_ISO_8601_DATE")
 697
 698     resetResults()
 699     autc_match_values = {}
 700
 701     local datestring1 =   "2013-03-01"  -- this is 1362096000 seconds epoch time
 702     local d_tvb1 = ByteArray.new(datestring1, true):tvb("Date string 1")
 703     local datestring2 = "  2013-03-01"  -- this is 1362096000 seconds epoch time
 704     local d_tvb2 = ByteArray.new(datestring2 .. "  foobar", true):tvb("Date string 2")
 705
 706     testlib.test(OTHER, "add_pfield-date-local", treeAddPField ( tree, AUTC, d_tvb1:range(), ENC_ISO_8601_DATE) )
 707     addMatch( NSTime( 1362096000, 0), string.len(datestring1))
 708
 709     testlib.test(OTHER, "add_pfield-date-local", treeAddPField ( tree, AUTC, d_tvb2:range(), ENC_ISO_8601_DATE) )
 710     addMatch( NSTime( 1362096000, 0), string.len(datestring2))
 711
 712     verifyFields("time.ABSOLUTE_UTC", autc_match_fields)
 713
 714     verifyResults("add_pfield-date-local", autc_match_values)
 715
 716 ----------------------------------------
 717     testlib.testing(OTHER, "tree:add_packet_field Time string ENC_ISO_8601_TIME")
 718
 719     resetResults()
 720     autc_match_values = {}
 721
 722     local timestring1 =   "22:14:48"  -- this is 80088 seconds
 723     local t_tvb1 = ByteArray.new(timestring1, true):tvb("Time string 1")
 724     local timestring2 = "  22:14:48"  -- this is 80088 seconds
 725     local t_tvb2 = ByteArray.new(timestring2 .. "  foobar", true):tvb("Time string 2")
 726
 727     local now = os.date("!*t")
 728     now.hour = 22
 729     now.min  = 14
 730     now.sec  = 48
 731     local timebase = os.time( now )
 732     timebase = timebase + timezone
 733     print ("timebase = " .. tostring(timebase) .. ", timezone=" .. timezone)
 734
 735     testlib.test(OTHER, "add_pfield-time-local", treeAddPField ( tree, AUTC, t_tvb1:range(), ENC_ISO_8601_TIME) )
 736     addMatch( NSTime( timebase, 0), string.len(timestring1))
 737
 738     testlib.test(OTHER, "add_pfield-time-local", treeAddPField ( tree, AUTC, t_tvb2:range(), ENC_ISO_8601_TIME) )
 739     addMatch( NSTime( timebase, 0), string.len(timestring2))
 740
 741     verifyFields("time.ABSOLUTE_UTC", autc_match_fields)
 742
 743     verifyResults("add_pfield-time-local", autc_match_values)
 744
 745 ----------------------------------------
 746     testlib.testing(OTHER, "tree:add_packet_field Time string ENC_IMF_DATE_TIME")
 747
 748     resetResults()
 749     autc_match_values = {}
 750
 751     local imfstring1 =   "Fri, 01 Mar 13 22:14:48 GMT"  -- this is 1362176088 seconds epoch time
 752     local imf_tvb1 = ByteArray.new(imfstring1, true):tvb("Internet Message Format Time string 1")
 753     local imfstring2 = "  Fri, 01 Mar 13 22:14:48 GMT"  -- this is 1362176088 seconds epoch time
 754     local imf_tvb2 = ByteArray.new(imfstring2 .. "  foobar", true):tvb("Internet Message Format Time string 2")
 755     local imfstring3 =   "Fri, 01 Mar 2013 22:14:48 GMT"  -- this is 1362176088 seconds epoch time
 756     local imf_tvb3 = ByteArray.new(imfstring3, true):tvb("Internet Message Format Time string 3")
 757     local imfstring4 = "  Fri, 01 Mar 2013 22:14:48 GMT"  -- this is 1362176088 seconds epoch time
 758     local imf_tvb4 = ByteArray.new(imfstring4 .. "  foobar", true):tvb("Internet Message Format Time string 4")
 759
 760     testlib.test(OTHER, "add_pfield-time-local", treeAddPField ( tree, AUTC, imf_tvb1:range(), ENC_IMF_DATE_TIME) )
 761     addMatch( NSTime( 1362176088, 0), string.len(imfstring1))
 762
 763     testlib.test(OTHER, "add_pfield-time-local", treeAddPField ( tree, AUTC, imf_tvb2:range(), ENC_IMF_DATE_TIME) )
 764     addMatch( NSTime( 1362176088, 0), string.len(imfstring2))
 765
 766     testlib.test(OTHER, "add_pfield-time-local", treeAddPField ( tree, AUTC, imf_tvb3:range(), ENC_IMF_DATE_TIME) )
 767     addMatch( NSTime( 1362176088, 0), string.len(imfstring3))
 768
 769     testlib.test(OTHER, "add_pfield-time-local", treeAddPField ( tree, AUTC, imf_tvb4:range(), ENC_IMF_DATE_TIME) )
 770     addMatch( NSTime( 1362176088, 0), string.len(imfstring4))
 771
 772     verifyFields("time.ABSOLUTE_UTC", autc_match_fields)
 773
 774     verifyResults("add_pfield-imf-date-time-local", autc_match_values)
 775
 776 ----------------------------------------
 777     testlib.testing(OTHER, "tree:add_packet_field Time string ENC_ISO_8601_DATE_TIME_BASIC")
 778
 779     resetResults()
 780     autc_match_values = {}
 781
 782     local datetimestring1 =   "20130301T221448+0000" -- this is 1362176088 seconds epoch time
 783     local tvb1 = ByteArray.new(datetimestring1, true):tvb("Date_Time string 1")
 784     local datetimestring2 = "  20130301171448-0500" -- this is 1362176088 seconds epoch time
 785     local tvb2 = ByteArray.new(datetimestring2 .. "  foobar", true):tvb("Date_Time string 2")
 786     local datetimestring3 = "  20130301T1644-0530"    -- this is 1362176040 seconds epoch time
 787     local tvb3 = ByteArray.new(datetimestring3, true):tvb("Date_Time string 3")
 788     local datetimestring4 =   "20130302 014400+0330" -- this is 1362176040 seconds epoch time
 789     local tvb4 = ByteArray.new(datetimestring4, true):tvb("Date_Time string 4")
 790     local datetimestring5 =   "20130301T221448Z"      -- this is 1362176088 seconds epoch time
 791     local tvb5 = ByteArray.new(datetimestring5, true):tvb("Date_Time string 5")
 792     local datetimestring6 =   "201303012214Z"         -- this is 1362176040 seconds epoch time
 793     local tvb6 = ByteArray.new(datetimestring6, true):tvb("Date_Time string 6")
 794
 795     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb1:range(), ENC_ISO_8601_DATE_TIME_BASIC) )
 796     addMatch( NSTime( 1362176088, 0), string.len(datetimestring1))
 797
 798     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb2:range(), ENC_ISO_8601_DATE_TIME_BASIC) )
 799     addMatch( NSTime( 1362176088, 0), string.len(datetimestring2))
 800
 801     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb3:range(), ENC_ISO_8601_DATE_TIME_BASIC) )
 802     addMatch( NSTime( 1362176040, 0), string.len(datetimestring3))
 803
 804     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb4:range(), ENC_ISO_8601_DATE_TIME_BASIC) )
 805     addMatch( NSTime( 1362176040, 0), string.len(datetimestring4))
 806
 807     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb5:range(), ENC_ISO_8601_DATE_TIME_BASIC) )
 808     addMatch( NSTime( 1362176088, 0), string.len(datetimestring5))
 809
 810     testlib.test(OTHER, "add_pfield-datetime-local", treeAddPField ( tree, AUTC, tvb6:range(), ENC_ISO_8601_DATE_TIME_BASIC) )
 811     addMatch( NSTime( 1362176040, 0), string.len(datetimestring6))
 812
 813     verifyFields("time.ABSOLUTE_UTC", autc_match_fields)
 814
 815     verifyResults("add_pfield-datetime-local", autc_match_values)
 816
 817 ----------------------------------------
 818     testlib.testing(OTHER, "TvbRange subsets")
 819
 820     resetResults()
 821
 822     local offset = 5
 823     local len = 10
 824     local b_offset = 3
 825     local b_len = 2
 826     local range
 827     local range_raw
 828     local expected
 829
 830     -- This is the same data from the "tree:add_packet_field Bytes" test
 831     -- copied here for clarity
 832     local bytesstring1 = "deadbeef0123456789DEADBEEFabcdef"
 833     local bytestvb1 = ByteArray.new(bytesstring1, true):tvb("Bytes hex-string 1")
 834
 835     -- tvbrange with no offset or length (control test case)
 836     range = bytestvb1()
 837     range_raw = range:raw()
 838     expected = range:bytes():raw()
 839     testlib.test(OTHER, "tvbrange_raw", range_raw == expected,
 840         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 841     range_raw = range:raw(b_offset)
 842     expected = range:bytes():raw(b_offset)
 843     testlib.test(OTHER, "tvbrange_raw_offset", range_raw == expected,
 844         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 845     range_raw = range:raw(0, b_len)
 846     expected = range:bytes():raw(0, b_len)
 847     testlib.test(OTHER, "tvbrange_raw_len", range_raw == expected,
 848         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 849     range_raw = range:raw(b_offset, b_len)
 850     expected = range:bytes():raw(b_offset, b_len)
 851     testlib.test(OTHER, "tvbrange_raw_offset_len", range_raw == expected,
 852         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 853
 854     -- tvbrange with len only
 855     range = bytestvb1(0, len)
 856     range_raw = range:raw()
 857     expected = range:bytes():raw()
 858     testlib.test(OTHER, "tvbrange_len_raw", range_raw == expected,
 859         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 860     range_raw = range:raw(b_offset)
 861     expected = range:bytes():raw(b_offset)
 862     testlib.test(OTHER, "tvbrange_len_raw_offset", range_raw == expected,
 863         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 864     range_raw = range:raw(0, b_len)
 865     expected = range:bytes():raw(0, b_len)
 866     testlib.test(OTHER, "tvbrange_len_raw_len", range_raw == expected,
 867         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 868     range_raw = range:raw(b_offset, b_len)
 869     expected = range:bytes():raw(b_offset, b_len)
 870     testlib.test(OTHER, "tvbrange_len_raw_offset_len", range_raw == expected,
 871         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 872
 873     -- tvbrange with offset only
 874     range = bytestvb1(offset)
 875     range_raw = range:raw()
 876     expected = range:bytes():raw()
 877     testlib.test(OTHER, "tvbrange_offset_raw", range_raw == expected,
 878         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 879     range_raw = range:raw(b_offset)
 880     expected = range:bytes():raw(b_offset)
 881     testlib.test(OTHER, "tvbrange_offset_raw_offset", range_raw == expected,
 882         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 883     range_raw = range:raw(0, b_len)
 884     expected = range:bytes():raw(0, b_len)
 885     testlib.test(OTHER, "tvbrange_offset_raw_len", range_raw == expected,
 886         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 887     range_raw = range:raw(b_offset, b_len)
 888     expected = range:bytes():raw(b_offset, b_len)
 889     testlib.test(OTHER, "tvbrange_offset_raw_offset_len", range_raw == expected,
 890         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 891
 892     -- tvbrange with offset and len
 893     range = bytestvb1(offset, len)
 894     range_raw = range:raw()
 895     expected = range:bytes():raw()
 896     testlib.test(OTHER, "tvbrange_offset_len_raw", range_raw == expected,
 897         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 898     range_raw = range:raw(b_offset)
 899     expected = range:bytes():raw(b_offset)
 900     testlib.test(OTHER, "tvbrange_offset_len_raw_offset", range_raw == expected,
 901         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 902     range_raw = range:raw(0, b_len)
 903     expected = range:bytes():raw(0, b_len)
 904     testlib.test(OTHER, "tvbrange_offset_len_raw_len", range_raw == expected,
 905         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 906     range_raw = range:raw(b_offset, b_len)
 907     expected = range:bytes():raw(b_offset, b_len)
 908     testlib.test(OTHER, "tvbrange_offset_len_raw_offset_len", range_raw == expected,
 909         string.format('range_raw="%s" expected="%s"', range_raw, expected))
 910
 911 ----------------------------------------
 912
 913     testlib.pass(FRAME)
 914 end
 915
 916 ----------------------------------------
 917 -- we want to have our protocol dissection invoked for a specific UDP port,
 918 -- so get the udp dissector table and add our protocol to it
 919 DissectorTable.get("udp.port"):add(65333, test_proto)
 920 DissectorTable.get("udp.port"):add(65346, test_proto)
 921
 922 print("test_proto dissector registered")