srctree

Robin Linden parent d3895314 150d404d
etest: Drop _true suffix from expect_true

This is shorter and feels nicer. The _true suffix was dropped asexpect(bool) and expect_true(bool) both convey the same information. Mayadd expect_true back for symmetry when expect_false is added.

inline split

css/parser_test.cpp added: 136, removed: 136, total 0

@@ -3,87 +3,87 @@

#include "etest/etest.h"

using namespace std::literals;

using etest::expect_true;

using etest::expect;

int main() {

etest::test("parser: simple rule", [] {

auto rules = css::parse("body { width: 50px; }"sv);

expect_true(rules.size() == 1);

expect(rules.size() == 1);

auto body = rules[0];

expect_true(body.selectors == std::vector{"body"s});

expect_true(body.declarations.size() == 1);

expect_true(body.declarations.at("width"s) == "50px"s);

expect(body.selectors == std::vector{"body"s});

expect(body.declarations.size() == 1);

expect(body.declarations.at("width"s) == "50px"s);

});

etest::test("parser: multiple rules", [] {

auto rules = css::parse("body { width: 50px; }\np { font-size: 8em; }"sv);

expect_true(rules.size() == 2);

expect(rules.size() == 2);

auto body = rules[0];

expect_true(body.selectors == std::vector{"body"s});

expect_true(body.declarations.size() == 1);

expect_true(body.declarations.at("width"s) == "50px"s);

expect(body.selectors == std::vector{"body"s});

expect(body.declarations.size() == 1);

expect(body.declarations.at("width"s) == "50px"s);

auto p = rules[1];

expect_true(p.selectors == std::vector{"p"s});

expect_true(p.declarations.size() == 1);

expect_true(p.declarations.at("font-size"s) == "8em"s);

expect(p.selectors == std::vector{"p"s});

expect(p.declarations.size() == 1);

expect(p.declarations.at("font-size"s) == "8em"s);

});

etest::test("parser: multiple selectors", [] {

auto rules = css::parse("body, p { width: 50px; }"sv);

expect_true(rules.size() == 1);

expect(rules.size() == 1);

auto body = rules[0];

expect_true(body.selectors == std::vector{"body"s, "p"s});

expect_true(body.declarations.size() == 1);

expect_true(body.declarations.at("width"s) == "50px"s);

expect(body.selectors == std::vector{"body"s, "p"s});

expect(body.declarations.size() == 1);

expect(body.declarations.at("width"s) == "50px"s);

});

etest::test("parser: multiple declarations", [] {

auto rules = css::parse("body { width: 50px; height: 300px; }"sv);

expect_true(rules.size() == 1);

expect(rules.size() == 1);

auto body = rules[0];

expect_true(body.selectors == std::vector{"body"s});

expect_true(body.declarations.size() == 2);

expect_true(body.declarations.at("width"s) == "50px"s);

expect_true(body.declarations.at("height"s) == "300px"s);

expect(body.selectors == std::vector{"body"s});

expect(body.declarations.size() == 2);

expect(body.declarations.at("width"s) == "50px"s);

expect(body.declarations.at("height"s) == "300px"s);

});

etest::test("parser: class", [] {

auto rules = css::parse(".cls { width: 50px; }"sv);

expect_true(rules.size() == 1);

expect(rules.size() == 1);

auto body = rules[0];

expect_true(body.selectors == std::vector{".cls"s});

expect_true(body.declarations.size() == 1);

expect_true(body.declarations.at("width"s) == "50px"s);

expect(body.selectors == std::vector{".cls"s});

expect(body.declarations.size() == 1);

expect(body.declarations.at("width"s) == "50px"s);

});

etest::test("parser: id", [] {

auto rules = css::parse("#cls { width: 50px; }"sv);

expect_true(rules.size() == 1);

expect(rules.size() == 1);

auto body = rules[0];

expect_true(body.selectors == std::vector{"#cls"s});

expect_true(body.declarations.size() == 1);

expect_true(body.declarations.at("width"s) == "50px"s);

expect(body.selectors == std::vector{"#cls"s});

expect(body.declarations.size() == 1);

expect(body.declarations.at("width"s) == "50px"s);

});

etest::test("parser: empty rule", [] {

auto rules = css::parse("body {}"sv);

expect_true(rules.size() == 1);

expect(rules.size() == 1);

auto body = rules[0];

expect_true(body.selectors == std::vector{"body"s});

expect_true(body.declarations.size() == 0);

expect(body.selectors == std::vector{"body"s});

expect(body.declarations.size() == 0);

});

etest::test("parser: no rules", [] {

auto rules = css::parse(""sv);

expect_true(rules.size() == 0);

expect(rules.size() == 0);

});

return etest::run_all_tests();

etest/etest.cpp added: 136, removed: 136, total 0

@@ -50,7 +50,7 @@ int test(std::string_view name, std::function<void()> body) noexcept {

return 0;

}

void expect_true(bool b) noexcept {

void expect(bool b) noexcept {

if (!b) { ++assertion_failures; }

}

etest/etest.h added: 136, removed: 136, total 0

@@ -8,7 +8,7 @@ namespace etest {

int run_all_tests() noexcept;

int test(std::string_view name, std::function<void()> body) noexcept;

void expect_true(bool) noexcept;

void expect(bool) noexcept;

} // namespace etest

etest/etest_test.cpp added: 136, removed: 136, total 0

@@ -1,5 +1,5 @@

#include "etest/etest.h"

auto test0 = etest::test("expect true works", [] {

etest::expect_true(true);

etest::expect(true);

});

html/test_parser.cpp added: 136, removed: 136, total 0

@@ -3,155 +3,155 @@

#include "etest/etest.h"

using namespace std::literals;

using etest::expect_true;

using etest::expect;

int main() {

etest::test("doctype", [] {

auto nodes = html::parse("<!doctype html>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto doctype = nodes[0];

expect_true(doctype.children.size() == 0);

expect_true(std::get<dom::Doctype>(doctype.data).doctype == "html"s);

expect(doctype.children.size() == 0);

expect(std::get<dom::Doctype>(doctype.data).doctype == "html"s);

});

etest::test("weirdly capitalized doctype", [] {

auto nodes = html::parse("<!docTYpe html>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto doctype = nodes[0];

expect_true(doctype.children.size() == 0);

expect_true(std::get<dom::Doctype>(doctype.data).doctype == "html"s);

expect(doctype.children.size() == 0);

expect(std::get<dom::Doctype>(doctype.data).doctype == "html"s);

});

etest::test("single element", [] {

auto nodes = html::parse("<html></html>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto html = nodes[0];

expect_true(html.children.size() == 0);

expect_true(std::get<dom::Element>(html.data).name == "html"s);

expect_true(std::get<dom::Element>(html.data).attributes.size() == 0);

expect(html.children.size() == 0);

expect(std::get<dom::Element>(html.data).name == "html"s);

expect(std::get<dom::Element>(html.data).attributes.size() == 0);

});

etest::test("self-closing single element", [] {

auto nodes = html::parse("<br>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto br = nodes[0];

expect_true(br.children.size() == 0);

expect_true(std::get<dom::Element>(br.data).name == "br"s);

expect_true(std::get<dom::Element>(br.data).attributes.size() == 0);

expect(br.children.size() == 0);

expect(std::get<dom::Element>(br.data).name == "br"s);

expect(std::get<dom::Element>(br.data).attributes.size() == 0);

});

etest::test("self-closing single element with slash", [] {

auto nodes = html::parse("<img/>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto img = nodes[0];

expect_true(img.children.size() == 0);

expect_true(std::get<dom::Element>(img.data).name == "img"s);

expect_true(std::get<dom::Element>(img.data).attributes.size() == 0);

expect(img.children.size() == 0);

expect(std::get<dom::Element>(img.data).name == "img"s);

expect(std::get<dom::Element>(img.data).attributes.size() == 0);

});

etest::test("multiple elements", [] {

auto nodes = html::parse("<span></span><div></div>"sv);

expect_true(nodes.size() == 2);

expect(nodes.size() == 2);

auto span = nodes[0];

expect_true(span.children.size() == 0);

expect_true(std::get<dom::Element>(span.data).name == "span"s);

expect_true(std::get<dom::Element>(span.data).attributes.size() == 0);

expect(span.children.size() == 0);

expect(std::get<dom::Element>(span.data).name == "span"s);

expect(std::get<dom::Element>(span.data).attributes.size() == 0);

auto div = nodes[1];

expect_true(div.children.size() == 0);

expect_true(std::get<dom::Element>(div.data).name == "div"s);

expect_true(std::get<dom::Element>(div.data).attributes.size() == 0);

expect(div.children.size() == 0);

expect(std::get<dom::Element>(div.data).name == "div"s);

expect(std::get<dom::Element>(div.data).attributes.size() == 0);

});

etest::test("nested elements", [] {

auto nodes = html::parse("<html><body></body></html>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto html = nodes[0];

expect_true(html.children.size() == 1);

expect_true(std::get<dom::Element>(html.data).name == "html"s);

expect_true(std::get<dom::Element>(html.data).attributes.size() == 0);

expect(html.children.size() == 1);

expect(std::get<dom::Element>(html.data).name == "html"s);

expect(std::get<dom::Element>(html.data).attributes.size() == 0);

auto body = html.children[0];

expect_true(std::get<dom::Element>(body.data).name == "body"s);

expect_true(std::get<dom::Element>(body.data).attributes.size() == 0);

expect(std::get<dom::Element>(body.data).name == "body"s);

expect(std::get<dom::Element>(body.data).attributes.size() == 0);

});

etest::test("single-quoted attribute", [] {

auto nodes = html::parse("<meta charset='utf-8'/>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto meta = nodes[0];

expect_true(meta.children.size() == 0);

expect(meta.children.size() == 0);

auto meta_data = std::get<dom::Element>(meta.data);

expect_true(meta_data.name == "meta"s);

expect_true(meta_data.attributes.size() == 1);

expect_true(meta_data.attributes.at("charset") == "utf-8"s);

expect(meta_data.name == "meta"s);

expect(meta_data.attributes.size() == 1);

expect(meta_data.attributes.at("charset") == "utf-8"s);

});

etest::test("double-quoted attribute", [] {

auto nodes = html::parse("<meta charset=\"utf-8\"/>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto meta = nodes[0];

expect_true(meta.children.size() == 0);

expect(meta.children.size() == 0);

auto meta_data = std::get<dom::Element>(meta.data);

expect_true(meta_data.name == "meta"s);

expect_true(meta_data.attributes.size() == 1);

expect_true(meta_data.attributes.at("charset"s) == "utf-8"s);

expect(meta_data.name == "meta"s);

expect(meta_data.attributes.size() == 1);

expect(meta_data.attributes.at("charset"s) == "utf-8"s);

});

etest::test("multiple attributes", [] {

auto nodes = html::parse("<meta name=\"viewport\" content=\"width=100em, initial-scale=1\"/>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto meta = nodes[0];

expect_true(meta.children.size() == 0);

expect(meta.children.size() == 0);

auto meta_data = std::get<dom::Element>(meta.data);

expect_true(meta_data.name == "meta"s);

expect_true(meta_data.attributes.size() == 2);

expect_true(meta_data.attributes.at("name"s) == "viewport"s);

expect_true(meta_data.attributes.at("content"s) == "width=100em, initial-scale=1"s);

expect(meta_data.name == "meta"s);

expect(meta_data.attributes.size() == 2);

expect(meta_data.attributes.at("name"s) == "viewport"s);

expect(meta_data.attributes.at("content"s) == "width=100em, initial-scale=1"s);

});

etest::test("multiple nodes with attributes", [] {

auto nodes = html::parse("<html bonus='hello'><body style='fancy'></body></html>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto html = nodes[0];

expect_true(html.children.size() == 1);

expect(html.children.size() == 1);

auto html_data = std::get<dom::Element>(html.data);

expect_true(html_data.name == "html"s);

expect_true(html_data.attributes.size() == 1);

expect_true(html_data.attributes.at("bonus"s) == "hello"s);

expect(html_data.name == "html"s);

expect(html_data.attributes.size() == 1);

expect(html_data.attributes.at("bonus"s) == "hello"s);

auto body = html.children[0];

auto body_data = std::get<dom::Element>(body.data);

expect_true(body_data.name == "body"s);

expect_true(body_data.attributes.size() == 1);

expect_true(body_data.attributes.at("style"s) == "fancy"s);

expect(body_data.name == "body"s);

expect(body_data.attributes.size() == 1);

expect(body_data.attributes.at("style"s) == "fancy"s);

});

etest::test("text node", [] {

auto nodes = html::parse("<html>fantastic, the future is now</html>"sv);

expect_true(nodes.size() == 1);

expect(nodes.size() == 1);

auto html = nodes[0];

expect_true(html.children.size() == 1);

expect_true(std::get<dom::Element>(html.data).name == "html"s);

expect_true(std::get<dom::Element>(html.data).attributes.size() == 0);

expect(html.children.size() == 1);

expect(std::get<dom::Element>(html.data).name == "html"s);

expect(std::get<dom::Element>(html.data).attributes.size() == 0);

auto text = html.children[0];

expect_true(std::get<dom::Text>(text.data).text == "fantastic, the future is now"s);

expect(std::get<dom::Text>(text.data).text == "fantastic, the future is now"s);

});

return etest::run_all_tests();

style/style_test.cpp added: 136, removed: 136, total 0

@@ -4,17 +4,17 @@

#include "etest/etest.h"

using namespace std::literals;

using etest::expect_true;

using etest::expect;

int main() {

etest::test("is_match: simple names", [] {

expect_true(style::is_match(dom::Element{"div"}, "div"sv));

expect_true(!style::is_match(dom::Element{"div"}, "span"sv));

expect(style::is_match(dom::Element{"div"}, "div"sv));

expect(!style::is_match(dom::Element{"div"}, "span"sv));

});

etest::test("matching_rules: simple names", [] {

std::vector<css::Rule> stylesheet;

expect_true(style::matching_rules(dom::Element{"div"}, stylesheet).empty());

expect(style::matching_rules(dom::Element{"div"}, stylesheet).empty());

stylesheet.push_back(css::Rule{

.selectors = {"span", "p"},

@@ -23,18 +23,18 @@ int main() {

}

});

expect_true(style::matching_rules(dom::Element{"div"}, stylesheet).empty());

expect(style::matching_rules(dom::Element{"div"}, stylesheet).empty());

{

auto span_rules = style::matching_rules(dom::Element{"span"}, stylesheet);

expect_true(span_rules.size() == 1);

expect_true(span_rules.at(0) == std::pair{"width"s, "80px"s});

expect(span_rules.size() == 1);

expect(span_rules.at(0) == std::pair{"width"s, "80px"s});

}

{

auto p_rules = style::matching_rules(dom::Element{"p"}, stylesheet);

expect_true(p_rules.size() == 1);

expect_true(p_rules.at(0) == std::pair{"width"s, "80px"s});

expect(p_rules.size() == 1);

expect(p_rules.at(0) == std::pair{"width"s, "80px"s});

}

stylesheet.push_back(css::Rule{

@@ -44,25 +44,25 @@ int main() {

}

});

expect_true(style::matching_rules(dom::Element{"div"}, stylesheet).empty());

expect(style::matching_rules(dom::Element{"div"}, stylesheet).empty());

{

auto span_rules = style::matching_rules(dom::Element{"span"}, stylesheet);

expect_true(span_rules.size() == 2);

expect_true(span_rules.at(0) == std::pair{"width"s, "80px"s});

expect_true(span_rules.at(1) == std::pair{"height"s, "auto"s});

expect(span_rules.size() == 2);

expect(span_rules.at(0) == std::pair{"width"s, "80px"s});

expect(span_rules.at(1) == std::pair{"height"s, "auto"s});

}

{

auto p_rules = style::matching_rules(dom::Element{"p"}, stylesheet);

expect_true(p_rules.size() == 1);

expect_true(p_rules.at(0) == std::pair{"width"s, "80px"s});

expect(p_rules.size() == 1);

expect(p_rules.at(0) == std::pair{"width"s, "80px"s});

}

{

auto hr_rules = style::matching_rules(dom::Element{"hr"}, stylesheet);

expect_true(hr_rules.size() == 1);

expect_true(hr_rules.at(0) == std::pair{"height"s, "auto"s});

expect(hr_rules.size() == 1);

expect(hr_rules.at(0) == std::pair{"height"s, "auto"s});

}

});

util/base_parser_test.cpp added: 136, removed: 136, total 0

@@ -2,7 +2,7 @@

#include "etest/etest.h"

using etest::expect_true;

using etest::expect;

using util::BaseParser;

namespace {

@@ -18,26 +18,26 @@ bool static_test() {

int main() {

etest::test("peek", [] {

constexpr auto abcd = BaseParser("abcd");

expect_true(static_test<abcd.peek() == 'a'>());

expect_true(static_test<abcd.peek(2) == "ab">());

expect_true(static_test<abcd.peek(3) == "abc">());

expect_true(static_test<abcd.peek(4) == "abcd">());

expect_true(static_test<BaseParser(" ").peek() == ' '>());

expect(static_test<abcd.peek() == 'a'>());

expect(static_test<abcd.peek(2) == "ab">());

expect(static_test<abcd.peek(3) == "abc">());

expect(static_test<abcd.peek(4) == "abcd">());

expect(static_test<BaseParser(" ").peek() == ' '>());

});

etest::test("starts_with", [] {

constexpr auto abcd = BaseParser("abcd");

expect_true(static_test<!abcd.starts_with("hello")>());

expect_true(static_test<abcd.starts_with("ab")>());

expect_true(static_test<abcd.starts_with("abcd")>());

expect(static_test<!abcd.starts_with("hello")>());

expect(static_test<abcd.starts_with("ab")>());

expect(static_test<abcd.starts_with("abcd")>());

});

#ifndef __clang__ // Clang doesn't yet support lambdas in templates.

etest::test("is_eof, advance", [] {

constexpr auto abcd = BaseParser("abcd");

expect_true(static_test<!abcd.is_eof()>());

expect_true(static_test<BaseParser("").is_eof()>());

expect_true(static_test<[] {

expect(static_test<!abcd.is_eof()>());

expect(static_test<BaseParser("").is_eof()>());

expect(static_test<[] {

auto p = BaseParser("abcd");

p.advance(3);

if (p.is_eof()) { return false; }

@@ -47,7 +47,7 @@ int main() {

});

etest::test("consume_char", [] {

expect_true(static_test<[] {

expect(static_test<[] {

auto p = BaseParser("abcd");

if (p.consume_char() != 'a') { return false; }

if (p.consume_char() != 'b') { return false; }

@@ -58,7 +58,7 @@ int main() {

});

etest::test("consume_while", [] {

expect_true(static_test<[] {

expect(static_test<[] {

auto p = BaseParser("abcd");

if (p.consume_while([](char c) { return c != 'c'; }) != "ab") { return false; }

if (p.consume_while([](char c) { return c != 'd'; }) != "c") { return false; }

@@ -67,7 +67,7 @@ int main() {

});

etest::test("skip_whitespace, consume_char", [] {

expect_true(static_test<[] {

expect(static_test<[] {

auto p = BaseParser(" \t \n h \n\n\ni");

p.skip_whitespace();

if (p.consume_char() != 'h') { return false; }