local loaded_const_code = assert(loadfile("../../src/b2ws-plugin/b2ws_const.lua"))
loaded_const_code()
b2ws_const.B2WS_PLUGIN_PATH="../../src/b2ws-plugin/"
local loaded_test_code = assert(loadfile("../../src/b2ws-plugin/b2ws_snippet.lua"))
loaded_test_code()

-- Unit testing starts
local lu = require('luaunit')

TestSnippet = {} --class
    function TestSnippet:testCreateObjects()
        local fieldObject = b2ws_create_field_object("foo ", " bar", "")
        lu.assertEquals(fieldObject.name, 'foo')
        lu.assertEquals(fieldObject.type, 'bar')
        lu.assertEquals(fieldObject.bit_size, nil)
        lu.assertEquals(fieldObject.bit_mask, nil)
        lu.assertEquals(fieldObject.array_number, nil)

        local structObject = b2ws_create_struct_object("bla  ")
        structObject.fields[1] = fieldObject
        lu.assertEquals(structObject.name, 'bla')
        lu.assertEquals(structObject.size, -1)
        lu.assertEquals(structObject.fields[1].name, 'foo')
        lu.assertEquals(structObject.fields[1].type, 'bar')

        fieldObject = b2ws_create_field_object("foo2", "uint8_t", "")
        lu.assertEquals(fieldObject.name, 'foo2')
        lu.assertEquals(fieldObject.type, 'uint8')
        lu.assertEquals(fieldObject.bit_size, 8)
        lu.assertEquals(fieldObject.bit_mask, nil)
        lu.assertEquals(fieldObject.array_number, nil)

        fieldObject = b2ws_create_field_object("foo3", "uint16", "[ ]")
        lu.assertEquals(fieldObject.name, 'foo3')
        lu.assertEquals(fieldObject.type, 'uint16')
        lu.assertEquals(fieldObject.bit_size, 0)
        lu.assertEquals(fieldObject.bit_mask, nil)
        lu.assertEquals(fieldObject.array_number, "")

        fieldObject = b2ws_create_field_object("foo3-1", "uint16", "[]")
        lu.assertEquals(fieldObject.name, 'foo3-1')
        lu.assertEquals(fieldObject.type, 'uint16')
        lu.assertEquals(fieldObject.bit_size, 0)
        lu.assertEquals(fieldObject.bit_mask, nil)
        lu.assertEquals(fieldObject.array_number, "")

        fieldObject = b2ws_create_field_object("foo4", "int16", "[3]")
        lu.assertEquals(fieldObject.name, 'foo4')
        lu.assertEquals(fieldObject.type, 'int16')
        lu.assertEquals(fieldObject.bit_size, 48)
        lu.assertEquals(fieldObject.bit_mask, nil)
        lu.assertEquals(fieldObject.array_number, "3")

        fieldObject = b2ws_create_field_object("foo5", "int16", "[foo]")
        lu.assertEquals(fieldObject.name, 'foo5')
        lu.assertEquals(fieldObject.type, 'int16')
        lu.assertEquals(fieldObject.bit_size, 16)
        lu.assertEquals(fieldObject.bit_mask, nil)
        lu.assertEquals(fieldObject.array_number, "foo")

        fieldObject = b2ws_create_field_object("foo6", "uint32", ":0-15")
        lu.assertEquals(fieldObject.name, 'foo6')
        lu.assertEquals(fieldObject.type, 'uint32')
        lu.assertEquals(fieldObject.bit_size, 16)
        lu.assertEquals(fieldObject.bit_mask, 0x0000ffff)
        lu.assertEquals(fieldObject.array_number, nil)

        fieldObject = b2ws_create_field_object("foo6-1", "uint32", ":8-23")
        lu.assertEquals(fieldObject.name, 'foo6-1')
        lu.assertEquals(fieldObject.type, 'uint32')
        lu.assertEquals(fieldObject.bit_size, 16)
        lu.assertEquals(fieldObject.bit_mask, 0x00ffff00)
        lu.assertEquals(fieldObject.array_number, nil)

        fieldObject = b2ws_create_field_object("foo6-2", "uint32", ":24-31")
        lu.assertEquals(fieldObject.name, 'foo6-2')
        lu.assertEquals(fieldObject.type, 'uint32')
        lu.assertEquals(fieldObject.bit_size, 8)
        lu.assertEquals(fieldObject.bit_mask, 0xff000000)
        lu.assertEquals(fieldObject.array_number, nil)

    end

    function TestSnippet:testParseStruct()
        local structObject = b2ws_parse_struct([["  struct foo
         { uint8 bla_count; uint16_t bla[bla_count];
         uint32_t foo:0-15; int64_t bar[]; int8_t bla[3];
          int16_t bla; int32_t bla; int64_t bla;
        }  "]])
        lu.assertEquals(structObject.name, 'foo')
        lu.assertEquals(structObject.size, 22)
        lu.assertEquals(structObject.fields[1].name, 'bla_count')
        lu.assertEquals(structObject.fields[1].type, 'uint8')
        lu.assertEquals(structObject.fields[2].name, 'bla')
        lu.assertEquals(structObject.fields[2].type, 'uint16')
        lu.assertEquals(structObject.fields[3].name, 'foo')
        lu.assertEquals(structObject.fields[3].type, 'uint32')
        lu.assertEquals(structObject.fields[4].name, 'bar')
        lu.assertEquals(structObject.fields[4].type, 'int64')
        lu.assertEquals(structObject.fields[#structObject.fields].name, 'bla')
        lu.assertEquals(structObject.fields[#structObject.fields].type, 'int64')
    end

    function TestSnippet:testCreateSnippets()
        local structObject = b2ws_parse_struct([["  struct foo
         { uint8 bla_count; uint16_t bla[bla_count];
         uint32_t foo:0-15; int64_t bar[]; int8_t bla[3];
          int16_t bla; int32_t bla; int64_t bar[];
        }  "]])
        local result_template = b2ws_create_dissector_snippet(structObject)
        local expected_result = [===[-- bar Layer
bar_layer = Proto("bar_layer", "bar layer")

function bar_layer.dissector(buffer, packet_info, tree)
	bar_layer_tree = tree:add(bar_layer, buffer(0, buffer:len()))
end

-- foo Layer
foo_layer = Proto("foo_layer", "foo layer")

local foo_layer_fields = foo_layer.fields
foo_layer_fields.bla_count = ProtoField.uint8("foo_layer_fields.bla_count", "bla_count", base.HEX, nil--[[valuestring]], nil, "bla_count description")
foo_layer_fields.bla = ProtoField.bytes("foo_layer_fields.bla", "bla", base.HEX, nil--[[valuestring]], nil, "bla description")
foo_layer_fields.foo = ProtoField.uint32("foo_layer_fields.foo", "foo", base.HEX, nil--[[valuestring]], 0x0000ffff, "foo description")
foo_layer_fields.bar = ProtoField.bytes("foo_layer_fields.bar", "bar", base.HEX, nil--[[valuestring]], nil, "bar description")
foo_layer_fields.bla = ProtoField.bytes("foo_layer_fields.bla", "bla", base.HEX, nil--[[valuestring]], nil, "bla description")
foo_layer_fields.bla = ProtoField.int16("foo_layer_fields.bla", "bla", base.DEC, nil--[[valuestring]], nil, "bla description")
foo_layer_fields.bla = ProtoField.int32("foo_layer_fields.bla", "bla", base.DEC, nil--[[valuestring]], nil, "bla description")

function foo_layer.dissector(buffer, packet_info, tree)
	foo_layer_tree = tree:add(foo_layer, buffer(0, buffer:len()))

	local bla_count_value = buffer(0, 1):le_uint()
	foo_layer_tree:add(foo_layer_fields.bla_count, buffer(0, 1), bla_count_value)

	local current_offset = 1
	foo_layer_tree:add(foo_layer_fields.bla, buffer(current_offset, 2 * bla_count_value))

	current_offset = current_offset + 2 * bla_count_value
	local foo_value = buffer(current_offset, 4):le_uint()
	foo_layer_tree:add(foo_layer_fields.foo, buffer(current_offset, 4), foo_value)

	foo_layer_tree:add(foo_layer_fields.bar, buffer(current_offset, buffer:len() - current_offset))

	current_offset = current_offset + buffer:len() - current_offset
	foo_layer_tree:add(foo_layer_fields.bla, buffer(current_offset, 3))

	current_offset = current_offset + 3
	local bla_value = buffer(current_offset, 2):le_uint()
	foo_layer_tree:add(foo_layer_fields.bla, buffer(current_offset, 2), bla_value)

	current_offset = current_offset + 2
	local bla_value = buffer(current_offset, 4):le_uint()
	foo_layer_tree:add(foo_layer_fields.bla, buffer(current_offset, 4), bla_value)

	current_offset = current_offset + 4
	Dissector.get("bar_layer"):call(buffer(14.0, buffer:len() - 14.0):tvb(), packet_info, foo_layer_tree)
end
]===]
        lu.assertEquals(result_template:gsub("%s", ""), expected_result:gsub("%s", ""))
        --print(result_template)
    end

    function TestSnippet:testCreateLayerSnippets()
        local structObject = b2ws_parse_struct([["  struct foo
         { uint8 bla_count; uint16_t bla[bla_count];
         uint32_t foo:0-15; int64_t bar[]; int8_t bla[3];
          int16_t bla; int32_t bla; int64_t bla;
        }  "]])
        result_template = b2ws_create_dissector_layer_snippet(structObject, "{struct_size}bla \n\t{struct_name}_bar{struct_size}\n{struct_name}:{struct_name}{struct_size}")
        lu.assertEquals(result_template, "22.0bla \n\tfoo_bar22.0\nfoo:foo22.0")
    end

    function TestSnippet:testCreateFunctionDeclaration()
        local test_field_declaration_template = [===[{struct_name}_layer_fields.{field_name} = ProtoField.{field_type}("{struct_name}_layer_fields.{field_name}", "{field_name}", {base_type}, nil--[[valuestring]], {bit_mask}, {field_name} description})]===]

        local structObject = b2ws_create_struct_object("bla  ")
        structObject.fields[1] = fieldObject
        lu.assertEquals(structObject.name, 'bla')

        local fieldObject = b2ws_create_field_object("foo2", "uint8_t", "")
        local result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "bla_layer_fields.foo2 = ProtoField.uint8(\"bla_layer_fields.foo2\", \"foo2\", base.HEX, nil--[[valuestring]], nil, foo2 description})")

        fieldObject = b2ws_create_field_object("foo3", "uint16", "[ ]")
        result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "bla_layer_fields.foo3 = ProtoField.bytes(\"bla_layer_fields.foo3\", \"foo3\", base.HEX, nil--[[valuestring]], nil, foo3 description})")

        fieldObject = b2ws_create_field_object("foo3-1", "uint16", "[]")
        result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "bla_layer_fields.foo3-1 = ProtoField.bytes(\"bla_layer_fields.foo3-1\", \"foo3-1\", base.HEX, nil--[[valuestring]], nil, foo3-1 description})")

        fieldObject = b2ws_create_field_object("foo4", "int16", "")
        result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "bla_layer_fields.foo4 = ProtoField.int16(\"bla_layer_fields.foo4\", \"foo4\", base.DEC, nil--[[valuestring]], nil, foo4 description})")

        fieldObject = b2ws_create_field_object("foo5", "int16", "[foo]")
        result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "bla_layer_fields.foo5 = ProtoField.bytes(\"bla_layer_fields.foo5\", \"foo5\", base.HEX, nil--[[valuestring]], nil, foo5 description})")

        fieldObject = b2ws_create_field_object("foo6", "uint32", ":0-15")
        result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "bla_layer_fields.foo6 = ProtoField.uint32(\"bla_layer_fields.foo6\", \"foo6\", base.HEX, nil--[[valuestring]], 0x0000ffff, foo6 description})")

        fieldObject = b2ws_create_field_object("foo6-1", "int32", ":8-23")
        result_string = b2ws_create_dissector_fields_declaration_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "bla_layer_fields.foo6-1 = ProtoField.int32(\"bla_layer_fields.foo6-1\", \"foo6-1\", base.DEC, nil--[[valuestring]], 0x00ffff00, foo6-1 description})")
    end

    function TestSnippet:testCreateFunctionDefinition()
        local test_field_declaration_template = [[local {field_name}_value = buffer(0,{field_end}):{to_method}()
{struct_name}_layer_tree:add({struct_name}_layer_fields.{field_name}, buffer(0, {field_end}), {field_name}_value)]]

        local structObject = b2ws_create_struct_object("bla  ")
        structObject.fields[1] = fieldObject
        lu.assertEquals(structObject.name, 'bla')

        local fieldObject = b2ws_create_field_object("foo2", "uint8_t", "")
        local result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "local foo2_value = buffer(0,1):le_uint()\nbla_layer_tree:add(bla_layer_fields.foo2, buffer(0, 1), foo2_value)")

        fieldObject = b2ws_create_field_object("foo3", "uint16", "[ ]")
        result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
        "bla_layer_tree:add(bla_layer_fields.foo3, buffer(0, buffer:len() - current_offset))")

        fieldObject = b2ws_create_field_object("foo33", "uint16", "[3]")
        result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
        "bla_layer_tree:add(bla_layer_fields.foo33, buffer(0, 6))")

        fieldObject = b2ws_create_field_object("foo4", "int16", "")
        local result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "local foo4_value = buffer(0,2):le_uint()\nbla_layer_tree:add(bla_layer_fields.foo4, buffer(0, 2), foo4_value)")

        fieldObject = b2ws_create_field_object("foo5", "int16", "[foo]")
        result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
        "bla_layer_tree:add(bla_layer_fields.foo5, buffer(0, 2 * foo_value))")

        fieldObject = b2ws_create_field_object("foo6", "uint32", ":0-15")
        result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "local foo6_value = buffer(0,4):le_uint()\nbla_layer_tree:add(bla_layer_fields.foo6, buffer(0, 4), foo6_value)")

        fieldObject = b2ws_create_field_object("foo6-1", "int32", ":8-23")
        result_string = b2ws_create_dissector_fields_definition_snippet(structObject, fieldObject, test_field_declaration_template)
        lu.assertEquals(result_string,
            "local foo6-1_value = buffer(0,4):le_uint()\nbla_layer_tree:add(bla_layer_fields.foo6-1, buffer(0, 4), foo6-1_value)")
    end

-- class TestSnippet

local runner = lu.LuaUnit.new()
runner:setOutputType("tap")
os.exit( runner:runSuite() )