9092137558

Committed 15 May 2024 08:05AM UTC coverage: 77.347% (-0.001%) from 77.348%

Build # 9092137558

Build Type

Pull #476

github

Committed by

mgeplf

Commit Message

add locale-de to coverage build

Pull Request Pull Request #476: Efficient swc build

Run Details

285 of 316 new or added lines in 9 files covered. (90.19%)

13 existing lines in 4 files now uncovered.

2117 of 2737 relevant lines covered (77.35%)

900.35 hits per line

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

60.23

/src/warning_handling.cpp

#include <sstream>  // std::ostringstream

#include <morphio/mut/section.h>
#include <morphio/warning_handling.h>
#include <stdexcept>

namespace morphio {
namespace details {
std::string errorLink(const std::string& uri,
                      long unsigned int lineNumber,
                      morphio::readers::ErrorLevel errorLevel) {
    using morphio::readers::ErrorLevel;
    if (uri.empty()) {
        return {};
    }

    const auto SEVERITY = [](ErrorLevel el) {
        switch (el) {
        case ErrorLevel::INFO:
            return "info";
        case ErrorLevel::WARNING:
            return "warning";
        case ErrorLevel::ERROR:
            return "error";
        }
        throw std::runtime_error("Unknown ErrorLevel");
    };

    auto COLOR = [](ErrorLevel el) {
        switch (el) {
        case ErrorLevel::INFO:
            return "\033[1;34m";
        case ErrorLevel::WARNING:
            return "\033[1;33m";
        case ErrorLevel::ERROR:
            return "\033[1;31m";
        }
        throw std::runtime_error("Unknown ErrorLevel");
    };

    const std::string COLOR_END("\033[0m");

    return COLOR(errorLevel) + uri + ":" + std::to_string(lineNumber) + ":" + SEVERITY(errorLevel) +
           COLOR_END + "\n";
}
}  // namespace details

std::string WrongDuplicate::msg() const {
    std::string msg("Warning: while appending section: " + std::to_string(current->id()) +
                    " to parent: " + std::to_string(parent->id()));

    if (parent->points().empty()) {
        return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + msg +
               "\nThe parent section is empty.";
    }

    if (current->points().empty()) {
        return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + msg +
               "\nThe current section has no points. It should at "
               "least contains "
               "parent section last point";
    }

    auto p0 = parent->points()[parent->points().size() - 1];
    auto p1 = current->points()[0];
    auto d0 = parent->diameters()[parent->diameters().size() - 1];
    auto d1 = current->diameters()[0];

    std::ostringstream oss;
    oss << msg
        << "\nThe section first point should be parent section last point: "
           "\n        : X Y Z Diameter"
           "\nparent last point :["
        << std::to_string(p0[0]) << ", " << std::to_string(p0[1]) << ", " << std::to_string(p0[2])
        << ", " << std::to_string(d0) << "]\nchild first point :[" << std::to_string(p1[0]) << ", "
        << std::to_string(p1[1]) << ", " << std::to_string(p1[2]) << ", " << std::to_string(d1)
        << "]\n";

    return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + oss.str();
}

bool WarningHandler::isIgnored(enums::Warning warning) {
    return ignoredWarnings_.find(warning) != ignoredWarnings_.end();
}

void WarningHandler::setIgnoredWarning(enums::Warning warning, bool ignore) {
    if (ignore) {
        ignoredWarnings_.insert(warning);
    } else {
        ignoredWarnings_.erase(warning);
    }
}

int32_t WarningHandlerPrinter::getMaxWarningCount() const {
    return maxWarningCount_;
}

void WarningHandlerPrinter::setMaxWarningCount(int32_t warningCount) {
    maxWarningCount_ = warningCount;
}

bool WarningHandlerPrinter::getRaiseWarnings() const {
    return raiseWarnings_;
}
void WarningHandlerPrinter::setRaiseWarnings(bool raise) {
    raiseWarnings_ = raise;
}

void WarningHandlerPrinter::emit(std::shared_ptr<morphio::WarningMessage> wm) {
    const int maxWarningCount = getMaxWarningCount();

    const auto& warning = wm->warning();

    if (isIgnored(warning) || maxWarningCount == 0) {
        return;
    }

    if (getRaiseWarnings()) {
        throw morphio::MorphioError(wm->msg());
    }

    if (maxWarningCount < 0 || errorCount <= static_cast<uint32_t>(maxWarningCount)) {
        std::cerr << wm->msg() << '\n';
        if (maxWarningCount > 0 && errorCount == static_cast<uint32_t>(maxWarningCount)) {
            std::cerr << "Maximum number of warning reached. Next warnings "
                         "won't be displayed.\n"
                         "You can change this number by calling:\n"
                         "\t- C++: set_maximum_warnings(int)\n"
                         "\t- Python: morphio.set_maximum_warnings(int)\n"
                         "0 will print no warning. -1 will print them all\n";
        }
        ++errorCount;
    }
}

int WarningHandlerCollector::getMaxWarningCount() const {
    throw std::runtime_error("WarningHandlerCollector does not implement getMaxWarningCount");
}
void WarningHandlerCollector::setMaxWarningCount(int /*warningCount*/) {
    throw std::runtime_error("WarningHandlerCollector does not implement setMaxWarningCount");
}
bool WarningHandlerCollector::getRaiseWarnings() const {
    throw std::runtime_error("WarningHandlerCollector does not implement getRaiseWarnings");
}
void WarningHandlerCollector::setRaiseWarnings(bool /*raise*/) {
    throw std::runtime_error("WarningHandlerCollector does not implement setRaiseWarnings");
}

void WarningHandlerCollector::emit(std::shared_ptr<WarningMessage> wm) {
    m.emplace_back(isIgnored(wm->warning()), wm);
}

void WarningHandlerCollector::reset() {
    m.erase(m.begin());
}

std::vector<WarningHandlerCollector::Emission> WarningHandlerCollector::getAll() const {
    return m;
}


}  // namespace morphio

