further implementation for create dissector template

src/b2ws-plugin/b2ws_snippet.lua

@@ -33,7 +33,7 @@ function b2ws_create_field_object(name, type, type_suffix)
 			end
 		end
 	end
-	return {["name"] = b2ws_trim(name), ["type"] = ws_type_name, ["bit_size"] = bit_size, ["bit_mask"] = bit_mask, ["offset"] = 0, ["array_number"] = array_number}
+	return {["name"] = b2ws_trim(name), ["type"] = ws_type_name, ["bit_size"] = bit_size, ["bit_mask"] = bit_mask, ["array_number"] = array_number}
 end
 
 function b2ws_create_struct_object(name)
@@ -43,6 +43,7 @@ end
 function b2ws_parse_struct(struct_string)
 	local struct_name, field_list = string.match(b2ws_trim(struct_string), "struct%s+(%g+)%s*{(.*)}")
 	struct_object = b2ws_create_struct_object(struct_name)
+	local tmp_bit_size = 0
 	for key_index, field_string in next, b2ws_string_split(field_list, ";")
 	do
 		local trim_filed_string = b2ws_trim(field_string)
@@ -51,29 +52,164 @@ function b2ws_parse_struct(struct_string)
 			if type_suffix == nil then
 				type_suffix = ""
 			end
-			struct_object.fields[key_index] = b2ws_create_field_object(field_name, type_name, type_suffix)
+
+			local tmp_field_object = b2ws_create_field_object(field_name, type_name, type_suffix)
+			struct_object.fields[key_index] = tmp_field_object
+			tmp_bit_size = tmp_bit_size + tmp_field_object.bit_size
 		end
 	end
+
+	if tmp_bit_size % 8 ~= 0 then
+		tmp_bit_size = tmp_bit_size + 8
+	end
+
+	struct_object.size = tmp_bit_size / 8
 	return struct_object
 end
 
+next_proto_template = [[-- {field_name} Layer
+{field_name}_layer = Proto("{field_name}_layer", "{field_name} layer")
+
+function {field_name}_layer.dissector(buffer, packet_info, tree)
+	{field_name}_layer_tree = tree:add({field_name}_layer, buffer(0, buffer:len()))
+end
+]]
+
+next_proto_dissector_call = [[Dissector.get("{field_name}_layer"):call(buffer({struct_size}, buffer:len() - {struct_size}):tvb(), packet_info, tree)]]
+
 proto_template = [[-- {struct_name} Layer
 {struct_name}_layer = Proto("{struct_name}_layer", "{struct_name} layer")
+
 local {struct_name}_layer_fields = {struct_name}_layer.fields
 {field_declarations}
 function {struct_name}_layer.dissector(buffer, packet_info, tree)
 	{struct_name}_layer_tree = tree:add({struct_name}_layer, buffer(0, {struct_size}))
-	{field_definitions}
+{field_definitions}
 end]]
 
-field_declaration_template = [===[{struct_name}_layer_fields.{field_name} = ProtoField.{fiel_type}("{struct_name}_layer_fields.{field_name}", "{field_name}", {base_type}, nil--[[valuestring]], {bit_mask}, {field_name} description})]===]
+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})]===]
 field_definition_template = [[
-local {field_name}_value = buffer({field_start},{field_end}):{to_method}()
+local {field_name}_value = buffer(current_offset, {field_end}):{to_method}()
-{struct_name}_layer_tree:add({struct_name}_layer_fields.{field_name}, buffer({field_start}, {field_end}), {field_name}_value)]]
+{struct_name}_layer_tree:add({struct_name}_layer_fields.{field_name}, buffer(current_offset, {field_end}), {field_name}_value)
 
