Mercurial > irccd

diff tests/util/main.cpp @ 207:6635b9187d71

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Irccd: switch to 4 spaces indent, #518
author David Demelier <markand@malikania.fr>
date Tue, 21 Jun 2016 20:52:17 +0200
parents b39573fc066e
children c6fbb6e0e06d
line wrap: on
line diff
--- a/tests/util/main.cpp	Tue Jun 21 12:36:46 2016 +0200
+++ b/tests/util/main.cpp	Tue Jun 21 20:52:17 2016 +0200
@@ -31,122 +31,122 @@
 
 TEST(Format, nothing)
 {
-	std::string expected = "hello world!";
-	std::string result = util::format("hello world!");
+    std::string expected = "hello world!";
+    std::string result = util::format("hello world!");
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 TEST(Format, escape)
 {
-	util::Substitution params;
+    util::Substitution params;
 
-	params.keywords.emplace("target", "hello");
+    params.keywords.emplace("target", "hello");
 
-	ASSERT_EQ("$@#", util::format("$@#"));
-	ASSERT_EQ(" $ @ # ", util::format(" $ @ # "));
-	ASSERT_EQ("#", util::format("#"));
-	ASSERT_EQ(" # ", util::format(" # "));
-	ASSERT_EQ("#@", util::format("#@"));
-	ASSERT_EQ("##", util::format("##"));
-	ASSERT_EQ("#!", util::format("#!"));
-	ASSERT_EQ("#{target}", util::format("##{target}"));
-	ASSERT_EQ("@hello", util::format("@#{target}", params));
-	ASSERT_EQ("hello#", util::format("#{target}#", params));
-	ASSERT_ANY_THROW(util::format("#{failure"));
+    ASSERT_EQ("$@#", util::format("$@#"));
+    ASSERT_EQ(" $ @ # ", util::format(" $ @ # "));
+    ASSERT_EQ("#", util::format("#"));
+    ASSERT_EQ(" # ", util::format(" # "));
+    ASSERT_EQ("#@", util::format("#@"));
+    ASSERT_EQ("##", util::format("##"));
+    ASSERT_EQ("#!", util::format("#!"));
+    ASSERT_EQ("#{target}", util::format("##{target}"));
+    ASSERT_EQ("@hello", util::format("@#{target}", params));
+    ASSERT_EQ("hello#", util::format("#{target}#", params));
+    ASSERT_ANY_THROW(util::format("#{failure"));
 }
 
 TEST(Format, disableDate)
 {
-	util::Substitution params;
+    util::Substitution params;
 
-	params.flags &= ~(util::Substitution::Date);
+    params.flags &= ~(util::Substitution::Date);
 
-	ASSERT_EQ("%H:%M", util::format("%H:%M", params));
+    ASSERT_EQ("%H:%M", util::format("%H:%M", params));
 }
 
 TEST(Format, disableKeywords)
 {
-	util::Substitution params;
+    util::Substitution params;
 
-	params.keywords.emplace("target", "hello");
-	params.flags &= ~(util::Substitution::Keywords);
+    params.keywords.emplace("target", "hello");
+    params.flags &= ~(util::Substitution::Keywords);
 
-	ASSERT_EQ("#{target}", util::format("#{target}", params));
+    ASSERT_EQ("#{target}", util::format("#{target}", params));
 }
 
 TEST(Format, disableEnv)
 {
-	util::Substitution params;
+    util::Substitution params;
 
-	params.flags &= ~(util::Substitution::Env);
+    params.flags &= ~(util::Substitution::Env);
 
-	ASSERT_EQ("${HOME}", util::format("${HOME}", params));
+    ASSERT_EQ("${HOME}", util::format("${HOME}", params));
 }
 
 TEST(Format, keywordSimple)
 {
-	util::Substitution params;
+    util::Substitution params;
 
-	params.keywords.insert({"target", "irccd"});
+    params.keywords.insert({"target", "irccd"});
 
-	std::string expected = "hello irccd!";
-	std::string result = util::format("hello #{target}!", params);
+    std::string expected = "hello irccd!";
+    std::string result = util::format("hello #{target}!", params);
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 TEST(Format, keywordMultiple)
 {
-	util::Substitution params;
+    util::Substitution params;
 
-	params.keywords.insert({"target", "irccd"});
-	params.keywords.insert({"source", "nightmare"});
+    params.keywords.insert({"target", "irccd"});
+    params.keywords.insert({"source", "nightmare"});
 
-	std::string expected = "hello irccd from nightmare!";
-	std::string result = util::format("hello #{target} from #{source}!", params);
+    std::string expected = "hello irccd from nightmare!";
+    std::string result = util::format("hello #{target} from #{source}!", params);
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 TEST(Format, keywordAdjTwice)
 {
-	util::Substitution params;
+    util::Substitution params;
 
-	params.keywords.insert({"target", "irccd"});
+    params.keywords.insert({"target", "irccd"});
 
-	std::string expected = "hello irccdirccd!";
-	std::string result = util::format("hello #{target}#{target}!", params);
+    std::string expected = "hello irccdirccd!";
+    std::string result = util::format("hello #{target}#{target}!", params);
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 TEST(Format, keywordMissing)
 {
-	std::string expected = "hello !";
-	std::string result = util::format("hello #{target}!");
+    std::string expected = "hello !";
+    std::string result = util::format("hello #{target}!");
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 TEST(Format, envSimple)
 {
-	std::string home = sys::env("HOME");
+    std::string home = sys::env("HOME");
 
-	if (!home.empty()) {
-		std::string expected = "my home is " + home;
-		std::string result = util::format("my home is ${HOME}");
+    if (!home.empty()) {
+        std::string expected = "my home is " + home;
+        std::string result = util::format("my home is ${HOME}");
 
-		ASSERT_EQ(expected, result);
-	}
+        ASSERT_EQ(expected, result);
+    }
 }
 
 TEST(Format, envMissing)
 {
-	std::string expected = "value is ";
-	std::string result = util::format("value is ${HOPE_THIS_VAR_NOT_EXIST}");
+    std::string expected = "value is ";
+    std::string result = util::format("value is ${HOPE_THIS_VAR_NOT_EXIST}");
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 /* --------------------------------------------------------
@@ -157,18 +157,18 @@
 
 TEST(Split, simple)
 {
-	List expected { "a", "b" };
-	List result = util::split("a;b", ";");
+    List expected { "a", "b" };
+    List result = util::split("a;b", ";");
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 TEST(Split, cut)
 {
-	List expected { "msg", "#staff", "foo bar baz" };
-	List result = util::split("msg;#staff;foo bar baz", ";", 3);
+    List expected { "msg", "#staff", "foo bar baz" };
+    List result = util::split("msg;#staff;foo bar baz", ";", 3);
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 /* --------------------------------------------------------
@@ -177,74 +177,74 @@
 
 TEST(Strip, left)
 {
-	std::string value = "   123";
-	std::string result = util::strip(value);
+    std::string value = "   123";
+    std::string result = util::strip(value);
 
-	ASSERT_EQ("123", result);
+    ASSERT_EQ("123", result);
 }
 
 TEST(Strip, right)
 {
-	std::string value = "123   ";
-	std::string result = util::strip(value);
+    std::string value = "123   ";
+    std::string result = util::strip(value);
 
-	ASSERT_EQ("123", result);
+    ASSERT_EQ("123", result);
 }
 
 TEST(Strip, both)
 {
-	std::string value = "   123   ";
-	std::string result = util::strip(value);
+    std::string value = "   123   ";
+    std::string result = util::strip(value);
 
-	ASSERT_EQ("123", result);
+    ASSERT_EQ("123", result);
 }
 
 TEST(Strip, none)
 {
-	std::string value = "without";
-	std::string result = util::strip(value);
+    std::string value = "without";
+    std::string result = util::strip(value);
 
-	ASSERT_EQ("without", result);
+    ASSERT_EQ("without", result);
 }
 
 TEST(Strip, betweenEmpty)
 {
-	std::string value = "one list";
-	std::string result = util::strip(value);
+    std::string value = "one list";
+    std::string result = util::strip(value);
 
-	ASSERT_EQ("one list", result);
+    ASSERT_EQ("one list", result);
 }
 
 TEST(Strip, betweenLeft)
 {
-	std::string value = "  space at left";
-	std::string result = util::strip(value);
+    std::string value = "  space at left";
+    std::string result = util::strip(value);
 
-	ASSERT_EQ("space at left", result);
+    ASSERT_EQ("space at left", result);
 }
 
 TEST(Strip, betweenRight)
 {
-	std::string value = "space at right  ";
-	std::string result = util::strip(value);
+    std::string value = "space at right  ";
+    std::string result = util::strip(value);
 
-	ASSERT_EQ("space at right", result);
+    ASSERT_EQ("space at right", result);
 }
 
 TEST(Strip, betweenBoth)
 {
-	std::string value = "  space at both  ";
-	std::string result = util::strip(value);
+    std::string value = "  space at both  ";
+    std::string result = util::strip(value);
 
-	ASSERT_EQ("space at both", result);
+    ASSERT_EQ("space at both", result);
 }
 
 TEST(Strip, empty)
 {
-	std::string value = "    ";
-	std::string result = util::strip(value);
+    std::string value = "    ";
+    std::string result = util::strip(value);
 
-	ASSERT_EQ("", result);
+    ASSERT_EQ("", result);
 }
 
 /* --------------------------------------------------------
@@ -253,42 +253,42 @@
 
 TEST(Join, empty)
 {
-	std::string expected = "";
-	std::string result = util::join<int>({});
+    std::string expected = "";
+    std::string result = util::join<int>({});
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 TEST(Join, one)
 {
-	std::string expected = "1";
-	std::string result = util::join({1});
+    std::string expected = "1";
+    std::string result = util::join({1});
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 TEST(Join, two)
 {
-	std::string expected = "1:2";
-	std::string result = util::join({1, 2});
+    std::string expected = "1:2";
+    std::string result = util::join({1, 2});
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 TEST(Join, delimiterString)
 {
-	std::string expected = "1;;2;;3";
-	std::string result = util::join({1, 2, 3}, ";;");
+    std::string expected = "1;;2;;3";
+    std::string result = util::join({1, 2, 3}, ";;");
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 TEST(Join, delimiterChar)
 {
-	std::string expected = "1@2@3@4";
-	std::string result = util::join({1, 2, 3, 4}, '@');
+    std::string expected = "1@2@3@4";
+    std::string result = util::join({1, 2, 3, 4}, '@');
 
-	ASSERT_EQ(expected, result);
+    ASSERT_EQ(expected, result);
 }
 
 /* --------------------------------------------------------
@@ -297,20 +297,20 @@
 
 TEST(IsIdentifierValid, correct)
 {
-	ASSERT_TRUE(util::isIdentifierValid("localhost"));
-	ASSERT_TRUE(util::isIdentifierValid("localhost2"));
-	ASSERT_TRUE(util::isIdentifierValid("localhost2-4_"));
+    ASSERT_TRUE(util::isIdentifierValid("localhost"));
+    ASSERT_TRUE(util::isIdentifierValid("localhost2"));
+    ASSERT_TRUE(util::isIdentifierValid("localhost2-4_"));
 }
 
 TEST(IsIdentifierValid, incorrect)
 {
-	ASSERT_FALSE(util::isIdentifierValid(""));
-	ASSERT_FALSE(util::isIdentifierValid("localhost with spaces"));
-	ASSERT_FALSE(util::isIdentifierValid("localhost*"));
-	ASSERT_FALSE(util::isIdentifierValid("&&"));
-	ASSERT_FALSE(util::isIdentifierValid("@'"));
-	ASSERT_FALSE(util::isIdentifierValid("##"));
-	ASSERT_FALSE(util::isIdentifierValid("===++"));
+    ASSERT_FALSE(util::isIdentifierValid(""));
+    ASSERT_FALSE(util::isIdentifierValid("localhost with spaces"));
+    ASSERT_FALSE(util::isIdentifierValid("localhost*"));
+    ASSERT_FALSE(util::isIdentifierValid("&&"));
+    ASSERT_FALSE(util::isIdentifierValid("@'"));
+    ASSERT_FALSE(util::isIdentifierValid("##"));
+    ASSERT_FALSE(util::isIdentifierValid("===++"));
 }
 
 /* --------------------------------------------------------
@@ -319,34 +319,34 @@
 
 TEST(IsBoolean, correct)
 {
-	// true
-	ASSERT_TRUE(util::isBoolean("true"));
-	ASSERT_TRUE(util::isBoolean("True"));
-	ASSERT_TRUE(util::isBoolean("TRUE"));
-	ASSERT_TRUE(util::isBoolean("TruE"));
+    // true
+    ASSERT_TRUE(util::isBoolean("true"));
+    ASSERT_TRUE(util::isBoolean("True"));
+    ASSERT_TRUE(util::isBoolean("TRUE"));
+    ASSERT_TRUE(util::isBoolean("TruE"));
 
-	// yes
-	ASSERT_TRUE(util::isBoolean("yes"));
-	ASSERT_TRUE(util::isBoolean("Yes"));
-	ASSERT_TRUE(util::isBoolean("YES"));
-	ASSERT_TRUE(util::isBoolean("YeS"));
+    // yes
+    ASSERT_TRUE(util::isBoolean("yes"));
+    ASSERT_TRUE(util::isBoolean("Yes"));
+    ASSERT_TRUE(util::isBoolean("YES"));
+    ASSERT_TRUE(util::isBoolean("YeS"));
 
-	// on
-	ASSERT_TRUE(util::isBoolean("on"));
-	ASSERT_TRUE(util::isBoolean("On"));
-	ASSERT_TRUE(util::isBoolean("oN"));
-	ASSERT_TRUE(util::isBoolean("ON"));
+    // on
+    ASSERT_TRUE(util::isBoolean("on"));
+    ASSERT_TRUE(util::isBoolean("On"));
+    ASSERT_TRUE(util::isBoolean("oN"));
+    ASSERT_TRUE(util::isBoolean("ON"));
 
-	// 1
-	ASSERT_TRUE(util::isBoolean("1"));
+    // 1
+    ASSERT_TRUE(util::isBoolean("1"));
 }
 
 TEST(IsBoolean, incorrect)
 {
-	ASSERT_FALSE(util::isBoolean("false"));
-	ASSERT_FALSE(util::isBoolean("lol"));
-	ASSERT_FALSE(util::isBoolean(""));
-	ASSERT_FALSE(util::isBoolean("0"));
+    ASSERT_FALSE(util::isBoolean("false"));
+    ASSERT_FALSE(util::isBoolean("lol"));
+    ASSERT_FALSE(util::isBoolean(""));
+    ASSERT_FALSE(util::isBoolean("0"));
 }
 
 /* --------------------------------------------------------
@@ -355,15 +355,15 @@
 
 TEST(IsNumber, correct)
 {
-	ASSERT_TRUE(util::isNumber("123"));
-	ASSERT_TRUE(util::isNumber("-123"));
-	ASSERT_TRUE(util::isNumber("123.67"));
+    ASSERT_TRUE(util::isNumber("123"));
+    ASSERT_TRUE(util::isNumber("-123"));
+    ASSERT_TRUE(util::isNumber("123.67"));
 }
 
 TEST(IsNumber, incorrect)
 {
-	ASSERT_FALSE(util::isNumber("lol"));
-	ASSERT_FALSE(util::isNumber("this is not a number"));
+    ASSERT_FALSE(util::isNumber("lol"));
+    ASSERT_FALSE(util::isNumber("this is not a number"));
 }
 
 /*
@@ -373,46 +373,46 @@
 
 TEST(ToNumber, correct)
 {
-	/* unsigned */
-	ASSERT_EQ(50u, util::toNumber<std::uint8_t>("50"));
-	ASSERT_EQ(5000u, util::toNumber<std::uint16_t>("5000"));
-	ASSERT_EQ(50000u, util::toNumber<std::uint32_t>("50000"));
-	ASSERT_EQ(500000u, util::toNumber<std::uint64_t>("500000"));
+    /* unsigned */
+    ASSERT_EQ(50u, util::toNumber<std::uint8_t>("50"));
+    ASSERT_EQ(5000u, util::toNumber<std::uint16_t>("5000"));
+    ASSERT_EQ(50000u, util::toNumber<std::uint32_t>("50000"));
+    ASSERT_EQ(500000u, util::toNumber<std::uint64_t>("500000"));
 
-	/* signed */
-	ASSERT_EQ(-50, util::toNumber<std::int8_t>("-50"));
-	ASSERT_EQ(-500, util::toNumber<std::int16_t>("-500"));
-	ASSERT_EQ(-5000, util::toNumber<std::int32_t>("-5000"));
-	ASSERT_EQ(-50000, util::toNumber<std::int64_t>("-50000"));
+    /* signed */
+    ASSERT_EQ(-50, util::toNumber<std::int8_t>("-50"));
+    ASSERT_EQ(-500, util::toNumber<std::int16_t>("-500"));
+    ASSERT_EQ(-5000, util::toNumber<std::int32_t>("-5000"));
+    ASSERT_EQ(-50000, util::toNumber<std::int64_t>("-50000"));
 }
 
 TEST(ToNumber, incorrect)
 {
-	/* unsigned */
-	ASSERT_THROW(util::toNumber<std::uint8_t>("300"), std::out_of_range);
-	ASSERT_THROW(util::toNumber<std::uint16_t>("80000"), std::out_of_range);
-	ASSERT_THROW(util::toNumber<std::uint8_t>("-125"), std::out_of_range);
-	ASSERT_THROW(util::toNumber<std::uint16_t>("-25000"), std::out_of_range);
+    /* unsigned */
+    ASSERT_THROW(util::toNumber<std::uint8_t>("300"), std::out_of_range);
+    ASSERT_THROW(util::toNumber<std::uint16_t>("80000"), std::out_of_range);
+    ASSERT_THROW(util::toNumber<std::uint8_t>("-125"), std::out_of_range);
+    ASSERT_THROW(util::toNumber<std::uint16_t>("-25000"), std::out_of_range);
 
-	/* signed */
-	ASSERT_THROW(util::toNumber<std::int8_t>("300"), std::out_of_range);
-	ASSERT_THROW(util::toNumber<std::int16_t>("80000"), std::out_of_range);
-	ASSERT_THROW(util::toNumber<std::int8_t>("-300"), std::out_of_range);
-	ASSERT_THROW(util::toNumber<std::int16_t>("-80000"), std::out_of_range);
+    /* signed */
+    ASSERT_THROW(util::toNumber<std::int8_t>("300"), std::out_of_range);
+    ASSERT_THROW(util::toNumber<std::int16_t>("80000"), std::out_of_range);
+    ASSERT_THROW(util::toNumber<std::int8_t>("-300"), std::out_of_range);
+    ASSERT_THROW(util::toNumber<std::int16_t>("-80000"), std::out_of_range);
 
-	/* not numbers */
-	ASSERT_THROW(util::toNumber<std::uint8_t>("nonono"), std::invalid_argument);
+    /* not numbers */
+    ASSERT_THROW(util::toNumber<std::uint8_t>("nonono"), std::invalid_argument);
 
-	/* custom ranges */
-	ASSERT_THROW(util::toNumber<std::uint8_t>("50", 0, 10), std::out_of_range);
-	ASSERT_THROW(util::toNumber<std::int8_t>("-50", -10, 10), std::out_of_range);
+    /* custom ranges */
+    ASSERT_THROW(util::toNumber<std::uint8_t>("50", 0, 10), std::out_of_range);
+    ASSERT_THROW(util::toNumber<std::int8_t>("-50", -10, 10), std::out_of_range);
 }
 
 } // !irccd
 
 int main(int argc, char **argv)
 {
-	testing::InitGoogleTest(&argc, argv);
+    testing::InitGoogleTest(&argc, argv);
 
-	return RUN_ALL_TESTS();
+    return RUN_ALL_TESTS();
 }