3160576339

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/iovisor/ubpf/commit/<a class=hub.com/iovisor/ubpf/commit/<a class="double-link" href="https://git"><a class=hub.com/iovisor/ubpf/commit/<a class="double-link" href="https://git"><a class=hub.com/iovisor/ubpf/commit/<a class="double-link" href="https://git"><a class=hub.com/iovisor/ubpf/commit/7842e0cc2922b713e1346493f93719f0ca9f98c4">7842e0cc2">&lt;a href=&quot;https://github.com/iovisor/ubpf/commit/</a><a class="double-link" href="https://github.com/iovisor/ubpf/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/iovisor/ubpf/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/iovisor/ubpf/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/iovisor/ubpf/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/iovisor/ubpf/commit/7842e0cc2922b713e1346493f93719f0ca9f98c4">7842e0cc2</a><a href="https://github.com/iovisor/ubpf/commit/7842e0cc2922b713e1346493f93719f0ca9f98c4">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/iovisor/ubpf/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/iovisor/ubpf/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/iovisor/ubpf/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/iovisor/ubpf/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/iovisor/ubpf/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/iovisor/ubpf/commit/7842e0cc2922b713e1346493f93719f0ca9f98c4&quot;&gt;7842e0cc2&lt;/a&gt;&lt;a href=&quot;https://github.com/iovisor/ubpf/commit/7842e0cc2922b713e1346493f93719f0ca9f98c4&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/iovisor/ubpf/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/iovisor/ubpf/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot... (continued)

Pull Request Pull Request #119: uBPF unit tests that run natively with out Python.

Run Details

263 of 303 new or added lines in 3 files covered. (86.8%)

2911 of 3536 relevant lines covered (82.32%)

149273.27 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.96

/unit_tests/code_gen_tests.cc

// Copyright (c) 2022-present, IO Visor Project
// SPDX-License-Identifier: Apache-2.0

#include <filesystem>
#include <fstream>

#include <gtest/gtest.h>

#include "bpf_assembler.h"
#include "test_helpers.h"
extern "C"
{
#include "ubpf.h"
}

std::tuple<std::vector<uint8_t>, uint64_t, std::string, std::vector<ebpf_inst>>
parse_test_file(const std::filesystem::path &data_file)
{
    enum class _state
    {
        state_ignore,
        state_assembly,
        state_raw,
        state_result,
        state_memory,
        state_error,
    } state = _state::state_ignore;

    std::stringstream data_out;
    std::ifstream data_in(data_file);

    std::string result_string;
    std::string mem;
    std::string line;
    std::string expected_error;
    while (std::getline(data_in, line))
    {
        if (line.find("--") != std::string::npos)
        {
            if (line.find("asm") != std::string::npos)
            {
                state = _state::state_assembly;
                continue;
            }
            else if (line.find("result") != std::string::npos)
            {
                state = _state::state_result;
                continue;
            }
            else if (line.find("mem") != std::string::npos)
            {
                state = _state::state_memory;
                continue;
            }
            else if (line.find("raw") != std::string::npos)
            {
                state = _state::state_ignore;
                continue;
            }
            else if (line.find("result") != std::string::npos)
            {
                state = _state::state_result;
                continue;
            }
            else if (line.find("no register offset") != std::string::npos)
            {
                state = _state::state_ignore;
                continue;
            }
            else if (line.find(" c") != std::string::npos)
            {
                state = _state::state_ignore;
                continue;
            }
            else if (line.find("error") != std::string::npos)
            {
                state = _state::state_error;
                continue;
            }
            else if (line.find("no jit") != std::string::npos) {
                // Skip tests that don't support JIT.
                return {};
            }
            else
            {
                std::cout << "Unknown directive " << line << std::endl;
                state = _state::state_ignore;
                continue;
            }
        }
        if (line.empty())
        {
            continue;
        }

        switch (state)
        {
        case _state::state_assembly:
            if (line.find("#") != std::string::npos)
            {
                line = line.substr(0, line.find("#"));
            }
            data_out << line << std::endl;
            break;
        case _state::state_result:
            result_string = line;
            break;
        case _state::state_memory:
            mem += std::string(" ") + line;
            break;
        case _state::state_error:
            expected_error = line;
            break;
        default:
            continue;
        }
    }

    uint64_t result_value;
    if (result_string.empty())
    {
        result_value = 0;
        return {};
    } else if (result_string.find("0x") != std::string::npos)
    {
        result_value = std::stoull(result_string, nullptr, 16);
    }
    else
    {
        result_value = std::stoull(result_string);
    }

    data_out.seekg(0);
    auto instructions = bpf_assembler(data_out);

    std::vector<uint8_t> input_buffer;

    if (!mem.empty())
    {
        std::stringstream ss(mem);
        uint32_t value;
        while (ss >> std::hex >> value)
        {
            input_buffer.push_back(static_cast<uint8_t>(value));
        }
    }

    return {input_buffer, result_value, expected_error, instructions};
}