+current_offset = current_offset + {field_end}]]
+
+first_field_definition_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 current_offset = {field_end}]]
+
+last_field_definition_template = [[
+local {field_name}_value = buffer(current_offset, {field_end}):{to_method}()
+{struct_name}_layer_tree:add({struct_name}_layer_fields.{field_name}, buffer(current_offset, {field_end}), {field_name}_value)]]
+
+pad_lef_template = "0x%0{pad_count}x"
+
+function b2ws_create_dissector_next_layer_snippet(field_object, template_string)
+	return template_string:gsub("{field_name}", field_object.name)
+end
+
+function b2ws_create_dissector_call_snippet(struct_object, field_object, template_string)
+	local result_template = template_string:gsub("{field_name}", field_object.name)
+	return result_template:gsub("{struct_size}", struct_object.size)
+end
+
+function b2ws_create_dissector_fields_definition_snippet(struct_object, field_object, template_string)
+	local result_template = template_string:gsub("{struct_name}", struct_object.name)
+	result_template = result_template:gsub("{field_name}", field_object.name)
+	local bit_size = field_object.bit_size
+	local array_number = field_object.array_number
+	if bit_size == 0 then
+		result_template = result_template:gsub("{field_end}", "buffer:len() - current_offset")
+	else
+		if bit_size % 8 ~= 0 then
+			bit_size = bit_size + 8
+		end
+		local byte_size = bit_size / 8
+		if array_number == nil or tonumber(array_number) ~= nil then
+			if field_object.bit_mask ~= nil then
+				byte_size = tonumber(string.match(field_object.type, "(%d+)")) / 8
+			end
+
+			result_template = result_template:gsub("{field_end}", string.match(byte_size, "(%d+)"))
+		else
+			result_template = result_template:gsub("{field_end}", string.match(byte_size, "(%d+)") .. " * " .. array_number .. "_value")
+		end
+	end
+
+	if array_number== nil then
+		result_template = result_template:gsub("{to_method}", "le_uint")
+	else
+		result_template = result_template:gsub("{to_method}", "bytes")
+	end
+
+	return result_template
+end
+
+function b2ws_create_dissector_fields_declaration_snippet(struct_object, field_object, template_string)
+	local result_template = template_string:gsub("{struct_name}", struct_object.name)
+	result_template = result_template:gsub("{field_name}", field_object.name)
+	local field_type = field_object.type
+	if field_object.array_number == nil then
+		result_template = result_template:gsub("{field_type}", field_type)
+	else
+		result_template = result_template:gsub("{field_type}", "bytes")
+	end
+
+	if b2ws_string_starts(field_type, "u") or field_object.array_number ~= nil then
+		result_template = result_template:gsub("{base_type}", "base.HEX")
+	else
+		result_template = result_template:gsub("{base_type}", "base.DEC")
+	end
+
+	local bit_mask = field_object.bit_mask
+	if bit_mask == nil then
+		bit_mask = "nil"
+	else
+		local size_string = string.match(field_type, "(%d+)")
+		local bit_size = string.match(tonumber(size_string) / 4, "(%d+)")
+		bit_mask = string.format( pad_lef_template:gsub("{pad_count}", bit_size), bit_mask)
+	end
+	return result_template:gsub("{bit_mask}", bit_mask)
+end
 
 function b2ws_create_dissector_fields_snippet(struct_object, template_string)
