Line data Source code
1 : /**
2 : * @file UtilsTests.cpp
3 : * @copyright (c) 2014 by Petr Zemek (s3rvac@gmail.com) and contributors
4 : * @license BSD, see the @c LICENSE file for more details
5 : * @brief Tests for the utilities.
6 : */
7 :
8 : #include <gtest/gtest.h>
9 :
10 : #include "TestUtils.h"
11 : #include "Utils.h"
12 :
13 : namespace bencoding {
14 : namespace tests {
15 :
16 : using namespace testing;
17 :
18 46 : class UtilsTests: public Test {};
19 :
20 : //
21 : // strToNum()
22 : //
23 :
24 5 : TEST_F(UtilsTests,
25 : StrToNumWithValidDecimalIntegerSucceeds) {
26 1 : int num = 0;
27 1 : EXPECT_TRUE(strToNum("-1000", num, std::dec));
28 1 : EXPECT_EQ(-1000, num);
29 :
30 1 : num = 0;
31 1 : EXPECT_TRUE(strToNum("-1", num, std::dec));
32 1 : EXPECT_EQ(-1, num);
33 :
34 1 : num = 0;
35 1 : EXPECT_TRUE(strToNum("0", num, std::dec));
36 1 : EXPECT_EQ(0, num);
37 :
38 1 : num = 0;
39 1 : EXPECT_TRUE(strToNum("1", num, std::dec));
40 1 : EXPECT_EQ(1, num);
41 :
42 1 : num = 0;
43 1 : EXPECT_TRUE(strToNum("1000", num, std::dec));
44 1 : EXPECT_EQ(1000, num);
45 :
46 1 : num = 0;
47 1 : EXPECT_TRUE(strToNum("0000", num, std::dec));
48 1 : EXPECT_EQ(0, num);
49 :
50 1 : num = 0;
51 1 : EXPECT_TRUE(strToNum("0003", num, std::dec));
52 1 : EXPECT_EQ(3, num);
53 1 : }
54 :
55 5 : TEST_F(UtilsTests,
56 : StrToNumWithInvalidDecimalIntegerFails) {
57 1 : int num = -1;
58 1 : EXPECT_FALSE(strToNum("", num, std::dec));
59 1 : EXPECT_EQ(-1, num);
60 :
61 1 : num = -1;
62 1 : EXPECT_FALSE(strToNum("zzz", num, std::dec));
63 1 : EXPECT_EQ(-1, num);
64 :
65 1 : num = -1;
66 1 : EXPECT_FALSE(strToNum("13 something", num, std::dec));
67 1 : EXPECT_EQ(-1, num);
68 :
69 1 : num = -1;
70 1 : EXPECT_FALSE(strToNum("13something", num, std::dec));
71 1 : EXPECT_EQ(-1, num);
72 1 : }
73 :
74 5 : TEST_F(UtilsTests,
75 : StrToNumWithValidHexadecimalIntegerSucceeds) {
76 1 : int num = 0;
77 1 : EXPECT_TRUE(strToNum("-0x3E8", num, std::hex));
78 1 : EXPECT_EQ(-0x3E8, num);
79 :
80 1 : num = 0;
81 1 : EXPECT_TRUE(strToNum("-0x1", num, std::hex));
82 1 : EXPECT_EQ(-0x1, num);
83 :
84 1 : num = 0;
85 1 : EXPECT_TRUE(strToNum("0x0", num, std::hex));
86 1 : EXPECT_EQ(0x0, num);
87 :
88 1 : num = 0;
89 1 : EXPECT_TRUE(strToNum("0x1", num, std::hex));
90 1 : EXPECT_EQ(0x1, num);
91 :
92 1 : num = 0;
93 1 : EXPECT_TRUE(strToNum("0x3E8", num, std::hex));
94 1 : EXPECT_EQ(0x3E8, num);
95 :
96 1 : num = 0;
97 1 : EXPECT_TRUE(strToNum("0x00C", num, std::hex));
98 1 : EXPECT_EQ(0x00C, num);
99 1 : }
100 :
101 5 : TEST_F(UtilsTests,
102 : StrToNumWithInvalidHexadecimalIntegerFails) {
103 1 : int num = -1;
104 1 : EXPECT_FALSE(strToNum("", num, std::hex));
105 1 : EXPECT_EQ(-1, num);
106 :
107 1 : num = -1;
108 1 : EXPECT_FALSE(strToNum("0x", num, std::hex));
109 1 : EXPECT_EQ(-1, num);
110 :
111 1 : num = -1;
112 1 : EXPECT_FALSE(strToNum("zz", num, std::hex));
113 1 : EXPECT_EQ(-1, num);
114 :
115 1 : num = -1;
116 1 : EXPECT_FALSE(strToNum("0xC something", num, std::hex));
117 1 : EXPECT_EQ(-1, num);
118 :
119 1 : num = -1;
120 1 : EXPECT_FALSE(strToNum("0xCsomething", num, std::hex));
121 1 : EXPECT_EQ(-1, num);
122 1 : }
123 :
124 : //
125 : // readUpTo()
126 : //
127 :
128 5 : TEST_F(UtilsTests,
129 : ReadUpToReadsCorrectlyAllCharactersUpToSentinel) {
130 2 : std::istringstream input("abcd$");
131 2 : std::string readData;
132 :
133 1 : bool dataReadCorrectly = readUpTo(input, readData, '$');
134 1 : ASSERT_TRUE(dataReadCorrectly);
135 1 : EXPECT_EQ(readData, "abcd");
136 : }
137 :
138 5 : TEST_F(UtilsTests,
139 : ReadUpToReturnsFalseWhenSentinelIsNotFound) {
140 2 : std::istringstream input("abcd");
141 2 : std::string readData;
142 :
143 1 : bool dataReadCorrectly = readUpTo(input, readData, '$');
144 1 : EXPECT_FALSE(dataReadCorrectly);
145 1 : }
146 :
147 5 : TEST_F(UtilsTests,
148 : ReadUpToStoresReadCharsEvenWhenSentinelIsNotFound) {
149 2 : std::istringstream input("abcd");
150 2 : std::string readData;
151 :
152 1 : readUpTo(input, readData, '$');
153 1 : EXPECT_EQ("abcd", readData);
154 1 : }
155 :
156 5 : TEST_F(UtilsTests,
157 : ReadUpToReturnsFalseWhenInputIsInError) {
158 2 : std::istringstream input("abcd$");
159 2 : std::string readData;
160 :
161 1 : putIntoErrorState(input);
162 1 : EXPECT_FALSE(readUpTo(input, readData, '$'));
163 1 : }
164 :
165 5 : TEST_F(UtilsTests,
166 : ReadUpToDoesNotReadAnyDataWhenInputIsInError) {
167 2 : std::istringstream input("abc$");
168 2 : std::string readData;
169 :
170 1 : putIntoErrorState(input);
171 1 : readUpTo(input, readData, '$');
172 1 : EXPECT_EQ("", readData);
173 1 : }
174 :
175 5 : TEST_F(UtilsTests,
176 : ReadUpToReturnsFalseWhenInputIsAtEOF) {
177 2 : std::istringstream input("abcd$");
178 2 : std::string readData;
179 :
180 1 : putIntoEOFState(input);
181 1 : EXPECT_FALSE(readUpTo(input, readData, '$'));
182 1 : }
183 :
184 5 : TEST_F(UtilsTests,
185 : ReadUpToDoesNotReadAnyDataWhenInputIsAtEOF) {
186 2 : std::istringstream input("abcd$");
187 2 : std::string readData;
188 :
189 1 : putIntoEOFState(input);
190 1 : readUpTo(input, readData, '$');
191 1 : EXPECT_EQ("", readData);
192 1 : }
193 :
194 : //
195 : // readUntil()
196 : //
197 :
198 5 : TEST_F(UtilsTests,
199 : ReadUntilReadsCorrectlyAllCharactersIncludingLast) {
200 2 : std::istringstream input("abcd$");
201 2 : std::string readData;
202 :
203 1 : bool dataReadCorrectly = readUntil(input, readData, '$');
204 1 : ASSERT_TRUE(dataReadCorrectly);
205 1 : EXPECT_EQ(readData, "abcd$");
206 : }
207 :
208 5 : TEST_F(UtilsTests,
209 : ReadUntilToReturnsFalseWhenLastIsNotFound) {
210 2 : std::istringstream input("abcd");
211 2 : std::string readData;
212 :
213 1 : bool dataReadCorrectly = readUntil(input, readData, '$');
214 1 : EXPECT_FALSE(dataReadCorrectly);
215 1 : }
216 :
217 5 : TEST_F(UtilsTests,
218 : ReadUntilStoresReadCharsEvenWhenLastIsNotFound) {
219 2 : std::istringstream input("abcd");
220 2 : std::string readData;
221 :
222 1 : readUntil(input, readData, '$');
223 1 : EXPECT_EQ("abcd", readData);
224 1 : }
225 :
226 5 : TEST_F(UtilsTests,
227 : ReadUntilDoesNotReadAnyDataWhenInputIsInError) {
228 2 : std::istringstream input("abcd$");
229 2 : std::string readData;
230 :
231 1 : putIntoErrorState(input);
232 1 : readUntil(input, readData, '$');
233 1 : EXPECT_EQ("", readData);
234 1 : }
235 :
236 5 : TEST_F(UtilsTests,
237 : ReadUntilReturnsFalseWhenInputIsAtEOF) {
238 2 : std::istringstream input("abc$");
239 2 : std::string readData;
240 :
241 1 : putIntoEOFState(input);
242 1 : EXPECT_FALSE(readUntil(input, readData, '$'));
243 1 : }
244 :
245 5 : TEST_F(UtilsTests,
246 : ReadUntilDoesNotReadAnyDataWhenInputIsAtEOF) {
247 2 : std::istringstream input("abcd$");
248 2 : std::string readData;
249 :
250 1 : putIntoEOFState(input);
251 1 : readUntil(input, readData, '$');
252 1 : EXPECT_EQ("", readData);
253 1 : }
254 :
255 : //
256 : // replace()
257 : //
258 :
259 5 : TEST_F(UtilsTests,
260 : ReplaceDoesNotPerformAnyReplacementWhenStringIsEmpty) {
261 1 : EXPECT_EQ("", replace("", 'x', "X"));
262 1 : }
263 :
264 5 : TEST_F(UtilsTests,
265 : ReplaceDoesNotPerformAnyReplacementWhenCharDoesNotAppearInString) {
266 1 : EXPECT_EQ("abcd", replace("abcd", 'x', "X"));
267 1 : }
268 :
269 5 : TEST_F(UtilsTests,
270 : ReplaceCorrectlyReplacesCharInStringIfItOccursOnce) {
271 1 : EXPECT_EQ("Abcd", replace("abcd", 'a', "A"));
272 1 : }
273 :
274 5 : TEST_F(UtilsTests,
275 : ReplaceCorrectlyReplacesCharInStringIfItOccursTwice) {
276 1 : EXPECT_EQ("AbcA", replace("abca", 'a', "A"));
277 1 : }
278 :
279 5 : TEST_F(UtilsTests,
280 : ReplaceCorrectlyReplacesCharInStringWhenWithWhatIsLongerThanOneChar) {
281 1 : EXPECT_EQ("XXXXbcXXXX", replace("abca", 'a', "XXXX"));
282 1 : }
283 :
284 5 : TEST_F(UtilsTests,
285 : ReplaceDeletesCharsInStringWhenWithWhatIsEmpty) {
286 1 : EXPECT_EQ("bc", replace("abca", 'a', ""));
287 1 : }
288 :
289 : } // namespace tests
290 3 : } // namespace bencoding
|