1	#include <sstream> // std::ostringstream
2
3	#include <morphio/mut/section.h>
4	#include <morphio/warning_handling.h>
5	#include <stdexcept>
6
7	namespace morphio {
8	namespace details {
9	std::string errorLink(const std::string& uri,	112✔
10	long unsigned int lineNumber,
11	morphio::readers::ErrorLevel errorLevel) {
12	using morphio::readers::ErrorLevel;
13	if (uri.empty()) {	112✔
14	return {};	26✔
15	}
16
17	const auto SEVERITY = [](ErrorLevel el) {	86✔
18	switch (el) {	86✔
UNCOV 19	case ErrorLevel::INFO:	×
UNCOV 20	return "info";	×
21	case ErrorLevel::WARNING:	64✔
22	return "warning";	64✔
23	case ErrorLevel::ERROR:	22✔
24	return "error";	22✔
25	}
26	throw std::runtime_error("Unknown ErrorLevel");	×
27	};
28
29	auto COLOR = [](ErrorLevel el) {	86✔
30	switch (el) {	86✔
UNCOV 31	case ErrorLevel::INFO:	×
UNCOV 32	return "\033[1;34m";	×
33	case ErrorLevel::WARNING:	64✔
34	return "\033[1;33m";	64✔
35	case ErrorLevel::ERROR:	22✔
36	return "\033[1;31m";	22✔
37	}
38	throw std::runtime_error("Unknown ErrorLevel");	×
39	};
40
41	const std::string COLOR_END("\033[0m");	86✔
42
43	return COLOR(errorLevel) + uri + ":" + std::to_string(lineNumber) + ":" + SEVERITY(errorLevel) +	172✔
44	COLOR_END + "\n";	86✔
45	}
46	} // namespace details
47
48	std::string WrongDuplicate::msg() const {	8✔
49	std::string msg("Warning: while appending section: " + std::to_string(current->id()) +	16✔
50	" to parent: " + std::to_string(parent->id()));	24✔
51
52	if (parent->points().empty()) {	8✔
53	return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + msg +	×
54	"\nThe parent section is empty.";	×
55	}
56
57	if (current->points().empty()) {	8✔
58	return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + msg +	×
59	"\nThe current section has no points. It should at "
60	"least contains "
61	"parent section last point";	×
62	}
63
64	auto p0 = parent->points()[parent->points().size() - 1];	8✔
65	auto p1 = current->points()[0];	8✔
66	auto d0 = parent->diameters()[parent->diameters().size() - 1];	8✔
67	auto d1 = current->diameters()[0];	8✔
68
69	std::ostringstream oss;	8✔
70	oss << msg
71	<< "\nThe section first point should be parent section last point: "
72	"\n : X Y Z Diameter"
73	"\nparent last point :["
74	<< std::to_string(p0[0]) << ", " << std::to_string(p0[1]) << ", " << std::to_string(p0[2])	32✔
75	<< ", " << std::to_string(d0) << "]\nchild first point :[" << std::to_string(p1[0]) << ", "	16✔
76	<< std::to_string(p1[1]) << ", " << std::to_string(p1[2]) << ", " << std::to_string(d1)	24✔
77	<< "]\n";	56✔
78
79	return "\n" + details::errorLink(uri, 0, readers::ErrorLevel::WARNING) + oss.str();	16✔
80	}
81
82	bool WarningHandler::isIgnored(enums::Warning warning) {	76✔
83	return ignoredWarnings_.find(warning) != ignoredWarnings_.end();	76✔
84	}
85
UNCOV 86	void WarningHandler::setIgnoredWarning(enums::Warning warning, bool ignore) {	×
UNCOV 87	if (ignore) {	×
UNCOV 88	ignoredWarnings_.insert(warning);	×
89	} else {
UNCOV 90	ignoredWarnings_.erase(warning);	×
91	}
UNCOV 92	}	×
93
94	int32_t WarningHandlerPrinter::getMaxWarningCount() const {	72✔
95	return maxWarningCount_;	72✔
96	}
97
98	void WarningHandlerPrinter::setMaxWarningCount(int32_t warningCount) {	×
99	maxWarningCount_ = warningCount;	×
100	}	×
101
102	bool WarningHandlerPrinter::getRaiseWarnings() const {	72✔
103	return raiseWarnings_;	72✔
104	}
105	void WarningHandlerPrinter::setRaiseWarnings(bool raise) {	×
106	raiseWarnings_ = raise;	×
107	}	×
108
109	void WarningHandlerPrinter::emit(std::shared_ptr<morphio::WarningMessage> wm) {	72✔
110	const int maxWarningCount = getMaxWarningCount();	72✔
111
112	const auto& warning = wm->warning();	72✔
113
114	if (isIgnored(warning) \|\| maxWarningCount == 0) {	72✔
UNCOV 115	return;	×
116	}
117
118	if (getRaiseWarnings()) {	72✔
119	throw morphio::MorphioError(wm->msg());	×
120	}
121
122	if (maxWarningCount < 0 \|\| errorCount <= static_cast<uint32_t>(maxWarningCount)) {	72✔
123	std::cerr << wm->msg() << '\n';	72✔
124	if (maxWarningCount > 0 && errorCount == static_cast<uint32_t>(maxWarningCount)) {	72✔
125	std::cerr << "Maximum number of warning reached. Next warnings "
126	"won't be displayed.\n"
127	"You can change this number by calling:\n"
128	"\t- C++: set_maximum_warnings(int)\n"
129	"\t- Python: morphio.set_maximum_warnings(int)\n"
130	"0 will print no warning. -1 will print them all\n";	×
131	}
132	++errorCount;	72✔
133	}
134	}
135
136	int WarningHandlerCollector::getMaxWarningCount() const {	×
137	throw std::runtime_error("WarningHandlerCollector does not implement getMaxWarningCount");	×
138	}
139	void WarningHandlerCollector::setMaxWarningCount(int /warningCount/) {	×
140	throw std::runtime_error("WarningHandlerCollector does not implement setMaxWarningCount");	×
141	}
142	bool WarningHandlerCollector::getRaiseWarnings() const {	×
143	throw std::runtime_error("WarningHandlerCollector does not implement getRaiseWarnings");	×
144	}
145	void WarningHandlerCollector::setRaiseWarnings(bool /raise/) {	×
146	throw std::runtime_error("WarningHandlerCollector does not implement setRaiseWarnings");	×
147	}
148
149	void WarningHandlerCollector::emit(std::shared_ptr<WarningMessage> wm) {	4✔
150	m.emplace_back(isIgnored(wm->warning()), wm);	4✔
151	}	4✔
152
153	void WarningHandlerCollector::reset() {	×
154	m.erase(m.begin());	×
155	}	×
156
157	std::vector<WarningHandlerCollector::Emission> WarningHandlerCollector::getAll() const {	4✔
158	return m;	4✔
159	}
160
161
162	} // namespace morphio

BlueBrain / MorphIO / 9092137558

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