From 8db67e3e5ad10ab266f7c2a29340c6ccd2ee21b0 Mon Sep 17 00:00:00 2001 From: stubbfel Date: Wed, 21 Jun 2017 01:37:02 +0200 Subject: [PATCH] further implementation for create dissector template --- src/b2ws-plugin/b2ws_snippet.lua | 150 +++++++++++++++++++++++++++-- tests/src/test_b2ws_snippet.lua | 160 ++++++++++++++++++++++++++++--- 2 files changed, 288 insertions(+), 22 deletions(-) diff --git a/src/b2ws-plugin/b2ws_snippet.lua b/src/b2ws-plugin/b2ws_snippet.lua index 5ee575a..e30a91b 100644 --- a/src/b2ws-plugin/b2ws_snippet.lua +++ b/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}() -{struct_name}_layer_tree:add({struct_name}_layer_fields.{field_name}, buffer({field_start}, {field_end}), {field_name}_value)]] +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) +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) diff --git a/tests/src/test_b2ws_snippet.lua b/tests/src/test_b2ws_snippet.lua index 7017522..aa390b1 100644 --- a/tests/src/test_b2ws_snippet.lua +++ b/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) - --print(result_template) + 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, 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