Mercurial > irccd
annotate tests/util/main.cpp @ 75:f8160d515a76
Irccd: rework a lot the JavaScript library
| author | David Demelier <markand@malikania.fr> |
|---|---|
| date | Wed, 30 Mar 2016 13:52:47 +0200 |
| parents | 1158cffe5a5e |
| children | 1125d90b3b44 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 * main.cpp -- test util functions | |
| 3 * | |
| 4 * Copyright (c) 2013-2016 David Demelier <markand@malikania.fr> | |
| 5 * | |
| 6 * Permission to use, copy, modify, and/or distribute this software for any | |
| 7 * purpose with or without fee is hereby granted, provided that the above | |
| 8 * copyright notice and this permission notice appear in all copies. | |
| 9 * | |
| 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
| 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
| 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
| 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
| 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
| 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
| 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
| 17 */ | |
| 18 | |
| 19 #include <gtest/gtest.h> | |
| 20 | |
|
75
f8160d515a76
Irccd: rework a lot the JavaScript library
David Demelier <markand@malikania.fr>
parents:
0
diff
changeset
|
21 #include <irccd/util.h> |
|
f8160d515a76
Irccd: rework a lot the JavaScript library
David Demelier <markand@malikania.fr>
parents:
0
diff
changeset
|
22 #include <irccd/system.h> |
| 0 | 23 |
| 24 namespace irccd { | |
| 25 | |
| 26 /* -------------------------------------------------------- | |
| 27 * util::format function | |
| 28 * -------------------------------------------------------- */ | |
| 29 | |
| 30 TEST(Format, nothing) | |
| 31 { | |
| 32 std::string expected = "hello world!"; | |
| 33 std::string result = util::format("hello world!"); | |
| 34 | |
| 35 ASSERT_EQ(expected, result); | |
| 36 } | |
| 37 | |
| 38 TEST(Format, keywordSimple) | |
| 39 { | |
| 40 util::Substitution params; | |
| 41 | |
| 42 params.keywords.insert({"target", "irccd"}); | |
| 43 | |
| 44 std::string expected = "hello irccd!"; | |
| 45 std::string result = util::format("hello #{target}!", params); | |
| 46 | |
| 47 ASSERT_EQ(expected, result); | |
| 48 } | |
| 49 | |
| 50 TEST(Format, keywordMultiple) | |
| 51 { | |
| 52 util::Substitution params; | |
| 53 | |
| 54 params.keywords.insert({"target", "irccd"}); | |
| 55 params.keywords.insert({"source", "nightmare"}); | |
| 56 | |
| 57 std::string expected = "hello irccd from nightmare!"; | |
| 58 std::string result = util::format("hello #{target} from #{source}!", params); | |
| 59 | |
| 60 ASSERT_EQ(expected, result); | |
| 61 } | |
| 62 | |
| 63 TEST(Format, keywordAdjTwice) | |
| 64 { | |
| 65 util::Substitution params; | |
| 66 | |
| 67 params.keywords.insert({"target", "irccd"}); | |
| 68 | |
| 69 std::string expected = "hello irccdirccd!"; | |
| 70 std::string result = util::format("hello #{target}#{target}!", params); | |
| 71 | |
| 72 ASSERT_EQ(expected, result); | |
| 73 } | |
| 74 | |
| 75 TEST(Format, keywordMissing) | |
| 76 { | |
| 77 std::string expected = "hello !"; | |
| 78 std::string result = util::format("hello #{target}!"); | |
| 79 | |
| 80 ASSERT_EQ(expected, result); | |
| 81 } | |
| 82 | |
| 83 TEST(Format, envSimple) | |
| 84 { | |
| 85 std::string home = sys::env("HOME"); | |
| 86 | |
| 87 if (!home.empty()) { | |
| 88 std::string expected = "my home is " + home; | |
| 89 std::string result = util::format("my home is ${HOME}"); | |
| 90 | |
| 91 ASSERT_EQ(expected, result); | |
| 92 } | |
| 93 } | |
| 94 | |
| 95 TEST(Format, envMissing) | |
| 96 { | |
| 97 std::string expected = "value is "; | |
| 98 std::string result = util::format("value is ${HOPE_THIS_VAR_NOT_EXIST}"); | |
| 99 | |
| 100 ASSERT_EQ(expected, result); | |
| 101 } | |
| 102 | |
| 103 /* -------------------------------------------------------- | |
| 104 * util::split function | |
| 105 * -------------------------------------------------------- */ | |
| 106 | |
| 107 using List = std::vector<std::string>; | |
| 108 | |
| 109 TEST(Split, simple) | |
| 110 { | |
| 111 List expected { "a", "b" }; | |
| 112 List result = util::split("a;b", ";"); | |
| 113 | |
| 114 ASSERT_EQ(expected, result); | |
| 115 } | |
| 116 | |
| 117 TEST(Split, cut) | |
| 118 { | |
| 119 List expected { "msg", "#staff", "foo bar baz" }; | |
| 120 List result = util::split("msg;#staff;foo bar baz", ";", 3); | |
| 121 | |
| 122 ASSERT_EQ(expected, result); | |
| 123 } | |
| 124 | |
| 125 /* -------------------------------------------------------- | |
| 126 * util::strip function | |
| 127 * -------------------------------------------------------- */ | |
| 128 | |
| 129 TEST(Strip, left) | |
| 130 { | |
| 131 std::string value = " 123"; | |
| 132 std::string result = util::strip(value); | |
| 133 | |
| 134 ASSERT_EQ("123", result); | |
| 135 } | |
| 136 | |
| 137 TEST(Strip, right) | |
| 138 { | |
| 139 std::string value = "123 "; | |
| 140 std::string result = util::strip(value); | |
| 141 | |
| 142 ASSERT_EQ("123", result); | |
| 143 } | |
| 144 | |
| 145 TEST(Strip, both) | |
| 146 { | |
| 147 std::string value = " 123 "; | |
| 148 std::string result = util::strip(value); | |
| 149 | |
| 150 ASSERT_EQ("123", result); | |
| 151 } | |
| 152 | |
| 153 TEST(Strip, none) | |
| 154 { | |
| 155 std::string value = "without"; | |
| 156 std::string result = util::strip(value); | |
| 157 | |
| 158 ASSERT_EQ("without", result); | |
| 159 } | |
| 160 | |
| 161 TEST(Strip, betweenEmpty) | |
| 162 { | |
| 163 std::string value = "one list"; | |
| 164 std::string result = util::strip(value); | |
| 165 | |
| 166 ASSERT_EQ("one list", result); | |
| 167 } | |
| 168 | |
| 169 TEST(Strip, betweenLeft) | |
| 170 { | |
| 171 std::string value = " space at left"; | |
| 172 std::string result = util::strip(value); | |
| 173 | |
| 174 ASSERT_EQ("space at left", result); | |
| 175 } | |
| 176 | |
| 177 TEST(Strip, betweenRight) | |
| 178 { | |
| 179 std::string value = "space at right "; | |
| 180 std::string result = util::strip(value); | |
| 181 | |
| 182 ASSERT_EQ("space at right", result); | |
| 183 } | |
| 184 | |
| 185 TEST(Strip, betweenBoth) | |
| 186 { | |
| 187 std::string value = " space at both "; | |
| 188 std::string result = util::strip(value); | |
| 189 | |
| 190 ASSERT_EQ("space at both", result); | |
| 191 } | |
| 192 | |
| 193 TEST(Strip, empty) | |
| 194 { | |
| 195 std::string value = " "; | |
| 196 std::string result = util::strip(value); | |
| 197 | |
| 198 ASSERT_EQ("", result); | |
| 199 } | |
| 200 | |
| 201 /* -------------------------------------------------------- | |
| 202 * util::join function | |
| 203 * -------------------------------------------------------- */ | |
| 204 | |
| 205 TEST(Join, empty) | |
| 206 { | |
| 207 std::string expected = ""; | |
| 208 std::string result = util::join<int>({}); | |
| 209 | |
| 210 ASSERT_EQ(expected, result); | |
| 211 } | |
| 212 | |
| 213 TEST(Join, one) | |
| 214 { | |
| 215 std::string expected = "1"; | |
| 216 std::string result = util::join({1}); | |
| 217 | |
| 218 ASSERT_EQ(expected, result); | |
| 219 } | |
| 220 | |
| 221 TEST(Join, two) | |
| 222 { | |
| 223 std::string expected = "1:2"; | |
| 224 std::string result = util::join({1, 2}); | |
| 225 | |
| 226 ASSERT_EQ(expected, result); | |
| 227 } | |
| 228 | |
| 229 TEST(Join, delimiterString) | |
| 230 { | |
| 231 std::string expected = "1;;2;;3"; | |
| 232 std::string result = util::join({1, 2, 3}, ";;"); | |
| 233 | |
| 234 ASSERT_EQ(expected, result); | |
| 235 } | |
| 236 | |
| 237 TEST(Join, delimiterChar) | |
| 238 { | |
| 239 std::string expected = "1@2@3@4"; | |
| 240 std::string result = util::join({1, 2, 3, 4}, '@'); | |
| 241 | |
| 242 ASSERT_EQ(expected, result); | |
| 243 } | |
| 244 | |
| 245 /* -------------------------------------------------------- | |
| 246 * util::isIdentifierValid function | |
| 247 * -------------------------------------------------------- */ | |
| 248 | |
| 249 TEST(IsIdentifierValid, correct) | |
| 250 { | |
| 251 ASSERT_TRUE(util::isIdentifierValid("localhost")); | |
| 252 ASSERT_TRUE(util::isIdentifierValid("localhost2")); | |
| 253 ASSERT_TRUE(util::isIdentifierValid("localhost2-4_")); | |
| 254 } | |
| 255 | |
| 256 TEST(IsIdentifierValid, incorrect) | |
| 257 { | |
| 258 ASSERT_FALSE(util::isIdentifierValid("")); | |
| 259 ASSERT_FALSE(util::isIdentifierValid("localhost with spaces")); | |
| 260 ASSERT_FALSE(util::isIdentifierValid("localhost*")); | |
| 261 ASSERT_FALSE(util::isIdentifierValid("&&")); | |
| 262 ASSERT_FALSE(util::isIdentifierValid("@'")); | |
| 263 ASSERT_FALSE(util::isIdentifierValid("##")); | |
| 264 ASSERT_FALSE(util::isIdentifierValid("===++")); | |
| 265 } | |
| 266 | |
| 267 /* -------------------------------------------------------- | |
| 268 * util::isBoolean function | |
| 269 * -------------------------------------------------------- */ | |
| 270 | |
| 271 TEST(IsBoolean, correct) | |
| 272 { | |
| 273 // true | |
| 274 ASSERT_TRUE(util::isBoolean("true")); | |
| 275 ASSERT_TRUE(util::isBoolean("True")); | |
| 276 ASSERT_TRUE(util::isBoolean("TRUE")); | |
| 277 ASSERT_TRUE(util::isBoolean("TruE")); | |
| 278 | |
| 279 // yes | |
| 280 ASSERT_TRUE(util::isBoolean("yes")); | |
| 281 ASSERT_TRUE(util::isBoolean("Yes")); | |
| 282 ASSERT_TRUE(util::isBoolean("YES")); | |
| 283 ASSERT_TRUE(util::isBoolean("YeS")); | |
| 284 | |
| 285 // on | |
| 286 ASSERT_TRUE(util::isBoolean("on")); | |
| 287 ASSERT_TRUE(util::isBoolean("On")); | |
| 288 ASSERT_TRUE(util::isBoolean("oN")); | |
| 289 ASSERT_TRUE(util::isBoolean("ON")); | |
| 290 | |
| 291 // 1 | |
| 292 ASSERT_TRUE(util::isBoolean("1")); | |
| 293 } | |
| 294 | |
| 295 TEST(IsBoolean, incorrect) | |
| 296 { | |
| 297 ASSERT_FALSE(util::isBoolean("false")); | |
| 298 ASSERT_FALSE(util::isBoolean("lol")); | |
| 299 ASSERT_FALSE(util::isBoolean("")); | |
| 300 ASSERT_FALSE(util::isBoolean("0")); | |
| 301 } | |
| 302 | |
| 303 /* -------------------------------------------------------- | |
| 304 * util::isNumber function | |
| 305 * -------------------------------------------------------- */ | |
| 306 | |
| 307 TEST(IsNumber, correct) | |
| 308 { | |
| 309 ASSERT_TRUE(util::isNumber("123")); | |
| 310 ASSERT_TRUE(util::isNumber("-123")); | |
| 311 ASSERT_TRUE(util::isNumber("123.67")); | |
| 312 } | |
| 313 | |
| 314 TEST(IsNumber, incorrect) | |
| 315 { | |
| 316 ASSERT_FALSE(util::isNumber("lol")); | |
| 317 ASSERT_FALSE(util::isNumber("this is not a number")); | |
| 318 } | |
| 319 | |
| 320 } // !irccd | |
| 321 | |
| 322 int main(int argc, char **argv) | |
| 323 { | |
| 324 testing::InitGoogleTest(&argc, argv); | |
| 325 | |
| 326 return RUN_ALL_TESTS(); | |
| 327 } |