Mercurial > irccd
view tests/util/main.cpp @ 312:a0180b5a150c
Tests: add test for plugin-config, #559
author | David Demelier <markand@malikania.fr> |
---|---|
date | Sat, 22 Oct 2016 15:56:01 +0200 |
parents | 6635b9187d71 |
children | c6fbb6e0e06d |
line wrap: on
line source
/* * main.cpp -- test util functions * * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr> * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include <cstdint> #include <gtest/gtest.h> #include <irccd/util.hpp> #include <irccd/system.hpp> namespace irccd { /* -------------------------------------------------------- * util::format function * -------------------------------------------------------- */ TEST(Format, nothing) { std::string expected = "hello world!"; std::string result = util::format("hello world!"); ASSERT_EQ(expected, result); } TEST(Format, escape) { util::Substitution params; 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")); } TEST(Format, disableDate) { util::Substitution params; params.flags &= ~(util::Substitution::Date); ASSERT_EQ("%H:%M", util::format("%H:%M", params)); } TEST(Format, disableKeywords) { util::Substitution params; params.keywords.emplace("target", "hello"); params.flags &= ~(util::Substitution::Keywords); ASSERT_EQ("#{target}", util::format("#{target}", params)); } TEST(Format, disableEnv) { util::Substitution params; params.flags &= ~(util::Substitution::Env); ASSERT_EQ("${HOME}", util::format("${HOME}", params)); } TEST(Format, keywordSimple) { util::Substitution params; params.keywords.insert({"target", "irccd"}); std::string expected = "hello irccd!"; std::string result = util::format("hello #{target}!", params); ASSERT_EQ(expected, result); } TEST(Format, keywordMultiple) { util::Substitution params; 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); ASSERT_EQ(expected, result); } TEST(Format, keywordAdjTwice) { util::Substitution params; params.keywords.insert({"target", "irccd"}); std::string expected = "hello irccdirccd!"; std::string result = util::format("hello #{target}#{target}!", params); ASSERT_EQ(expected, result); } TEST(Format, keywordMissing) { std::string expected = "hello !"; std::string result = util::format("hello #{target}!"); ASSERT_EQ(expected, result); } TEST(Format, envSimple) { 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}"); ASSERT_EQ(expected, result); } } TEST(Format, envMissing) { std::string expected = "value is "; std::string result = util::format("value is ${HOPE_THIS_VAR_NOT_EXIST}"); ASSERT_EQ(expected, result); } /* -------------------------------------------------------- * util::split function * -------------------------------------------------------- */ using List = std::vector<std::string>; TEST(Split, simple) { List expected { "a", "b" }; List result = util::split("a;b", ";"); ASSERT_EQ(expected, result); } TEST(Split, cut) { List expected { "msg", "#staff", "foo bar baz" }; List result = util::split("msg;#staff;foo bar baz", ";", 3); ASSERT_EQ(expected, result); } /* -------------------------------------------------------- * util::strip function * -------------------------------------------------------- */ TEST(Strip, left) { std::string value = " 123"; std::string result = util::strip(value); ASSERT_EQ("123", result); } TEST(Strip, right) { std::string value = "123 "; std::string result = util::strip(value); ASSERT_EQ("123", result); } TEST(Strip, both) { std::string value = " 123 "; std::string result = util::strip(value); ASSERT_EQ("123", result); } TEST(Strip, none) { std::string value = "without"; std::string result = util::strip(value); ASSERT_EQ("without", result); } TEST(Strip, betweenEmpty) { std::string value = "one list"; std::string result = util::strip(value); ASSERT_EQ("one list", result); } TEST(Strip, betweenLeft) { std::string value = " space at left"; std::string result = util::strip(value); ASSERT_EQ("space at left", result); } TEST(Strip, betweenRight) { std::string value = "space at right "; std::string result = util::strip(value); ASSERT_EQ("space at right", result); } TEST(Strip, betweenBoth) { std::string value = " space at both "; std::string result = util::strip(value); ASSERT_EQ("space at both", result); } TEST(Strip, empty) { std::string value = " "; std::string result = util::strip(value); ASSERT_EQ("", result); } /* -------------------------------------------------------- * util::join function * -------------------------------------------------------- */ TEST(Join, empty) { std::string expected = ""; std::string result = util::join<int>({}); ASSERT_EQ(expected, result); } TEST(Join, one) { std::string expected = "1"; std::string result = util::join({1}); ASSERT_EQ(expected, result); } TEST(Join, two) { std::string expected = "1:2"; std::string result = util::join({1, 2}); ASSERT_EQ(expected, result); } TEST(Join, delimiterString) { std::string expected = "1;;2;;3"; std::string result = util::join({1, 2, 3}, ";;"); ASSERT_EQ(expected, result); } TEST(Join, delimiterChar) { std::string expected = "1@2@3@4"; std::string result = util::join({1, 2, 3, 4}, '@'); ASSERT_EQ(expected, result); } /* -------------------------------------------------------- * util::isIdentifierValid function * -------------------------------------------------------- */ TEST(IsIdentifierValid, correct) { 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("===++")); } /* -------------------------------------------------------- * util::isBoolean function * -------------------------------------------------------- */ TEST(IsBoolean, correct) { // 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")); // 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")); } TEST(IsBoolean, incorrect) { ASSERT_FALSE(util::isBoolean("false")); ASSERT_FALSE(util::isBoolean("lol")); ASSERT_FALSE(util::isBoolean("")); ASSERT_FALSE(util::isBoolean("0")); } /* -------------------------------------------------------- * util::isNumber function * -------------------------------------------------------- */ TEST(IsNumber, correct) { 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")); } /* * util::toNumber function * ------------------------------------------------------------------ */ 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")); /* 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); /* 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); /* 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); return RUN_ALL_TESTS(); }