Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/tests/connectionstringparser_ut/connectionstringparser_ut.c

raw
1 // Copyright (c) Microsoft. All rights reserved.
2 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
4 #ifdef __cplusplus
5 #include <cstdlib>
6 #else
7 #include <stdlib.h>
8 #endif
9
10 #include "azure_macro_utils/macro_utils.h"
11
12 static void* my_gballoc_malloc(size_t size)
13 {
14 return malloc(size);
15 }
16
17 static void my_gballoc_free(void* s)
18 {
19 free(s);
20 }
21
22 void* my_gballoc_realloc(void* ptr, size_t size)
23 {
24 return realloc(ptr, size);
25 }
26
27 #include "azure_c_shared_utility/crt_abstractions.h"
28
29 #include "testrunnerswitcher.h"
30 #include "umock_c/umock_c.h"
31 #include "umock_c/umocktypes_charptr.h"
32 #include "umock_c/umocktypes_bool.h"
33 #include "umock_c/umocktypes_stdint.h"
34 #include "umock_c/umock_c_negative_tests.h"
35
36 #define ENABLE_MOCKS
37 #include "azure_c_shared_utility/gballoc.h"
38 #include "azure_c_shared_utility/map.h"
39 #include "azure_c_shared_utility/string_tokenizer.h"
40 #include "azure_c_shared_utility/strings.h"
41 #include "azure_c_shared_utility/optimize_size.h"
42 #include "azure_c_shared_utility/xlogging.h"
43 #undef ENABLE_MOCKS
44
45 #include "azure_c_shared_utility/connection_string_parser.h"
46
47 #include "real_map.h"
48 #include "real_string_tokenizer.h"
49 #include "real_strings.h"
50
51 IMPLEMENT_UMOCK_C_ENUM_TYPE(MAP_RESULT, MAP_RESULT_VALUES);
52
53 static TEST_MUTEX_HANDLE g_testByTest;
54
55 static const char* TEST_STRING_PAIR = "key1=value1";
56 STRING_HANDLE TEST_STRING_HANDLE_PAIR;
57 static const char* TEST_STRING_KEY = "key1=";
58 STRING_HANDLE TEST_STRING_HANDLE_KEY;
59 static const char* TEST_STRING_2_PAIR = "key1=value1;key2=value2";
60 STRING_HANDLE TEST_STRING_HANDLE_2_PAIR;
61 static const char* TEST_STRING_2_PAIR_SEMICOLON = "key1=value1;key2=value2;";
62 STRING_HANDLE TEST_STRING_HANDLE_2_PAIR_SEMICOLON;
63
64 MU_DEFINE_ENUM_STRINGS(UMOCK_C_ERROR_CODE, UMOCK_C_ERROR_CODE_VALUES)
65
66 static void on_umock_c_error(UMOCK_C_ERROR_CODE error_code)
67 {
68 ASSERT_FAIL("umock_c reported error :%" PRI_MU_ENUM "", MU_ENUM_VALUE(UMOCK_C_ERROR_CODE, error_code));
69 }
70
71 BEGIN_TEST_SUITE(connectionstringparser_ut)
72
73 TEST_SUITE_INITIALIZE(suite_init)
74 {
75 int result;
76
77 g_testByTest = TEST_MUTEX_CREATE();
78 ASSERT_IS_NOT_NULL(g_testByTest);
79
80 umock_c_init(on_umock_c_error);
81
82 result = umocktypes_charptr_register_types();
83 ASSERT_ARE_EQUAL(int, 0, result);
84 result = umocktypes_charptr_register_types();
85 ASSERT_ARE_EQUAL(int, 0, result);
86 result = umocktypes_stdint_register_types();
87 ASSERT_ARE_EQUAL(int, 0, result);
88
89 REGISTER_TYPE(MAP_RESULT, MAP_RESULT);
90 REGISTER_UMOCK_ALIAS_TYPE(STRING_TOKENIZER_HANDLE, void*);
91 REGISTER_UMOCK_ALIAS_TYPE(STRING_HANDLE, void*);
92 REGISTER_UMOCK_ALIAS_TYPE(MAP_FILTER_CALLBACK, void*);
93 REGISTER_UMOCK_ALIAS_TYPE(MAP_HANDLE, void*);
94 REGISTER_UMOCK_ALIAS_TYPE(STRING_HANDLE, void*);
95
96 REGISTER_GLOBAL_MOCK_HOOK(gballoc_malloc, my_gballoc_malloc);
97 REGISTER_GLOBAL_MOCK_HOOK(gballoc_realloc, my_gballoc_realloc);
98 REGISTER_GLOBAL_MOCK_HOOK(gballoc_free, my_gballoc_free);
99
100 REGISTER_STRING_GLOBAL_MOCK_HOOK;
101 REGISTER_STRING_TOKENIZER_GLOBAL_MOCK_HOOK;
102 REGISTER_MAP_GLOBAL_MOCK_HOOK;
103
104 TEST_STRING_HANDLE_PAIR = STRING_construct(TEST_STRING_PAIR);
105 TEST_STRING_HANDLE_KEY = STRING_construct(TEST_STRING_KEY);
106 TEST_STRING_HANDLE_2_PAIR = STRING_construct(TEST_STRING_2_PAIR);
107 TEST_STRING_HANDLE_2_PAIR_SEMICOLON = STRING_construct(TEST_STRING_2_PAIR_SEMICOLON);
108 }
109
110 TEST_SUITE_CLEANUP(TestClassCleanup)
111 {
112 STRING_delete(TEST_STRING_HANDLE_PAIR);
113 STRING_delete(TEST_STRING_HANDLE_KEY);
114 STRING_delete(TEST_STRING_HANDLE_2_PAIR);
115 STRING_delete(TEST_STRING_HANDLE_2_PAIR_SEMICOLON);
116
117 umock_c_deinit();
118
119 TEST_MUTEX_DESTROY(g_testByTest);
120 }
121
122 TEST_FUNCTION_INITIALIZE(TestMethodInitialize)
123 {
124 if (TEST_MUTEX_ACQUIRE(g_testByTest))
125 {
126 ASSERT_FAIL("Could not acquire test serialization mutex.");
127 }
128
129 umock_c_reset_all_calls();
130 }
131
132 TEST_FUNCTION_CLEANUP(TestMethodCleanup)
133 {
134 TEST_MUTEX_RELEASE(g_testByTest);
135 }
136
137 /* connectionstringparser_parse */
138
139 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_001: [connectionstringparser_parse shall parse all key value pairs from the connection_string passed in as argument and return a new map that holds the key/value pairs.] */
140 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_003: [connectionstringparser_parse shall create a STRING tokenizer to be used for parsing the connection string, by calling STRING_TOKENIZER_create.] */
141 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_004: [connectionstringparser_parse shall start scanning at the beginning of the connection string.] */
142 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_016: [2 STRINGs shall be allocated in order to hold the to be parsed key and value tokens.] */
143 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_005: [The following actions shall be repeated until parsing is complete:] */
144 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_006: [connectionstringparser_parse shall find a token (the key of the key/value pair) delimited by the "=" character, by calling STRING_TOKENIZER_get_next_token.] */
145 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_007: [If STRING_TOKENIZER_get_next_token fails, parsing shall be considered complete.] */
146 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_014: [After the parsing is complete the previously allocated STRINGs and STRING tokenizer shall be freed by calling STRING_TOKENIZER_destroy.] */
147 TEST_FUNCTION(connectionstringparser_parse_with_an_empty_string_yields_an_empty_map)
148 {
149 // arrange
150 MAP_HANDLE result;
151 STRING_HANDLE connectionString = STRING_new();
152 STRING_HANDLE key = STRING_new();
153 STRING_HANDLE value = STRING_new();
154 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(connectionString);
155
156 umock_c_reset_all_calls();
157 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(connectionString)).SetReturn(tokens);
158 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(key);
159 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(value);
160 STRICT_EXPECTED_CALL(Map_Create(NULL));
161 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
162 STRICT_EXPECTED_CALL(STRING_delete(value));
163 STRICT_EXPECTED_CALL(STRING_delete(key));
164 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(tokens));
165
166 // act
167 result = connectionstringparser_parse(connectionString);
168
169 // assert
170 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, result);
171 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
172
173 // cleanup
174 STRING_delete(connectionString);
175 Map_Destroy(result);
176 }
177
178 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_002: [If connection_string is NULL then connectionstringparser_parse shall fail and return NULL.] */
179 TEST_FUNCTION(connectionstringparser_parse_with_NULL_connection_string_fails)
180 {
181 // arrange
182
183 // act
184 MAP_HANDLE result = connectionstringparser_parse(NULL);
185
186 // assert
187 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
188 }
189
190 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_015: [If STRING_TOKENIZER_create fails, connectionstringparser_parse shall fail and return NULL.] */
191 TEST_FUNCTION(when_creating_the_string_tokenizer_fails_then_connectionstringparser_fails)
192 {
193 // arrange
194 MAP_HANDLE result;
195 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR))
196 .SetReturn((STRING_TOKENIZER_HANDLE)NULL);
197
198 // act
199 result = connectionstringparser_parse(TEST_STRING_HANDLE_PAIR);
200
201 // assert
202 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
203
204 // cleanup
205 }
206
207 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_017: [If allocating the STRINGs fails connectionstringparser_parse shall fail and return NULL.] */
208 TEST_FUNCTION(when_allocating_the_key_token_string_fails_then_connectionstringparser_fails)
209 {
210 // arrange
211 MAP_HANDLE result;
212 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR);
213
214 umock_c_reset_all_calls();
215 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR)).SetReturn(tokens);
216 STRICT_EXPECTED_CALL(STRING_new()).SetReturn((STRING_HANDLE)NULL);
217 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(tokens));
218
219 // act
220 result = connectionstringparser_parse(TEST_STRING_HANDLE_PAIR);
221
222 // assert
223 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
224 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
225
226 // cleanup
227 }
228
229 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_017: [If allocating the STRINGs fails connectionstringparser_parse shall fail and return NULL.] */
230 TEST_FUNCTION(when_allocating_the_value_token_string_fails_then_connectionstringparser_fails)
231 {
232 // arrange
233 MAP_HANDLE result;
234 STRING_HANDLE key = STRING_new();
235 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR);
236
237 umock_c_reset_all_calls();
238 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR)).SetReturn(tokens);
239 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(key);
240 STRICT_EXPECTED_CALL(STRING_new()).SetReturn((STRING_HANDLE)NULL);
241 STRICT_EXPECTED_CALL(STRING_delete(key));
242 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(tokens));
243
244 // act
245 result = connectionstringparser_parse(TEST_STRING_HANDLE_PAIR);
246
247 // assert
248 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
249 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
250
251 // cleanup
252 }
253
254 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_018: [If creating the result map fails, then connectionstringparser_parse shall return NULL.] */
255 TEST_FUNCTION(when_allocating_the_result_map_fails_then_connectionstringparser_fails)
256 {
257 // arrange
258 MAP_HANDLE result;
259 STRING_HANDLE key = STRING_new();
260 STRING_HANDLE value = STRING_new();
261 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR);
262
263 umock_c_reset_all_calls();
264 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR)).SetReturn(tokens);
265 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(key);
266 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(value);
267 STRICT_EXPECTED_CALL(Map_Create(NULL)).SetReturn((MAP_HANDLE)NULL);
268 STRICT_EXPECTED_CALL(STRING_delete(value));
269 STRICT_EXPECTED_CALL(STRING_delete(key));
270 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(tokens));
271
272 // act
273 result = connectionstringparser_parse(TEST_STRING_HANDLE_PAIR);
274
275 // assert
276 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
277 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
278
279 // cleanup
280 }
281
282 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_001: [connectionstringparser_parse shall parse all key value pairs from the connection_string passed in as argument and return a new map that holds the key/value pairs.] */
283 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_003: [connectionstringparser_parse shall create a STRING tokenizer to be used for parsing the connection string, by calling STRING_TOKENIZER_create.] */
284 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_004: [connectionstringparser_parse shall start scanning at the beginning of the connection string.] */
285 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_016: [2 STRINGs shall be allocated in order to hold the to be parsed key and value tokens.] */
286 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_005: [The following actions shall be repeated until parsing is complete:] */
287 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_006: [connectionstringparser_parse shall find a token (the key of the key/value pair) delimited by the "=" character, by calling STRING_TOKENIZER_get_next_token.] */
288 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_007: [If STRING_TOKENIZER_get_next_token fails, parsing shall be considered complete.] */
289 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_014: [After the parsing is complete the previously allocated STRINGs and STRING tokenizer shall be freed by calling STRING_TOKENIZER_destroy.] */
290 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_008: [connectionstringparser_parse shall find a token (the value of the key/value pair) delimited by the ";" character, by calling STRING_TOKENIZER_get_next_token.] */
291 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_010: [The key and value shall be added to the result map by using Map_Add.] */
292 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_011: [The C strings for the key and value shall be extracted from the previously parsed STRINGs by using STRING_c_str.] */
293 TEST_FUNCTION(connectionstringparser_parse_with_a_key_value_pair_adds_it_to_the_result_map)
294 {
295 // arrange
296 MAP_HANDLE result;
297 STRING_HANDLE key = STRING_new();
298 STRING_HANDLE value = STRING_new();
299 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR);
300
301 umock_c_reset_all_calls();
302 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR)).SetReturn(tokens);
303 STRICT_EXPECTED_CALL(STRING_new())
304 .SetReturn(key);
305 STRICT_EXPECTED_CALL(STRING_new())
306 .SetReturn(value);
307 STRICT_EXPECTED_CALL(Map_Create(NULL));
308 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
309 STRICT_EXPECTED_CALL(STRING_copy_n(key, TEST_STRING_PAIR, 4));
310 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, value, ";"));
311 STRICT_EXPECTED_CALL(STRING_copy_n(value, (TEST_STRING_PAIR +5), 6));
312 STRICT_EXPECTED_CALL(STRING_c_str(key));
313 STRICT_EXPECTED_CALL(STRING_c_str(value));
314 STRICT_EXPECTED_CALL(Map_Add(IGNORED_PTR_ARG, "key1", "value1")).IgnoreArgument(1);
315 STRICT_EXPECTED_CALL(gballoc_malloc(5));
316 STRICT_EXPECTED_CALL(gballoc_malloc(7));
317 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
318 STRICT_EXPECTED_CALL(STRING_delete(value));
319 STRICT_EXPECTED_CALL(STRING_delete(key));
320 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(tokens));
321
322 // act
323 result = connectionstringparser_parse(TEST_STRING_HANDLE_PAIR);
324
325 // assert
326 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
327 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, result);
328 ASSERT_ARE_EQUAL(char_ptr, "value1", Map_GetValueFromKey(result, "key1"));
329
330 // cleanup
331 Map_Destroy(result);
332 }
333
334 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_009: [If STRING_TOKENIZER_get_next_token fails, connectionstringparser_parse shall fail and return NULL (freeing the allocated result map).] */
335 TEST_FUNCTION(when_getting_the_value_token_fails_then_connectionstringparser_parse_fails)
336 {
337 // arrange
338 MAP_HANDLE result;
339 STRING_HANDLE key = STRING_new();
340 STRING_HANDLE value = STRING_new();
341 MAP_HANDLE map = Map_Create(NULL);
342 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(TEST_STRING_HANDLE_KEY);
343
344 umock_c_reset_all_calls();
345 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_KEY)).SetReturn(tokens);
346 STRICT_EXPECTED_CALL(STRING_new())
347 .SetReturn(key);
348 STRICT_EXPECTED_CALL(STRING_new())
349 .SetReturn(value);
350 STRICT_EXPECTED_CALL(Map_Create(NULL)).SetReturn(map);
351 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
352 STRICT_EXPECTED_CALL(STRING_copy_n(key, TEST_STRING_KEY, 4));
353 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, value, ";"));
354 STRICT_EXPECTED_CALL(Map_Destroy(map));
355 STRICT_EXPECTED_CALL(STRING_delete(value));
356 STRICT_EXPECTED_CALL(STRING_delete(key));
357 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(tokens));
358
359 // act
360 result = connectionstringparser_parse(TEST_STRING_HANDLE_KEY);
361
362 // assert
363 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
364 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
365 }
366
367 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_019: [If the key length is zero then connectionstringparser_parse shall fail and return NULL (freeing the allocated result map).] */
368 TEST_FUNCTION(when_the_key_is_zero_length_then_connectionstringparser_parse_fails)
369 {
370 // arrange
371 MAP_HANDLE result;
372 STRING_HANDLE key = STRING_new();
373 STRING_HANDLE value = STRING_new();
374 MAP_HANDLE map = Map_Create(NULL);
375
376 umock_c_reset_all_calls();
377 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR));
378 STRICT_EXPECTED_CALL(STRING_c_str(TEST_STRING_HANDLE_PAIR));
379 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG)).IgnoreAllArguments();
380 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(key);
381 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(value);
382 STRICT_EXPECTED_CALL(Map_Create(NULL)).SetReturn(map);
383 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(IGNORED_PTR_ARG, key, "=")).IgnoreArgument(1);
384 STRICT_EXPECTED_CALL(STRING_copy_n(key, TEST_STRING_PAIR, 4));
385 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(IGNORED_PTR_ARG, value, ";")).IgnoreArgument(1);
386 STRICT_EXPECTED_CALL(STRING_copy_n(value, (TEST_STRING_PAIR + 5), 6));
387 STRICT_EXPECTED_CALL(STRING_c_str(key)).SetReturn("");
388 STRICT_EXPECTED_CALL(Map_Destroy(map));
389 STRICT_EXPECTED_CALL(STRING_delete(value));
390 STRICT_EXPECTED_CALL(STRING_delete(key));
391 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(IGNORED_PTR_ARG)).IgnoreArgument(1);
392
393 // act
394 result = connectionstringparser_parse(TEST_STRING_HANDLE_PAIR);
395
396 // assert
397 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
398 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
399 }
400
401 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_012: [If Map_Add fails connectionstringparser_parse shall fail and return NULL (freeing the allocated result map).] */
402 TEST_FUNCTION(when_adding_the_key_value_pair_to_the_map_fails_then_connectionstringparser_parse_fails)
403 {
404 // arrange
405 MAP_HANDLE result;
406 STRING_HANDLE key = STRING_new();
407 STRING_HANDLE value = STRING_new();
408 MAP_HANDLE map = Map_Create(NULL);
409 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR);
410
411 umock_c_reset_all_calls();
412 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR)).SetReturn(tokens);
413 STRICT_EXPECTED_CALL(STRING_new())
414 .SetReturn(key);
415 STRICT_EXPECTED_CALL(STRING_new())
416 .SetReturn(value);
417 STRICT_EXPECTED_CALL(Map_Create(NULL)).SetReturn(map);
418 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
419 STRICT_EXPECTED_CALL(STRING_copy_n(key, TEST_STRING_PAIR, 4));
420 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, value, ";"));
421 STRICT_EXPECTED_CALL(STRING_copy_n(value, (TEST_STRING_PAIR + 5), 6));
422 STRICT_EXPECTED_CALL(STRING_c_str(key));
423 STRICT_EXPECTED_CALL(STRING_c_str(value));
424 STRICT_EXPECTED_CALL(Map_Add(map, "key1", "value1")).SetReturn((MAP_RESULT)MAP_INVALIDARG);
425 STRICT_EXPECTED_CALL(Map_Destroy(map));
426 STRICT_EXPECTED_CALL(STRING_delete(value));
427 STRICT_EXPECTED_CALL(STRING_delete(key));
428 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(tokens));
429
430 // act
431 result = connectionstringparser_parse(TEST_STRING_HANDLE_PAIR);
432
433 // assert
434 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
435 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
436 }
437
438 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_013: [If STRING_c_str fails then connectionstringparser_parse shall fail and return NULL (freeing the allocated result map).] */
439 TEST_FUNCTION(when_getting_the_C_string_for_the_key_fails_then_connectionstringparser_parse_fails)
440 {
441 // arrange
442 MAP_HANDLE result;
443 STRING_HANDLE key = STRING_new();
444 STRING_HANDLE value = STRING_new();
445 MAP_HANDLE map = Map_Create(NULL);
446
447 umock_c_reset_all_calls();
448 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR));
449 STRICT_EXPECTED_CALL(STRING_c_str(TEST_STRING_HANDLE_PAIR));
450 STRICT_EXPECTED_CALL(gballoc_malloc(IGNORED_NUM_ARG)).IgnoreAllArguments();
451 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(key);
452 STRICT_EXPECTED_CALL(STRING_new()).SetReturn(value);
453 STRICT_EXPECTED_CALL(Map_Create(NULL)).SetReturn(map);
454 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(IGNORED_PTR_ARG, key, "=")).IgnoreArgument(1);
455 STRICT_EXPECTED_CALL(STRING_copy_n(key, TEST_STRING_PAIR, 4));
456 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(IGNORED_PTR_ARG, value, ";")).IgnoreArgument(1);
457 STRICT_EXPECTED_CALL(STRING_copy_n(value, (TEST_STRING_PAIR + 5), 6));
458 STRICT_EXPECTED_CALL(STRING_c_str(key)).SetReturn(NULL);
459 STRICT_EXPECTED_CALL(Map_Destroy(map));
460 STRICT_EXPECTED_CALL(STRING_delete(value));
461 STRICT_EXPECTED_CALL(STRING_delete(key));
462 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(IGNORED_PTR_ARG)).IgnoreArgument(1);
463
464 // act
465 result = connectionstringparser_parse(TEST_STRING_HANDLE_PAIR);
466
467 // assert
468 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
469 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
470 }
471
472 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_013: [If STRING_c_str fails then connectionstringparser_parse shall fail and return NULL (freeing the allocated result map).] */
473 TEST_FUNCTION(when_getting_the_C_string_for_the_value_fails_then_connectionstringparser_parse_fails)
474 {
475 // arrange
476 MAP_HANDLE result;
477 STRING_HANDLE key = STRING_new();
478 STRING_HANDLE value = STRING_new();
479 MAP_HANDLE map = Map_Create(NULL);
480 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR);
481
482 umock_c_reset_all_calls();
483 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_PAIR)).SetReturn(tokens);
484 STRICT_EXPECTED_CALL(STRING_new())
485 .SetReturn(key);
486 STRICT_EXPECTED_CALL(STRING_new())
487 .SetReturn(value);
488 STRICT_EXPECTED_CALL(Map_Create(NULL)).SetReturn(map);
489 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
490 STRICT_EXPECTED_CALL(STRING_copy_n(key, TEST_STRING_PAIR, 4));
491 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, value, ";"));
492 STRICT_EXPECTED_CALL(STRING_copy_n(value, (TEST_STRING_PAIR + 5), 6));
493 STRICT_EXPECTED_CALL(STRING_c_str(key));
494 STRICT_EXPECTED_CALL(STRING_c_str(value)).SetReturn((const char*)NULL);
495 STRICT_EXPECTED_CALL(Map_Destroy(map));
496 STRICT_EXPECTED_CALL(STRING_delete(value));
497 STRICT_EXPECTED_CALL(STRING_delete(key));
498 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(tokens));
499
500 // act
501 result = connectionstringparser_parse(TEST_STRING_HANDLE_PAIR);
502
503 // assert
504 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
505 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
506 }
507
508 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_001: [connectionstringparser_parse shall parse all key value pairs from the connection_string passed in as argument and return a new map that holds the key/value pairs.] */
509 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_003: [connectionstringparser_parse shall create a STRING tokenizer to be used for parsing the connection string, by calling STRING_TOKENIZER_create.] */
510 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_004: [connectionstringparser_parse shall start scanning at the beginning of the connection string.] */
511 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_016: [2 STRINGs shall be allocated in order to hold the to be parsed key and value tokens.] */
512 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_005: [The following actions shall be repeated until parsing is complete:] */
513 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_006: [connectionstringparser_parse shall find a token (the key of the key/value pair) delimited by the "=" character, by calling STRING_TOKENIZER_get_next_token.] */
514 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_007: [If STRING_TOKENIZER_get_next_token fails, parsing shall be considered complete.] */
515 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_014: [After the parsing is complete the previously allocated STRINGs and STRING tokenizer shall be freed by calling STRING_TOKENIZER_destroy.] */
516 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_008: [connectionstringparser_parse shall find a token (the value of the key/value pair) delimited by the ";" character, by calling STRING_TOKENIZER_get_next_token.] */
517 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_010: [The key and value shall be added to the result map by using Map_Add.] */
518 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_011: [The C strings for the key and value shall be extracted from the previously parsed STRINGs by using STRING_c_str.] */
519 TEST_FUNCTION(connectionstringparser_parse_with_2_key_value_pairs_adds_them_to_the_result_map)
520 {
521 // arrange
522 MAP_HANDLE result;
523 STRING_HANDLE key = STRING_new();
524 STRING_HANDLE value = STRING_new();
525 MAP_HANDLE map = Map_Create(NULL);
526 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(TEST_STRING_HANDLE_2_PAIR);
527
528 umock_c_reset_all_calls();
529 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_2_PAIR)).SetReturn(tokens);
530 STRICT_EXPECTED_CALL(STRING_new())
531 .SetReturn(key);
532 STRICT_EXPECTED_CALL(STRING_new())
533 .SetReturn(value);
534 STRICT_EXPECTED_CALL(Map_Create(NULL)).SetReturn(map);
535
536 // 1st kvp
537 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
538 STRICT_EXPECTED_CALL(STRING_copy_n(key, TEST_STRING_2_PAIR, 4));
539 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, value, ";"));
540 STRICT_EXPECTED_CALL(STRING_copy_n(value, (TEST_STRING_2_PAIR + 5), 6));
541 STRICT_EXPECTED_CALL(STRING_c_str(key));
542 STRICT_EXPECTED_CALL(STRING_c_str(value));
543 STRICT_EXPECTED_CALL(Map_Add(map, "key1", "value1"));
544 STRICT_EXPECTED_CALL(gballoc_malloc(5));
545 STRICT_EXPECTED_CALL(gballoc_malloc(7));
546
547 // 2st kvp
548 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
549 STRICT_EXPECTED_CALL(STRING_copy_n(key, (TEST_STRING_2_PAIR + 12), 4));
550 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, value, ";"));
551 STRICT_EXPECTED_CALL(STRING_copy_n(value, (TEST_STRING_2_PAIR + 17), 6));
552 STRICT_EXPECTED_CALL(STRING_c_str(key));
553 STRICT_EXPECTED_CALL(STRING_c_str(value));
554 STRICT_EXPECTED_CALL(Map_Add(map, "key2", "value2"));
555 STRICT_EXPECTED_CALL(gballoc_malloc(5));
556 STRICT_EXPECTED_CALL(gballoc_malloc(7));
557
558 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
559 STRICT_EXPECTED_CALL(STRING_delete(value));
560 STRICT_EXPECTED_CALL(STRING_delete(key));
561 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(tokens));
562
563 // act
564 result = connectionstringparser_parse(TEST_STRING_HANDLE_2_PAIR);
565
566 // assert
567 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
568 ASSERT_ARE_EQUAL(void_ptr, map, result);
569 ASSERT_ARE_EQUAL(char_ptr, "value1", Map_GetValueFromKey(result, "key1"));
570 ASSERT_ARE_EQUAL(char_ptr, "value2", Map_GetValueFromKey(result, "key2"));
571
572 // cleanup
573 Map_Destroy(result);
574
575 }
576
577 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_001: [connectionstringparser_parse shall parse all key value pairs from the connection_string passed in as argument and return a new map that holds the key/value pairs.] */
578 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_003: [connectionstringparser_parse shall create a STRING tokenizer to be used for parsing the connection string, by calling STRING_TOKENIZER_create.] */
579 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_004: [connectionstringparser_parse shall start scanning at the beginning of the connection string.] */
580 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_016: [2 STRINGs shall be allocated in order to hold the to be parsed key and value tokens.] */
581 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_005: [The following actions shall be repeated until parsing is complete:] */
582 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_006: [connectionstringparser_parse shall find a token (the key of the key/value pair) delimited by the "=" character, by calling STRING_TOKENIZER_get_next_token.] */
583 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_007: [If STRING_TOKENIZER_get_next_token fails, parsing shall be considered complete.] */
584 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_014: [After the parsing is complete the previously allocated STRINGs and STRING tokenizer shall be freed by calling STRING_TOKENIZER_destroy.] */
585 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_008: [connectionstringparser_parse shall find a token (the value of the key/value pair) delimited by the ";" character, by calling STRING_TOKENIZER_get_next_token.] */
586 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_010: [The key and value shall be added to the result map by using Map_Add.] */
587 /* Tests_SRS_CONNECTIONSTRINGPARSER_01_011: [The C strings for the key and value shall be extracted from the previously parsed STRINGs by using STRING_c_str.] */
588 TEST_FUNCTION(connectionstringparser_parse_with_2_key_value_pairs_ended_with_semicolon_adds_them_to_the_result_map)
589 {
590 // arrange
591 MAP_HANDLE result;
592 STRING_HANDLE key = STRING_new();
593 STRING_HANDLE value = STRING_new();
594 MAP_HANDLE map = Map_Create(NULL);
595 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(TEST_STRING_HANDLE_2_PAIR_SEMICOLON);
596
597 umock_c_reset_all_calls();
598 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(TEST_STRING_HANDLE_2_PAIR_SEMICOLON)).SetReturn(tokens);
599 STRICT_EXPECTED_CALL(STRING_new())
600 .SetReturn(key);
601 STRICT_EXPECTED_CALL(STRING_new())
602 .SetReturn(value);
603 STRICT_EXPECTED_CALL(Map_Create(NULL)).SetReturn(map);
604
605 // 1st kvp
606 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
607 STRICT_EXPECTED_CALL(STRING_copy_n(key, TEST_STRING_2_PAIR_SEMICOLON, 4));
608 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, value, ";"));
609 STRICT_EXPECTED_CALL(STRING_copy_n(value, (TEST_STRING_2_PAIR_SEMICOLON + 5), 6));
610 STRICT_EXPECTED_CALL(STRING_c_str(key));
611 STRICT_EXPECTED_CALL(STRING_c_str(value));
612 STRICT_EXPECTED_CALL(Map_Add(map, "key1", "value1"));
613 STRICT_EXPECTED_CALL(gballoc_malloc(5));
614 STRICT_EXPECTED_CALL(gballoc_malloc(7));
615
616 // 2st kvp
617 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
618 STRICT_EXPECTED_CALL(STRING_copy_n(key, (TEST_STRING_2_PAIR_SEMICOLON + 12), 4));
619 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, value, ";"));
620 STRICT_EXPECTED_CALL(STRING_copy_n(value, (TEST_STRING_2_PAIR_SEMICOLON + 17), 6));
621 STRICT_EXPECTED_CALL(STRING_c_str(key));
622 STRICT_EXPECTED_CALL(STRING_c_str(value));
623 STRICT_EXPECTED_CALL(Map_Add(map, "key2", "value2"));
624 STRICT_EXPECTED_CALL(gballoc_malloc(5));
625 STRICT_EXPECTED_CALL(gballoc_malloc(7));
626
627 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(tokens, key, "="));
628 STRICT_EXPECTED_CALL(STRING_delete(value));
629 STRICT_EXPECTED_CALL(STRING_delete(key));
630 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(tokens));
631
632 // act
633 result = connectionstringparser_parse(TEST_STRING_HANDLE_2_PAIR_SEMICOLON);
634
635 // assert
636 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
637 ASSERT_ARE_EQUAL(void_ptr, map, result);
638 ASSERT_ARE_EQUAL(char_ptr, "value1", Map_GetValueFromKey(result, "key1"));
639 ASSERT_ARE_EQUAL(char_ptr, "value2", Map_GetValueFromKey(result, "key2"));
640
641 // cleanup
642 Map_Destroy(result);
643 }
644
645 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_020: [connectionstringparser_parse_from_char shall create a STRING_HANDLE from the connection_string passed in as argument and parse it using the connectionstringparser_parse.]*/
646 TEST_FUNCTION(connectionstringparser_parse_from_char_with_2_key_value_pairs_ended_with_semicolon_adds_them_to_the_result_map)
647 {
648 // arrange
649 MAP_HANDLE result;
650 STRING_HANDLE key = STRING_new();
651 STRING_HANDLE value = STRING_new();
652 MAP_HANDLE map = Map_Create(NULL);
653 STRING_TOKENIZER_HANDLE tokens = STRING_TOKENIZER_create(TEST_STRING_HANDLE_2_PAIR_SEMICOLON);
654 STRING_HANDLE test_string_val = STRING_construct(TEST_STRING_2_PAIR_SEMICOLON);
655
656 umock_c_reset_all_calls();
657 STRICT_EXPECTED_CALL(STRING_construct(TEST_STRING_2_PAIR_SEMICOLON)).SetReturn(test_string_val);
658 STRICT_EXPECTED_CALL(STRING_TOKENIZER_create(IGNORED_PTR_ARG)).SetReturn(tokens);
659 STRICT_EXPECTED_CALL(STRING_new())
660 .SetReturn(key);
661 STRICT_EXPECTED_CALL(STRING_new())
662 .SetReturn(value);
663 STRICT_EXPECTED_CALL(Map_Create(NULL)).SetReturn(map);
664
665 // 1st kvp
666 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "="));
667 STRICT_EXPECTED_CALL(STRING_copy_n(IGNORED_PTR_ARG, TEST_STRING_2_PAIR_SEMICOLON, 4));
668 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(IGNORED_PTR_ARG, IGNORED_PTR_ARG, ";"));
669 STRICT_EXPECTED_CALL(STRING_copy_n(IGNORED_PTR_ARG, (TEST_STRING_2_PAIR_SEMICOLON + 5), 6));
670 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG));
671 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG));
672 STRICT_EXPECTED_CALL(Map_Add(IGNORED_PTR_ARG, "key1", "value1"));
673 STRICT_EXPECTED_CALL(gballoc_malloc(5));
674 STRICT_EXPECTED_CALL(gballoc_malloc(7));
675
676 // 2st kvp
677 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "="));
678 STRICT_EXPECTED_CALL(STRING_copy_n(IGNORED_PTR_ARG, (TEST_STRING_2_PAIR_SEMICOLON + 12), 4));
679 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(IGNORED_PTR_ARG, IGNORED_PTR_ARG, ";"));
680 STRICT_EXPECTED_CALL(STRING_copy_n(IGNORED_PTR_ARG, (TEST_STRING_2_PAIR_SEMICOLON + 17), 6));
681 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG));
682 STRICT_EXPECTED_CALL(STRING_c_str(IGNORED_PTR_ARG));
683 STRICT_EXPECTED_CALL(Map_Add(IGNORED_PTR_ARG, "key2", "value2"));
684 STRICT_EXPECTED_CALL(gballoc_malloc(5));
685 STRICT_EXPECTED_CALL(gballoc_malloc(7));
686
687 STRICT_EXPECTED_CALL(STRING_TOKENIZER_get_next_token(IGNORED_PTR_ARG, IGNORED_PTR_ARG, "="));
688 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG));
689 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG));
690 STRICT_EXPECTED_CALL(STRING_TOKENIZER_destroy(IGNORED_PTR_ARG));
691 STRICT_EXPECTED_CALL(STRING_delete(IGNORED_PTR_ARG));
692
693 // act
694 result = connectionstringparser_parse_from_char(TEST_STRING_2_PAIR_SEMICOLON);
695
696 // assert
697 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
698 ASSERT_ARE_EQUAL(void_ptr, map, result);
699 ASSERT_ARE_EQUAL(char_ptr, "value1", Map_GetValueFromKey(result, "key1"));
700 ASSERT_ARE_EQUAL(char_ptr, "value2", Map_GetValueFromKey(result, "key2"));
701
702 // cleanup
703 Map_Destroy(result);
704 }
705
706 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_021: [If connectionstringparser_parse_from_char get error creating a STRING_HANDLE, it shall return NULL.]*/
707 TEST_FUNCTION(connectionstringparser_parse_from_char_with_NULL_connection_string_fails)
708 {
709 // arrange
710
711 // act
712 MAP_HANDLE result = connectionstringparser_parse_from_char(NULL);
713
714 // assert
715 ASSERT_ARE_EQUAL(void_ptr, NULL, result);
716 }
717
718 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_022: [connectionstringparser_splitHostName_from_char shall split the provided hostName in name and suffix.]*/
719 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_023: [connectionstringparser_splitHostName_from_char shall copy all characters, from the beginning of the hostName to the first . to the nameString.]*/
720 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_024: [connectionstringparser_splitHostName_from_char shall copy all characters, from the first . to the end of the hostName, to the suffixString.]*/
721 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_025: [If connectionstringparser_splitHostName_from_char get success splitting the hostName, it shall return 0.]*/
722 TEST_FUNCTION(connectionstringparser_splitHostName_from_char_with_success)
723 {
724 // arrange
725 int result;
726 const char* hostName = "abc.bcd.efg";
727 const char* startSuffix = hostName + 4;
728 STRING_HANDLE nameString = STRING_new();
729 STRING_HANDLE suffixString = STRING_new();
730 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, nameString);
731 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, suffixString);
732
733 umock_c_reset_all_calls();
734 STRICT_EXPECTED_CALL(STRING_copy_n(nameString, hostName, 3));
735 STRICT_EXPECTED_CALL(STRING_copy(suffixString, startSuffix));
736
737 // act
738 result = connectionstringparser_splitHostName_from_char(hostName, nameString, suffixString);
739
740 // assert
741 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
742 ASSERT_ARE_EQUAL(int, 0, result);
743 ASSERT_ARE_EQUAL(char_ptr, "abc", STRING_c_str(nameString));
744 ASSERT_ARE_EQUAL(char_ptr, "bcd.efg", STRING_c_str(suffixString));
745
746 // cleanup
747 STRING_delete(nameString);
748 STRING_delete(suffixString);
749 }
750
751 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_026: [If the hostName is NULL, connectionstringparser_splitHostName_from_char shall return MU_FAILURE.]*/
752 TEST_FUNCTION(connectionstringparser_splitHostName_from_char_with_NULL_hostName_failed)
753 {
754 // arrange
755 int result;
756 STRING_HANDLE nameString = STRING_new();
757 STRING_HANDLE suffixString = STRING_new();
758 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, nameString);
759 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, suffixString);
760
761 umock_c_reset_all_calls();
762
763 // act
764 result = connectionstringparser_splitHostName_from_char(NULL, nameString, suffixString);
765
766 // assert
767 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
768 ASSERT_ARE_NOT_EQUAL(int, 0, result);
769 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(nameString));
770 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(suffixString));
771
772 // cleanup
773 STRING_delete(nameString);
774 STRING_delete(suffixString);
775 }
776
777 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_027: [If the hostName is an empty string, connectionstringparser_splitHostName_from_char shall return MU_FAILURE.]*/
778 TEST_FUNCTION(connectionstringparser_splitHostName_from_char_with_empty_hostName_failed)
779 {
780 // arrange
781 int result;
782 const char* hostName = "";
783 STRING_HANDLE nameString = STRING_new();
784 STRING_HANDLE suffixString = STRING_new();
785 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, nameString);
786 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, suffixString);
787
788 umock_c_reset_all_calls();
789
790 // act
791 result = connectionstringparser_splitHostName_from_char(hostName, nameString, suffixString);
792
793 // assert
794 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
795 ASSERT_ARE_NOT_EQUAL(int, 0, result);
796 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(nameString));
797 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(suffixString));
798
799 // cleanup
800 STRING_delete(nameString);
801 STRING_delete(suffixString);
802 }
803
804 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_028: [If the nameString is NULL, connectionstringparser_splitHostName_from_char shall return MU_FAILURE.]*/
805 TEST_FUNCTION(connectionstringparser_splitHostName_from_char_with_NULL_nameString_failed)
806 {
807 // arrange
808 int result;
809 const char* hostName = "abc.bcd.efg";
810 STRING_HANDLE suffixString = STRING_new();
811 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, suffixString);
812
813 umock_c_reset_all_calls();
814
815 // act
816 result = connectionstringparser_splitHostName_from_char(hostName, NULL, suffixString);
817
818 // assert
819 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
820 ASSERT_ARE_NOT_EQUAL(int, 0, result);
821 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(suffixString));
822
823 // cleanup
824 STRING_delete(suffixString);
825 }
826
827 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_029: [If the suffixString is NULL, connectionstringparser_splitHostName_from_char shall return MU_FAILURE.]*/
828 TEST_FUNCTION(connectionstringparser_splitHostName_from_char_with_NULL_suffixString_failed)
829 {
830 // arrange
831 int result;
832 const char* hostName = "abc.bcd.efg";
833 STRING_HANDLE nameString = STRING_new();
834 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, nameString);
835
836 umock_c_reset_all_calls();
837
838 // act
839 result = connectionstringparser_splitHostName_from_char(hostName, nameString, NULL);
840
841 // assert
842 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
843 ASSERT_ARE_NOT_EQUAL(int, 0, result);
844 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(nameString));
845
846 // cleanup
847 STRING_delete(nameString);
848 }
849
850 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_030: [If the hostName is not a valid host name, connectionstringparser_splitHostName_from_char shall return MU_FAILURE.]*/
851 TEST_FUNCTION(connectionstringparser_splitHostName_from_char_with_empty_name_failed)
852 {
853 // arrange
854 int result;
855 const char* hostName = ".bcd.efg";
856 STRING_HANDLE nameString = STRING_new();
857 STRING_HANDLE suffixString = STRING_new();
858 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, nameString);
859 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, suffixString);
860
861 umock_c_reset_all_calls();
862
863 // act
864 result = connectionstringparser_splitHostName_from_char(hostName, nameString, suffixString);
865
866 // assert
867 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
868 ASSERT_ARE_NOT_EQUAL(int, 0, result);
869 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(nameString));
870 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(suffixString));
871
872 // cleanup
873 STRING_delete(nameString);
874 STRING_delete(suffixString);
875 }
876
877 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_030: [If the hostName is not a valid host name, connectionstringparser_splitHostName_from_char shall return MU_FAILURE.]*/
878 TEST_FUNCTION(connectionstringparser_splitHostName_from_char_with_empty_suffix_failed)
879 {
880 // arrange
881 int result;
882 const char* hostName = "abc.";
883 STRING_HANDLE nameString = STRING_new();
884 STRING_HANDLE suffixString = STRING_new();
885 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, nameString);
886 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, suffixString);
887
888 umock_c_reset_all_calls();
889
890 // act
891 result = connectionstringparser_splitHostName_from_char(hostName, nameString, suffixString);
892
893 // assert
894 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
895 ASSERT_ARE_NOT_EQUAL(int, 0, result);
896 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(nameString));
897 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(suffixString));
898
899 // cleanup
900 STRING_delete(nameString);
901 STRING_delete(suffixString);
902 }
903
904 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_031: [If connectionstringparser_splitHostName_from_char get error copying the name to the nameString, it shall return MU_FAILURE.]*/
905 TEST_FUNCTION(connectionstringparser_splitHostName_from_char_error_on_nameString_copy_failed)
906 {
907 // arrange
908 int result;
909 const char* hostName = "abc.bcd.efg";
910 STRING_HANDLE nameString = STRING_new();
911 STRING_HANDLE suffixString = STRING_new();
912 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, nameString);
913 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, suffixString);
914
915 umock_c_reset_all_calls();
916 STRICT_EXPECTED_CALL(STRING_copy_n(nameString, hostName, 3)).SetReturn(10);
917
918 // act
919 result = connectionstringparser_splitHostName_from_char(hostName, nameString, suffixString);
920
921 // assert
922 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
923 ASSERT_ARE_NOT_EQUAL(int, 0, result);
924 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(nameString));
925 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(suffixString));
926
927 // cleanup
928 STRING_delete(nameString);
929 STRING_delete(suffixString);
930 }
931
932 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_032: [If connectionstringparser_splitHostName_from_char get error copying the suffix to the suffixString, it shall return MU_FAILURE.]*/
933 TEST_FUNCTION(connectionstringparser_splitHostName_from_char_error_on_suffixString_copy_failed)
934 {
935 // arrange
936 int result;
937 const char* hostName = "abc.bcd.efg";
938 const char* startSuffix = hostName + 4;
939 STRING_HANDLE nameString = STRING_new();
940 STRING_HANDLE suffixString = STRING_new();
941 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, nameString);
942 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, suffixString);
943
944 umock_c_reset_all_calls();
945 STRICT_EXPECTED_CALL(STRING_copy_n(nameString, hostName, 3));
946 STRICT_EXPECTED_CALL(STRING_copy(suffixString, startSuffix)).SetReturn(10);
947
948 // act
949 result = connectionstringparser_splitHostName_from_char(hostName, nameString, suffixString);
950
951 // assert
952 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
953 ASSERT_ARE_NOT_EQUAL(int, 0, result);
954 ASSERT_ARE_EQUAL(char_ptr, "abc", STRING_c_str(nameString));
955 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(suffixString));
956
957 // cleanup
958 STRING_delete(nameString);
959 STRING_delete(suffixString);
960 }
961
962 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_033: [connectionstringparser_splitHostName shall convert the hostNameString to a connection_string passed in as argument, and call connectionstringparser_splitHostName_from_char.]*/
963 TEST_FUNCTION(connectionstringparser_splitHostName_with_success)
964 {
965 // arrange
966 int result;
967 const char* hostName;
968 const char* startSuffix;
969 STRING_HANDLE nameString = STRING_new();
970 STRING_HANDLE suffixString = STRING_new();
971 STRING_HANDLE hostNameString = STRING_construct("abc.bcd.efg");
972 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, hostNameString);
973 hostName = STRING_c_str(hostNameString);
974 startSuffix = hostName + 4;
975 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, nameString);
976 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, suffixString);
977
978 umock_c_reset_all_calls();
979 STRICT_EXPECTED_CALL(STRING_c_str(hostNameString));
980 STRICT_EXPECTED_CALL(STRING_copy_n(nameString, hostName, 3));
981 STRICT_EXPECTED_CALL(STRING_copy(suffixString, startSuffix));
982
983 // act
984 result = connectionstringparser_splitHostName(hostNameString, nameString, suffixString);
985
986 // assert
987 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
988 ASSERT_ARE_EQUAL(int, 0, result);
989 ASSERT_ARE_EQUAL(char_ptr, "abc", STRING_c_str(nameString));
990 ASSERT_ARE_EQUAL(char_ptr, "bcd.efg", STRING_c_str(suffixString));
991
992 // cleanup
993 STRING_delete(nameString);
994 STRING_delete(suffixString);
995 STRING_delete(hostNameString);
996 }
997
998 /* Tests_SRS_CONNECTIONSTRINGPARSER_21_034: [If the hostNameString is NULL, connectionstringparser_splitHostName shall return MU_FAILURE.]*/
999 TEST_FUNCTION(connectionstringparser_splitHostName_with_NULL_hostName_failed)
1000 {
1001 // arrange
1002 int result;
1003 STRING_HANDLE nameString = STRING_new();
1004 STRING_HANDLE suffixString = STRING_new();
1005 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, nameString);
1006 ASSERT_ARE_NOT_EQUAL(void_ptr, NULL, suffixString);
1007
1008 umock_c_reset_all_calls();
1009
1010 // act
1011 result = connectionstringparser_splitHostName(NULL, nameString, suffixString);
1012
1013 // assert
1014 ASSERT_ARE_EQUAL(char_ptr, umock_c_get_expected_calls(), umock_c_get_actual_calls());
1015 ASSERT_ARE_NOT_EQUAL(int, 0, result);
1016 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(nameString));
1017 ASSERT_ARE_EQUAL(char_ptr, "", STRING_c_str(suffixString));
1018
1019 // cleanup
1020 STRING_delete(nameString);
1021 STRING_delete(suffixString);
1022 }
1023
1024
1025 END_TEST_SUITE(connectionstringparser_ut)