-	return template_string
+	local field_list = struct_object.fields
+	local field_declarations_string = ""
+	local field_definitions_string = "\n"
+	local tmp_bit_size = 0
+	local field_list_len = #field_list
+	local field_object = nil
+	local tmp_field_definition_template = first_field_definition_template
+	if field_list_len > 1 then
+		field_object = field_list[1]
+		field_declarations_string = field_declarations_string .. b2ws_create_dissector_fields_declaration_snippet(struct_object, field_object, field_declaration_template) .. "\n"
+		field_definitions_string = field_definitions_string  .. b2ws_create_dissector_fields_definition_snippet(struct_object, field_object, tmp_field_definition_template) .. "\n"
+		tmp_field_definition_template = field_definition_template
+		if field_list_len > 2 then
+			for key_index = 2, field_list_len - 1
+			do
+				field_object = field_list[key_index]
+				field_declarations_string = field_declarations_string .. b2ws_create_dissector_fields_declaration_snippet(struct_object, field_object, field_declaration_template) .. "\n"
+				field_definitions_string = field_definitions_string  .. b2ws_create_dissector_fields_definition_snippet(struct_object, field_object, tmp_field_definition_template) .. "\n"
+			end
+		end
+	end
+
+	local pre_template = ""
+	field_object = field_list[field_list_len]
+	if field_object.bit_size == 0 then
+		pre_template = b2ws_create_dissector_next_layer_snippet(field_object, next_proto_template) .. "\n"
+		field_definitions_string = field_definitions_string .. b2ws_create_dissector_call_snippet(struct_object, field_object, next_proto_dissector_call)
+	else
+		field_declarations_string = field_declarations_string .. b2ws_create_dissector_fields_declaration_snippet(struct_object, field_object, field_declaration_template)
+		field_definitions_string = field_definitions_string  .. b2ws_create_dissector_fields_definition_snippet(struct_object, field_object, last_field_definition_template)
+	end
+
+	local result_template_string = template_string:gsub("{field_declarations}", field_declarations_string)
+	result_template_string = result_template_string:gsub("{field_definitions}", field_definitions_string:gsub("\n", "\n\t"))
+	return pre_template .. result_template_string
 end
 
 function b2ws_create_dissector_layer_snippet(struct_object, template_string)

tests/src/test_b2ws_snippet.lua

@@ -6,7 +6,6 @@ local loaded_test_code = assert(loadfile("../../src/b2ws-plugin/b2ws_snippet.lua
 loaded_test_code()
 
 -- Unit testing starts
-
 local lu = require('luaunit')
 
 TestSnippet = {} --class
@@ -16,7 +15,6 @@ TestSnippet = {} --class
         lu.assertEquals(fieldObject.type, 'bar')
         lu.assertEquals(fieldObject.bit_size, nil)
         lu.assertEquals(fieldObject.bit_mask, nil)
-        lu.assertEquals(fieldObject.offset, 0)
         lu.assertEquals(fieldObject.array_number, nil)
 
         local structObject = b2ws_create_struct_object("bla  ")
@@ -31,7 +29,6 @@ TestSnippet = {} --class
         lu.assertEquals(fieldObject.type, 'uint8')
         lu.assertEquals(fieldObject.bit_size, 8)
         lu.assertEquals(fieldObject.bit_mask, nil)
-        lu.assertEquals(fieldObject.offset, 0)
         lu.assertEquals(fieldObject.array_number, nil)
 
         fieldObject = b2ws_create_field_object("foo3", "uint16", "[ ]")
@@ -39,7 +36,6 @@ TestSnippet = {} --class
         lu.assertEquals(fieldObject.type, 'uint16')
         lu.assertEquals(fieldObject.bit_size, 0)
         lu.assertEquals(fieldObject.bit_mask, nil)
-        lu.assertEquals(fieldObject.offset, 0)
         lu.assertEquals(fieldObject.array_number, "")
 
         fieldObject = b2ws_create_field_object("foo3-1", "uint16", "[]")
@@ -47,7 +43,6 @@ TestSnippet = {} --class
         lu.assertEquals(fieldObject.type, 'uint16')
         lu.assertEquals(fieldObject.bit_size, 0)
         lu.assertEquals(fieldObject.bit_mask, nil)
-        lu.assertEquals(fieldObject.offset, 0)
         lu.assertEquals(fieldObject.array_number, "")
 
         fieldObject = b2ws_create_field_object("foo4", "int16", "[3]")
@@ -55,7 +50,6 @@ TestSnippet = {} --class
         lu.assertEquals(fieldObject.type, 'int16')
         lu.assertEquals(fieldObject.bit_size, 48)
         lu.assertEquals(fieldObject.bit_mask, nil)
-        lu.assertEquals(fieldObject.offset, 0)
         lu.assertEquals(fieldObject.array_number, "3")
 
         fieldObject = b2ws_create_field_object("foo5", "int16", "[foo]")
@@ -63,7 +57,6 @@ TestSnippet = {} --class
         lu.assertEquals(fieldObject.type, 'int16')
         lu.assertEquals(fieldObject.bit_size, 16)
         lu.assertEquals(fieldObject.bit_mask, nil)
-        lu.assertEquals(fieldObject.offset, 0)
         lu.assertEquals(fieldObject.array_number, "foo")
 
         fieldObject = b2ws_create_field_object("foo6", "uint32", ":0-15")
@@ -71,7 +64,6 @@ TestSnippet = {} --class
         lu.assertEquals(fieldObject.type, 'uint32')
         lu.assertEquals(fieldObject.bit_size, 16)
         lu.assertEquals(fieldObject.bit_mask, 0x0000ffff)
-        lu.assertEquals(fieldObject.offset, 0)
         lu.assertEquals(fieldObject.array_number, nil)
 
         fieldObject = b2ws_create_field_object("foo6-1", "uint32", ":8-23")
@@ -79,7 +71,6 @@ TestSnippet = {} --class
         lu.assertEquals(fieldObject.type, 'uint32')
         lu.assertEquals(fieldObject.bit_size, 16)
         lu.assertEquals(fieldObject.bit_mask, 0x00ffff00)
-        lu.assertEquals(fieldObject.offset, 0)
         lu.assertEquals(fieldObject.array_number, nil)
 
         fieldObject = b2ws_create_field_object("foo6-2", "uint32", ":24-31")
@@ -87,7 +78,6 @@ TestSnippet = {} --class
         lu.assertEquals(fieldObject.type, 'uint32')
         lu.assertEquals(fieldObject.bit_size, 8)
         lu.assertEquals(fieldObject.bit_mask, 0xff000000)
-        lu.assertEquals(fieldObject.offset, 0)
         lu.assertEquals(fieldObject.array_number, nil)
 
     end
@@ -99,7 +89,7 @@ TestSnippet = {} --class
           int16_t bla; int32_t bla; int64_t bla;
         }  "]])
         lu.assertEquals(structObject.name, 'foo')
-        lu.assertEquals(structObject.size, -1)
+        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')
@@ -116,10 +106,64 @@ TestSnippet = {} --class
         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;
+          int16_t bla; int32_t bla; int64_t bar[];
         }  "]])