ubpf_vm *
prepare_ubpf_vm(const std::vector<ebpf_inst> instructions, const std::string& expected_error)
{
    ubpf_vm *vm = ubpf_create();
    if (vm == nullptr)
        throw std::runtime_error("Failed to create VM");

    char *error = nullptr;
    for (auto &[key, value] : helper_functions)
    {
        if (ubpf_register(vm, key, "unnamed", reinterpret_cast<void*>(value)) != 0)
            throw std::runtime_error("Failed to register helper function");
    }

    if (ubpf_set_unwind_function_index(vm, 5) != 0)
        throw std::runtime_error("Failed to set unwind function index");

    auto result = ubpf_load(vm, instructions.data(), static_cast<uint32_t>(instructions.size() * sizeof(ebpf_inst)), &error);
    if (expected_error.empty())
    {
        if (result != 0)
            throw std::runtime_error("Failed to load program: " + std::string(error));
    }
    else
    {
        if (result == 0)
            throw std::runtime_error("Expected error but program loaded successfully");
        if (expected_error.find(error) == std::string::npos)
            throw std::runtime_error("Expected error '" + expected_error + "' but got '" + error + "'");
        ubpf_destroy(vm);
        vm = nullptr;
    }

    return vm;
}

void run_ubpf_jit_test(const std::filesystem::path &data_file)
{
    auto [mem, expected_result, expected_error, instructions] = parse_test_file(data_file);
    if (instructions.empty())
    {
        GTEST_SKIP();
        return;
    }

    char *error = nullptr;
    ubpf_vm *vm = prepare_ubpf_vm(instructions, expected_error);
    if (vm == nullptr)
        return;

    ubpf_jit_fn jit = ubpf_compile(vm, &error);
    if (jit == nullptr)
        throw std::runtime_error("Failed to compile program: " + std::string(error));

    uint64_t actual_result = jit(mem.data(), mem.size());

    if (actual_result != expected_result) {
        std::cout << "Expected: " << expected_result << " Actual: " << actual_result << std::endl;
        throw std::runtime_error("Result mismatch");
    }

    ubpf_destroy(vm);
}

void run_ubpf_interpret_test(const std::filesystem::path &data_file)
{
    auto [mem, expected_result, expected_error, instructions] = parse_test_file(data_file);
    if (instructions.empty())
    {
        GTEST_SKIP();
        return;
    }

    ubpf_vm *vm = prepare_ubpf_vm(instructions, expected_error);
    if (vm == nullptr)
        return;

    uint64_t actual_result = 0;
    if (ubpf_exec(vm, mem.data(), mem.size(), &actual_result) != 0)
        throw std::runtime_error("Failed to execute program");

    if (actual_result != expected_result) {
        std::cout << "Expected: " << expected_result << " Actual: " << actual_result << std::endl;
        throw std::runtime_error("Result mismatch");
    }

    ubpf_destroy(vm);
}

class ubpf_test : public ::testing::TestWithParam<std::filesystem::path>
{
};

TEST_P(ubpf_test, jit)
{
    run_ubpf_jit_test(GetParam());
}

TEST_P(ubpf_test, interpret)
{
    run_ubpf_interpret_test(GetParam());
}

std::vector<std::filesystem::path> get_test_files()
{
    std::vector<std::filesystem::path> result;
    for (auto &p : std::filesystem::directory_iterator("tests/"))
    {
        if (p.path().extension() == ".data")
        {
            result.push_back(p.path());
        }
    }
    return result;
}

INSTANTIATE_TEST_SUITE_P(ubpf_tests, ubpf_test, ::testing::ValuesIn(get_test_files()));

