3159990762

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/iovisor/ubpf/commit/<a class=hub.com/iovisor/ubpf/commit/c6e75886306e60154d3933942f1bd1e5586865bd">c6e758863<a href="https://github.com/iovisor/ubpf/commit/c6e75886306e60154d3933942f1bd1e5586865bd">">Merge </a><a class="double-link" href="https://github.com/iovisor/ubpf/commit/<a class="double-link" href="https://github.com/iovisor/ubpf/commit/650011a02affabc50c43f31efec413ebc838b771">650011a02</a>">650011a02</a><a href="https://github.com/iovisor/ubpf/commit/c6e75886306e60154d3933942f1bd1e5586865bd"> into b3ea3a0ab">b3ea3a0ab</a>

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

Run Details

398 of 398 new or added lines in 3 files covered. (100.0%)

2781 of 3537 relevant lines covered (78.63%)

54256.21 hits per line

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

88.43

/code_gen_tests/code_gen_tests.cc

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

#include <filesystem>
#include <fstream>

#include <gtest/gtest.h>

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


std::tuple<std::string, 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 = _state::state_ignore;

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

    std::string result;
    std::string mem;
    std::string line;
    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
            {
                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 = line;
            break;
        case _state::state_memory:
            mem += std::string(" ") + line;
            break;
        default:
            continue;
        }
    }

    if (result.find("0x") != std::string::npos)
    {
        result = result.substr(result.find("0x") + 2);
    }
    data_out.seekg(0);
    auto instructions = bpf_assembler(data_out);
    return {mem, result, instructions};
}

ubpf_vm *
prepare_ubpf_vm(const std::vector<ebpf_inst> instructions)
{
    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");

    if (ubpf_load(vm, instructions.data(), static_cast<uint32_t>(instructions.size() * sizeof(ebpf_inst)), &error) != 0)
        throw std::runtime_error("Failed to load program: " + std::string(error));

    return vm;
}

void run_ubpf_jit_test(const std::filesystem::path &data_file)
{
    if (data_file.filename().string().find("err") != std::string::npos)
    {
        GTEST_SKIP();
        return;
    }
    auto [mem, result, instructions] = parse_test_file(data_file);
    if (result.empty() || instructions.empty())
    {
        GTEST_SKIP();
        return;
    }

    char *error = nullptr;
    ubpf_vm *vm = prepare_ubpf_vm(instructions);
    if (vm == nullptr)
        throw std::runtime_error("Failed to create VM");

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

    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));
        }
    }

    uint64_t expected_result = std::stoull(result, nullptr, 16);

    uint64_t actual_result = jit(input_buffer.data(), input_buffer.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)
{
    if (data_file.filename().string().find("err") != std::string::npos)
    {
        GTEST_SKIP();
        return;
    }
    auto [mem, result, instructions] = parse_test_file(data_file);
    if (result.empty() || instructions.empty())
    {
        GTEST_SKIP();
        return;
    }

    ubpf_vm *vm = prepare_ubpf_vm(instructions);
    if (vm == nullptr)
        throw std::runtime_error("Failed to create VM");

    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));
        }
    }

    uint64_t expected_result = std::stoull(result, nullptr, 16);

    uint64_t actual_result;
    if (ubpf_exec(vm, input_buffer.data(), input_buffer.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: MIT
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
17	std::tuple<std::string, std::string, std::vector<ebpf_inst>>
18	parse_test_file(const std::filesystem::path &data_file)	224✔
19	{
20	enum class _state
21	{
22	state_ignore,
23	state_assembly,
24	state_raw,
25	state_result,
26	state_memory,
27	} state = _state::state_ignore;
28
29	std::stringstream data_out;	224✔
30	std::ifstream data_in(data_file);	224✔
31
32	std::string result;	224✔
33	std::string mem;	224✔
34	std::string line;	224✔
35	while (std::getline(data_in, line))	3,518✔
36	{
37	if (line.find("--") != std::string::npos)	3,294✔
38	{
39	if (line.find("asm") != std::string::npos)	540✔
40	{
41	state = _state::state_assembly;
42	continue;	224✔
43	}
44	else if (line.find("result") != std::string::npos)	316✔
45	{
46	state = _state::state_result;
47	continue;	210✔
48	}
49	else if (line.find("mem") != std::string::npos)	106✔
50	{
51	state = _state::state_memory;
52	continue;	62✔
53	}
54	else if (line.find("raw") != std::string::npos)	44✔
55	{
56	state = _state::state_ignore;
57	continue;	14✔
58	}
59	else if (line.find("result") != std::string::npos)	30✔
60	{
61	state = _state::state_result;
62	continue;	×
63	}
64	else if (line.find("no register offset") != std::string::npos)	30✔
65	{
66	state = _state::state_ignore;
67	continue;	16✔
68	}
69	else if (line.find(" c") != std::string::npos)	14✔
70	{
71	state = _state::state_ignore;
72	continue;	8✔
73	}
74	else
75	{
76	std::cout << "Unknown directive " << line << std::endl;	6✔
77	state = _state::state_ignore;	251✔
78	continue;	6✔
79	}
80	}
81	if (line.empty())	2,754✔
82	{
83	continue;
84	}
85
86	switch (state)	2,480✔
87	{
88	case _state::state_assembly:
89	if (line.find("#") != std::string::npos)	1,822✔
90	{
91	line = line.substr(0, line.find("#"));	196✔
92	}	196✔
93	data_out << line << std::endl;	1,822✔
94	break;
95	case _state::state_result:
96	result = line;	210✔
97	break;
98	case _state::state_memory:
99	mem += std::string(" ") + line;	118✔
100	break;	118✔
101	default:
102	continue;
103	}
104	}
105
106	if (result.find("0x") != std::string::npos)	224✔
107	{
108	result = result.substr(result.find("0x") + 2);	210✔
109	}	210✔
110	data_out.seekg(0);	224✔
111	auto instructions = bpf_assembler(data_out);	3,420✔
112	return {mem, result, instructions};	3,420✔
113	}	10,708✔
114
115	ubpf_vm *
116	prepare_ubpf_vm(const std::vector<ebpf_inst> instructions)	210✔
117	{
118	ubpf_vm *vm = ubpf_create();	210✔
119	if (vm == nullptr)	210✔
120	throw std::runtime_error("Failed to create VM");	×
121
122	char *error = nullptr;	210✔
123	for (auto &[key, value] : helper_functions)	1,470✔
124	{
125	if (ubpf_register(vm, key, "unnamed", reinterpret_cast<void*>(value)) != 0)	1,260✔
126	throw std::runtime_error("Failed to register helper function");	×
127	}
128
129	if (ubpf_set_unwind_function_index(vm, 5) != 0)	210✔
130	throw std::runtime_error("Failed to set unwind function index");	×
131
132	if (ubpf_load(vm, instructions.data(), static_cast<uint32_t>(instructions.size() * sizeof(ebpf_inst)), &error) != 0)	210✔
133	throw std::runtime_error("Failed to load program: " + std::string(error));	×
134
135	return vm;	210✔
136	}	210✔
137
138	void run_ubpf_jit_test(const std::filesystem::path &data_file)	125✔
139	{
140	if (data_file.filename().string().find("err") != std::string::npos)	125✔
141	{
142	GTEST_SKIP();	13✔
143	return;
144	}
145	auto [mem, result, instructions] = parse_test_file(data_file);	112✔
146	if (result.empty() \|\| instructions.empty())	112✔
147	{
148	GTEST_SKIP();	7✔
149	return;
150	}
151
152	char *error = nullptr;	105✔
153	ubpf_vm *vm = prepare_ubpf_vm(instructions);	105✔
154	if (vm == nullptr)	105✔
155	throw std::runtime_error("Failed to create VM");	×
156
157	ubpf_jit_fn jit = ubpf_compile(vm, &error);	105✔
158	if (jit == nullptr)	105✔
159	throw std::runtime_error("Failed to compile program: " + std::string(error));	×
160
161	std::vector<uint8_t> input_buffer;	105✔
162
163	if (!mem.empty())	105✔
164	{
165	std::stringstream ss(mem);	31✔
166	uint32_t value;	31✔
167	while (ss >> std::hex >> value)	370✔
168	{
169	input_buffer.push_back(static_cast<uint8_t>(value));	339✔
170	}
171	}	31✔
172
173	uint64_t expected_result = std::stoull(result, nullptr, 16);	105✔
174
175	uint64_t actual_result = jit(input_buffer.data(), input_buffer.size());	105✔
176
177	if (actual_result != expected_result) {	105✔
178	std::cout << "Expected: " << expected_result << " Actual: " << actual_result << std::endl;	×
179	throw std::runtime_error("Result mismatch");	×
180	}
181
182	ubpf_destroy(vm);	105✔
183	}	125✔
184
185	void run_ubpf_interpret_test(const std::filesystem::path &data_file)	125✔
186	{
187	if (data_file.filename().string().find("err") != std::string::npos)	125✔
188	{
189	GTEST_SKIP();	13✔
190	return;
191	}
192	auto [mem, result, instructions] = parse_test_file(data_file);	112✔
193	if (result.empty() \|\| instructions.empty())	112✔
194	{
195	GTEST_SKIP();	7✔
196	return;
197	}
198
199	ubpf_vm *vm = prepare_ubpf_vm(instructions);	105✔
200	if (vm == nullptr)	105✔
201	throw std::runtime_error("Failed to create VM");	×
202
203	std::vector<uint8_t> input_buffer;	105✔
204
205	if (!mem.empty())	105✔
206	{
207	std::stringstream ss(mem);	31✔
208	uint32_t value;	31✔
209	while (ss >> std::hex >> value)	370✔
210	{
211	input_buffer.push_back(static_cast<uint8_t>(value));	339✔
212	}
213	}	31✔
214
215	uint64_t expected_result = std::stoull(result, nullptr, 16);	105✔
216
217	uint64_t actual_result;	105✔
218	if (ubpf_exec(vm, input_buffer.data(), input_buffer.size(), &actual_result) != 0)	105✔
219	throw std::runtime_error("Failed to execute program");	×
220
221	if (actual_result != expected_result) {	105✔
222	std::cout << "Expected: " << expected_result << " Actual: " << actual_result << std::endl;	×
223	throw std::runtime_error("Result mismatch");	×
224	}
225
226	ubpf_destroy(vm);	105✔
227	}	125✔
228
229	class ubpf_test : public ::testing::TestWithParam<std::filesystem::path>
230	{
231	};
232
233	TEST_P(ubpf_test, jit)	877✔
234	{
235	run_ubpf_jit_test(GetParam());	125✔
236	}	125✔
237
238	TEST_P(ubpf_test, interpret)	877✔
239	{
240	run_ubpf_interpret_test(GetParam());	125✔
241	}	125✔
242
243	std::vector<std::filesystem::path> get_test_files()	502✔
244	{
245	std::vector<std::filesystem::path> result;	502✔
246	for (auto &p : std::filesystem::directory_iterator("tests/"))	65,260✔
247	{
248	if (p.path().extension() == ".data")	64,758✔
249	{
250	result.push_back(p.path());	62,750✔
251	}
252	}	×
253	return result;
254	}	502✔
255
256	INSTANTIATE_TEST_SUITE_P(ubpf_tests, ubpf_test, ::testing::ValuesIn(get_test_files()));	63,503✔

iovisor / ubpf / 3159990762

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