-        result_template = b2ws_create_dissector_snippet(structObject)
+        local result_template = b2ws_create_dissector_snippet(structObject)
-        --print(result_template)
+        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, 14.0))
+
+	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
+	local bla_value = buffer(current_offset, 2 * bla_count_value):bytes()
+	foo_layer_tree:add(foo_layer_fields.bla, buffer(current_offset, 2 * bla_count_value), bla_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)
+
+	current_offset = current_offset + 4
+	local bar_value = buffer(current_offset, buffer:len() - current_offset):bytes()
+	foo_layer_tree:add(foo_layer_fields.bar, buffer(current_offset, buffer:len() - current_offset), bar_value)
+
+	current_offset = current_offset + buffer:len() - current_offset
+	local bla_value = buffer(current_offset, 3):bytes()
+	foo_layer_tree:add(foo_layer_fields.bla, buffer(current_offset, 3), bla_value)
+
+	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, tree)
+end
+]===]
+        lu.assertEquals(result_template:gsub("%s", ""), expected_result:gsub("%s", ""))
+--        print(result_template)
     end
 
     function TestSnippet:testCreateLayerSnippets()
@@ -129,9 +173,95 @@ TestSnippet = {} --class
           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, "-1bla \n\tfoo_bar-1\nfoo:foo-1")
+        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,
+        "local foo3_value = buffer(0,buffer:len() - current_offset):bytes()\nbla_layer_tree:add(bla_layer_fields.foo3, buffer(0, buffer:len() - current_offset), foo3_value)")
+
+        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,
+        "local foo33_value = buffer(0,6):bytes()\nbla_layer_tree:add(bla_layer_fields.foo33, buffer(0, 6), foo33_value)")
+
+        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,
+        "local foo5_value = buffer(0,2 * foo_value):bytes()\nbla_layer_tree:add(bla_layer_fields.foo5, buffer(0, 2 * foo_value), foo5_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