1	// Copyright (c) 2022-present, IO Visor Project
2	// SPDX-License-Identifier: Apache-2.0
3
4	#include <filesystem>
5	#include <fstream>
6
7	#include <gtest/gtest.h>
8
9	#include "bpf_assembler.h"
10	#include "test_helpers.h"
11	extern "C"
12	{
13	#include "ubpf.h"
14	}
15
16	std::tuple<std::vector<uint8_t>, uint64_t, std::string, std::vector<ebpf_inst>>
17	parse_test_file(const std::filesystem::path &data_file)	8,616✔
18	{
19	enum class _state	500✔
20	{
21	state_ignore,
22	state_assembly,
23	state_raw,
24	state_result,
25	state_memory,
26	state_error,
27	} state = _state::state_ignore;	500✔
28
29	std::stringstream data_out;	9,116✔
30	std::ifstream data_in(data_file);	8,616✔
31
32	std::string result_string;	9,116✔
33	std::string mem;	8,616✔
34	std::string line;	8,616✔
35	std::string expected_error;	9,116✔
36	while (std::getline(data_in, line))	546,704✔
37	{
38	if (line.find("--") != std::string::npos)	538,096✔
39	{
40	if (line.find("asm") != std::string::npos)	2,384✔
41	{
42	state = _state::state_assembly;	480✔
43	continue;	960✔
44	}
45	else if (line.find("result") != std::string::npos)	1,424✔
46	{
47	state = _state::state_result;	424✔
48	continue;	848✔
49	}
50	else if (line.find("mem") != std::string::npos)	576✔
51	{
52	state = _state::state_memory;	124✔
53	continue;	248✔
54	}
55	else if (line.find("raw") != std::string::npos)	328✔
56	{
57	state = _state::state_ignore;	48✔
58	continue;	96✔
59	}
60	else if (line.find("result") != std::string::npos)	232✔
61	{
62	state = _state::state_result;
63	continue;
64	}
65	else if (line.find("no register offset") != std::string::npos)	232✔
66	{
67	state = _state::state_ignore;	32✔
68	continue;	64✔
69	}
70	else if (line.find(" c") != std::string::npos)	168✔
71	{
72	state = _state::state_ignore;	16✔
73	continue;	32✔
74	}
75	else if (line.find("error") != std::string::npos)	136✔
76	{
77	state = _state::state_error;	558✔
78	continue;	112✔
79	}
80	else if (line.find("no jit") != std::string::npos) {	24✔
81	// Skip tests that don't support JIT.
82	return {};	8✔
83	}
84	else
85	{
86	std::cout << "Unknown directive " << line << std::endl;	16✔
87	state = _state::state_ignore;	8✔
88	continue;	16✔
89	}
90	}
91	if (line.empty())	535,712✔
92	{
93	continue;	548✔
94	}
95
96	switch (state)	534,616✔
97	{
98	case _state::state_assembly:	3,752✔
99	if (line.find("#") != std::string::npos)	7,504✔
100	{
101	line = line.substr(0, line.find("#"));	904✔
102	}	392✔
103	data_out << line << std::endl;	7,504✔
104	break;
105	case _state::state_result:	424✔
106	result_string = line;	848✔
107	break;
108	case _state::state_memory:	236✔
109	mem += std::string(" ") + line;	816✔
110	break;	472✔
111	case _state::state_error:	56✔
112	expected_error = line;	269,656✔
113	break;
114	default:	262,840✔
115	continue;	262,840✔
116	}
117	}
118
119	uint64_t result_value;	992✔
120	if (result_string.empty())	992✔
121	{
122	result_value = 0;	152✔
123	return {};	152✔
124	} else if (result_string.find("0x") != std::string::npos)	840✔
125	{
126	result_value = std::stoull(result_string, nullptr, 16);	840✔
127	}	420✔
128	else
129	{
NEW 130	result_value = std::stoull(result_string);	×
131	}
132
133	data_out.seekg(0);	840✔
134	auto instructions = bpf_assembler(data_out);	1,340✔
135
136	std::vector<uint8_t> input_buffer;	1,260✔
137
138	if (!mem.empty())	840✔
139	{
140	std::stringstream ss(mem);	372✔
141	uint32_t value;	1,604✔
142	while (ss >> std::hex >> value)	2,960✔
143	{
144	input_buffer.push_back(static_cast<uint8_t>(value));	2,712✔
145	}
146	}	124✔
147
148	return {input_buffer, result_value, expected_error, instructions};	840✔
149	}	15,732✔
150
151	ubpf_vm *
152	prepare_ubpf_vm(const std::vector<ebpf_inst> instructions, const std::string& expected_error)	840✔
153	{
154	ubpf_vm *vm = ubpf_create();	840✔
155	if (vm == nullptr)	840✔
NEW 156	throw std::runtime_error("Failed to create VM");	×
157
158	char *error = nullptr;	840✔
159	for (auto &[key, value] : helper_functions)	5,880✔
160	{
161	if (ubpf_register(vm, key, "unnamed", reinterpret_cast<void*>(value)) != 0)	5,040✔
NEW 162	throw std::runtime_error("Failed to register helper function");	×
163	}
164
165	if (ubpf_set_unwind_function_index(vm, 5) != 0)	840✔
NEW 166	throw std::runtime_error("Failed to set unwind function index");	×
167
168	auto result = ubpf_load(vm, instructions.data(), static_cast<uint32_t>(instructions.size() * sizeof(ebpf_inst)), &error);	840✔
169	if (expected_error.empty())	840✔
170	{
171	if (result != 0)	840✔
NEW 172	throw std::runtime_error("Failed to load program: " + std::string(error));	×
173	}
174	else
175	{
NEW 176	if (result == 0)	×
NEW 177	throw std::runtime_error("Expected error but program loaded successfully");	×
NEW 178	if (expected_error.find(error) == std::string::npos)	×
NEW 179	throw std::runtime_error("Expected error '" + expected_error + "' but got '" + error + "'");	×
NEW 180	ubpf_destroy(vm);	×
181	vm = nullptr;
182	}
183
184	return vm;	840✔
185	}	420✔
186
187	void run_ubpf_jit_test(const std::filesystem::path &data_file)	500✔
188	{
189	auto [mem, expected_result, expected_error, instructions] = parse_test_file(data_file);	710✔
190	if (instructions.empty())	500✔
191	{
192	GTEST_SKIP();	160✔
193	return;
194	}
195
196	char *error = nullptr;	420✔
197	ubpf_vm *vm = prepare_ubpf_vm(instructions, expected_error);	420✔
198	if (vm == nullptr)	420✔
199	return;
200
201	ubpf_jit_fn jit = ubpf_compile(vm, &error);	420✔
202	if (jit == nullptr)	420✔
NEW 203	throw std::runtime_error("Failed to compile program: " + std::string(error));	×
204
205	uint64_t actual_result = jit(mem.data(), mem.size());	420✔
206
207	if (actual_result != expected_result) {	420✔
NEW 208	std::cout << "Expected: " << expected_result << " Actual: " << actual_result << std::endl;	×
NEW 209	throw std::runtime_error("Result mismatch");	×
210	}
211
212	ubpf_destroy(vm);	420✔
213	}	250✔
214
215	void run_ubpf_interpret_test(const std::filesystem::path &data_file)	500✔
216	{
217	auto [mem, expected_result, expected_error, instructions] = parse_test_file(data_file);	710✔
218	if (instructions.empty())	500✔
219	{
220	GTEST_SKIP();	160✔
221	return;
222	}
223
224	ubpf_vm *vm = prepare_ubpf_vm(instructions, expected_error);	420✔
225	if (vm == nullptr)	420✔
226	return;
227
228	uint64_t actual_result = 0;	420✔
229	if (ubpf_exec(vm, mem.data(), mem.size(), &actual_result) != 0)	420✔
NEW 230	throw std::runtime_error("Failed to execute program");	×
231
232	if (actual_result != expected_result) {	420✔
NEW 233	std::cout << "Expected: " << expected_result << " Actual: " << actual_result << std::endl;	×
NEW 234	throw std::runtime_error("Result mismatch");	×
235	}
236
237	ubpf_destroy(vm);	420✔
238	}	460✔
239
240	class ubpf_test : public ::testing::TestWithParam<std::filesystem::path>	1,000✔
241	{
242	};
243
244	TEST_P(ubpf_test, jit)	2,004✔
245	{
246	run_ubpf_jit_test(GetParam());	500✔
247	}	500✔
248
249	TEST_P(ubpf_test, interpret)	2,004✔
250	{
251	run_ubpf_interpret_test(GetParam());	500✔
252	}	500✔
253
254	std::vector<std::filesystem::path> get_test_files()	2,008✔
255	{
256	std::vector<std::filesystem::path> result;	2,008✔
257	for (auto &p : std::filesystem::directory_iterator("tests/"))	392,564✔
258	{
259	if (p.path().extension() == ".data")	388,548✔
260	{
261	result.push_back(p.path());	251,000✔
262	}
263	}
264	return result;	1,004✔
265	}	1,004✔
266
267	INSTANTIATE_TEST_SUITE_P(ubpf_tests, ubpf_test, ::testing::ValuesIn(get_test_files()));	128,010✔

iovisor / ubpf / 3160576339

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous