19036509529

Committed 02 Nov 2025 09:22PM UTC coverage: 86.936% (-0.5%) from 87.448%

Build # 19036509529

Build Type

push

github

Committed by

elazarg

Commit Message

Bump external/libbtf from `b674148` to `04281ee`

Bumps [external/libbtf](https://github.com/Alan-Jowett/libbtf) from `b674148` to `04281ee`.
- [Release notes](https://github.com/Alan-Jowett/libbtf/releases)
- [Commits](https://github.com/Alan-Jowett/libbtf/compare/b6741487e...<a class=hub.com/Alan-Jowett/ebpf-verifier/commit/04281ee7a91595911807897b4ca2e7483cf97497">04281ee7a)

---
updated-dependencies:
- dependency-name: external/libbtf
  dependency-version: '04281ee7a91595911807897b4ca2e7483cf97497'
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

Run Details

9044 of 10403 relevant lines covered (86.94%)

3989157.54 hits per line

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

85.0

/src/string_constraints.hpp

// Copyright (c) Prevail Verifier contributors.
// SPDX-License-Identifier: MIT

#pragma once

#include <optional>
#include <set>
#include <string>
#include <vector>

#include "arith/linear_constraint.hpp"
#include "crab/interval.hpp"

namespace prevail {
struct StringInvariant {
    std::optional<std::set<std::string>> maybe_inv{};

    StringInvariant() = default;

    explicit StringInvariant(std::set<std::string> inv) : maybe_inv(std::move(inv)) {}

    StringInvariant(const StringInvariant& inv) = default;
    StringInvariant& operator=(const StringInvariant& inv) = default;
    StringInvariant(StringInvariant&& inv) = default;
    StringInvariant& operator=(StringInvariant&& inv) = default;

    [[nodiscard]]
    bool is_bottom() const {
        return !maybe_inv;
    }
    [[nodiscard]]
    bool empty() const {
        return maybe_inv && maybe_inv->empty();
    }

    static StringInvariant top() { return StringInvariant{{}}; }
    static StringInvariant bottom() { return StringInvariant{}; }

    [[nodiscard]]
    const std::set<std::string>& value() const {
        if (is_bottom()) {
            throw std::runtime_error("cannot iterate bottom");
        }
        return *maybe_inv;
    }

    StringInvariant operator-(const StringInvariant& b) const;
    StringInvariant operator+(const StringInvariant& b) const;

    bool operator==(const StringInvariant& other) const { return maybe_inv == other.maybe_inv; }

    [[nodiscard]]
    bool contains(const std::string& item) const {
        return maybe_inv.value().contains(item);
    }

    friend std::ostream& operator<<(std::ostream&, const StringInvariant& inv);
};

struct TypeValueConstraints {
    std::vector<LinearConstraint> type_csts;
    std::vector<LinearConstraint> value_csts;
};

TypeValueConstraints parse_linear_constraints(const std::set<std::string>& constraints,
                                              std::vector<Interval>& numeric_ranges);
} // namespace prevail

1	// Copyright (c) Prevail Verifier contributors.
2	// SPDX-License-Identifier: MIT
3
4	#pragma once
5
6	#include <optional>
7	#include <set>
8	#include <string>
9	#include <vector>
10
11	#include "arith/linear_constraint.hpp"
12	#include "crab/interval.hpp"
13
14	namespace prevail {
15	struct StringInvariant {	4,113✔
16	std::optional<std::set<std::string>> maybe_inv{};
17
18	StringInvariant() = default;	434✔
19
20	explicit StringInvariant(std::set<std::string> inv) : maybe_inv(std::move(inv)) {}	255,982✔
21
22	StringInvariant(const StringInvariant& inv) = default;	4,796✔
23	StringInvariant& operator=(const StringInvariant& inv) = default;
24	StringInvariant(StringInvariant&& inv) = default;	212,318✔
25	StringInvariant& operator=(StringInvariant&& inv) = default;	80✔
26
27	[[nodiscard]]
28	bool is_bottom() const {	10,446✔
29	return !maybe_inv;	10,446✔
30	}
31	[[nodiscard]]
32	bool empty() const {	×
33	return maybe_inv && maybe_inv->empty();	×
34	}
35
36	static StringInvariant top() { return StringInvariant{{}}; }	1,734✔
37	static StringInvariant bottom() { return StringInvariant{}; }	434✔
38
39	[[nodiscard]]
40	const std::set<std::string>& value() const {	3,808✔
41	if (is_bottom()) {	3,808✔
42	throw std::runtime_error("cannot iterate bottom");	×
43	}
44	return *maybe_inv;	3,808✔
45	}
46
47	StringInvariant operator-(const StringInvariant& b) const;
48	StringInvariant operator+(const StringInvariant& b) const;
49
50	bool operator==(const StringInvariant& other) const { return maybe_inv == other.maybe_inv; }	2,088✔
51
52	[[nodiscard]]
53	bool contains(const std::string& item) const {	4,224✔
54	return maybe_inv.value().contains(item);	4,224✔
55	}
56
57	friend std::ostream& operator<<(std::ostream&, const StringInvariant& inv);
58	};
59
60	struct TypeValueConstraints {	914✔
61	std::vector<LinearConstraint> type_csts;
62	std::vector<LinearConstraint> value_csts;
63	};
64
65	TypeValueConstraints parse_linear_constraints(const std::set<std::string>& constraints,
66	std::vector<Interval>& numeric_ranges);
67	} // namespace prevail

Alan-Jowett / ebpf-verifier / 19036509529

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