libamxc  1.10.3
C Generic Data Containers
Data Structures | Typedefs | Functions
test_amxc_string_split.c File Reference
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <ctype.h>
#include <string.h>
#include <setjmp.h>
#include <cmocka.h>
#include <amxc/amxc_string_split.h>
#include <amxc/amxc_utils.h>
#include "test_amxc_string_split.h"
#include <amxc/amxc_macros.h>

Go to the source code of this file.

Data Structures

struct  _test_cases
 

Typedefs

typedef struct _test_cases test_cases_t
 

Functions

void test_can_split_string_using_separator (UNUSED void **state)
 
void test_can_split_string_using_space_separators (UNUSED void **state)
 
void test_check_parts_are_correct (UNUSED void **state)
 
void test_can_split_csv_string_to_variant (UNUSED void **state)
 
void test_split_csv_handles_sequence_of_commas_as_multiple_items (UNUSED void **state)
 
void test_split_csv_string_handles_comma_in_quotes_correctly (UNUSED void **state)
 
void test_split_csv_string_handles_empty_string_correctly (UNUSED void **state)
 
void test_can_split_csv_string_with_multi_array_to_variant (UNUSED void **state)
 
void test_can_split_csv_string_can_start_with_array_to_variant (UNUSED void **state)
 
void test_can_split_csv_string_supports_multi_level_array_to_variant (UNUSED void **state)
 
void test_can_split_csv_string_with_single_quotes_to_variant (UNUSED void **state)
 
void test_can_split_csv_string_with_double_quotes_to_variant (UNUSED void **state)
 
void test_split_csv_can_handle_empty_sublist (UNUSED void **state)
 
void test_can_split_ssv_string_to_variant (UNUSED void **state)
 
void test_split_ssv_handles_sequence_of_spaces_as_one_separator (UNUSED void **state)
 
void test_split_ssv_string_handles_spaces_in_quotes_correctly (UNUSED void **state)
 
void test_can_split_ssv_string_with_single_quotes_to_variant (UNUSED void **state)
 
void test_split_ssv_string_handles_empty_string_correctly (UNUSED void **state)
 
void test_can_split_ssv_string_with_multi_array_to_variant (UNUSED void **state)
 
void test_split_word_checks_quotes (UNUSED void **state)
 
void test_split_word_checks_curly_brackets (UNUSED void **state)
 
void test_split_word_checks_square_brackets (UNUSED void **state)
 
void test_split_word_checks_round_brackets (UNUSED void **state)
 
void test_amxc_string_split_word (UNUSED void **state)
 
void test_amxc_string_split_word_quotes2 (UNUSED void **state)
 
void test_amxc_string_split_word_can_start_with_punctuation (UNUSED void **state)
 
void test_functions_validates_input_arguments (UNUSED void **state)
 
void test_split_string_on_new_line (UNUSED void **state)
 

Typedef Documentation

◆ test_cases_t

typedef struct _test_cases test_cases_t

Function Documentation

◆ test_amxc_string_split_word()

void test_amxc_string_split_word ( UNUSED void **  state)

Definition at line 907 of file test_amxc_string_split.c.

907  {
908  amxc_string_t string;
909  amxc_llist_t string_list;
910  const char* parts[] = {
911  "This", " ", "is", " ", "a", " ", "text", "\t", "with", " ", "space", " ", "characters", " ", "and",
912  " ", "\"", "quoted text with \\\" escapes", "\"", " ", "and", " ", ",", " ", "some", " ", "(",
913  "punctuation", ")", ".", " ", "A", " ", "=", " ", "The", " ", "end", " ", NULL
914  };
915 
916  const char* text = " This is a text\t\t with space characters and \"quoted text with \\\" escapes\" and , some (punctuation). A = The end ";
917  amxc_llist_init(&string_list);
918  assert_int_equal(amxc_string_init(&string, 0), 0);
919  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
920 
921  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), 0);
922  amxc_llist_for_each(it, (&string_list)) {
923  amxc_string_t* s = amxc_string_from_llist_it(it);
924  const char* p = amxc_string_get(s, 0);
925  printf("*%s*\n", p);
926  }
927  assert_int_equal(amxc_llist_size(&string_list), 39);
928 
929  for(int i = 0; parts[i] != NULL; i++) {
930  const char* txt_part = amxc_string_get_text_from_llist(&string_list, i);
931  assert_string_equal(txt_part, parts[i]);
932  }
933 
934  amxc_llist_clean(&string_list, amxc_string_list_it_free);
935  amxc_string_clean(&string);
936 }
amxc_llist_size
size_t amxc_llist_size(const amxc_llist_t *const llist)
Calculates the size of the linked list.
Definition: amxc_llist.c:151
amxc_llist_init
int amxc_llist_init(amxc_llist_t *const llist)
Initializes a linked list.
Definition: amxc_llist.c:111
amxc_llist_clean
void amxc_llist_clean(amxc_llist_t *const llist, amxc_llist_it_delete_t func)
Removes all items from the linked list.
Definition: amxc_llist.c:124
amxc_llist_for_each
#define amxc_llist_for_each(it, list)
Loops over the list from head to tail.
Definition: amxc_llist.h:253
amxc_string_split_word
amxc_string_split_status_t amxc_string_split_word(const amxc_string_t *const string, amxc_llist_t *list, const char **reason)
Split a string in individual words or punctuation signs.
Definition: amxc_string_split.c:499
amxc_string_get_text_from_llist
const char * amxc_string_get_text_from_llist(const amxc_llist_t *const llist, const unsigned int index)
Helper function to be used with amxc_string_split_llist.
Definition: amxc_string_split.c:656
amxc_string_list_it_free
void amxc_string_list_it_free(amxc_llist_it_t *it)
Helper function to delete an item in a linked list.
Definition: amxc_utils.c:327
amxc_string_get
const char * amxc_string_get(const amxc_string_t *const string, const size_t offset)
Gets the content of the string buffer.
Definition: amxc_string.c:339
amxc_string_append
AMXC_INLINE int amxc_string_append(amxc_string_t *const string, const char *const text, const size_t length)
Appends text to the end of the current content of the string buffer.
Definition: amxc_string.h:920
amxc_string_from_llist_it
#define amxc_string_from_llist_it(ll_it)
Get the pointer to a string structure from an amxc linked list iterator.
Definition: amxc_string.h:95
amxc_string_init
int amxc_string_init(amxc_string_t *const string, const size_t length)
Initializes a string.
Definition: amxc_string.c:163
amxc_string_clean
void amxc_string_clean(amxc_string_t *const string)
Frees the string buffer and reset length attributes.
Definition: amxc_string.c:189
_amxc_llist
The linked list structure.
Definition: amxc_llist.h:228
_amxc_string
The string structure.
Definition: amxc_string.h:103
it
static amxc_htable_it_t it[2000]
Definition: test_amxc_htable.c:69

◆ test_amxc_string_split_word_can_start_with_punctuation()

void test_amxc_string_split_word_can_start_with_punctuation ( UNUSED void **  state)

Definition at line 990 of file test_amxc_string_split.c.

990  {
991  amxc_string_t string;
992  amxc_llist_t string_list;
993 
994  const char* text = ",some more text here";
995  amxc_llist_init(&string_list);
996  assert_int_equal(amxc_string_init(&string, 0), 0);
997  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
998 
999  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), 0);
1000  assert_int_equal(amxc_llist_size(&string_list), 8);
1001 
1002  amxc_llist_clean(&string_list, amxc_string_list_it_free);
1003  amxc_string_clean(&string);
1004 }

◆ test_amxc_string_split_word_quotes2()

void test_amxc_string_split_word_quotes2 ( UNUSED void **  state)

Definition at line 938 of file test_amxc_string_split.c.

938  {
939  amxc_string_t string;
940  amxc_llist_t string_list;
941  int counter = 0;
942 
943  const char* text = "!History.save \"/tmp/test.txt\"";
944 
945  amxc_llist_init(&string_list);
946  assert_int_equal(amxc_string_init(&string, 0), 0);
947  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
948  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), 0);
949 
950  amxc_llist_for_each(it, (&string_list)) {
951  amxc_string_t* s = amxc_string_from_llist_it(it);
952  const char* p = amxc_string_get(s, 0);
953  assert_ptr_not_equal(p, NULL);
954 
955  switch(counter) {
956  case 0:
957  assert_string_equal(p, "!");
958  break;
959  case 1:
960  assert_string_equal(p, "History");
961  break;
962  case 2:
963  assert_string_equal(p, ".");
964  break;
965  case 3:
966  assert_string_equal(p, "save");
967  break;
968  case 4:
969  assert_string_equal(p, " ");
970  break;
971  case 5:
972  assert_string_equal(p, "\"");
973  break;
974  case 6:
975  assert_string_equal(p, "/tmp/test.txt");
976  break;
977  case 7:
978  assert_string_equal(p, "\"");
979  break;
980  }
981 
982  printf("[%s]\n", p);
983  counter++;
984  }
985 
986  amxc_llist_clean(&string_list, amxc_string_list_it_free);
987  amxc_string_clean(&string);
988 }
counter
static int counter
Definition: test_amxc_array.c:66

◆ test_can_split_csv_string_can_start_with_array_to_variant()

void test_can_split_csv_string_can_start_with_array_to_variant ( UNUSED void **  state)

Definition at line 374 of file test_amxc_string_split.c.

374  {
375  amxc_string_t string;
376  amxc_var_t variant;
377  const amxc_llist_t* string_list = NULL;
378  amxc_llist_it_t* it = NULL;
379  amxc_var_t* part = NULL;
380 
381  amxc_var_init(&variant);
382 
383  assert_int_equal(amxc_string_init(&string, 0), 0);
384  assert_int_equal(amxc_string_append(&string, "[part1,part2],part3,part4", 25), 0);
385  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
386  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
387  string_list = amxc_var_constcast(amxc_llist_t, &variant);
388  assert_ptr_not_equal(string_list, NULL);
389  assert_int_equal(amxc_llist_size(string_list), 3);
390 
391  it = amxc_llist_get_first(string_list);
392  part = amxc_var_from_llist_it(it);
393  assert_ptr_not_equal(part, NULL);
394  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_LIST);
395  assert_ptr_not_equal(amxc_var_constcast(amxc_llist_t, part), NULL);
396 
397  it = amxc_llist_it_get_next(it);
398  part = amxc_var_from_llist_it(it);
399  assert_ptr_not_equal(part, NULL);
400  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
401  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
402  assert_string_equal(amxc_var_constcast(cstring_t, part), "part3");
403 
404  it = amxc_llist_it_get_next(it);
405  part = amxc_var_from_llist_it(it);
406  assert_ptr_not_equal(part, NULL);
407  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
408  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
409  assert_string_equal(amxc_var_constcast(cstring_t, part), "part4");
410 
411  amxc_string_clean(&string);
412  amxc_var_clean(&variant);
413 }
cstring_t
#define cstring_t
Convenience macro.
Definition: amxc_variant.h:584
amxc_var_from_llist_it
#define amxc_var_from_llist_it(ll_it)
Get the variant pointer from an amxc linked list iterator.
Definition: amxc_variant.h:799
amxc_llist_it_get_next
AMXC_INLINE amxc_llist_it_t * amxc_llist_it_get_next(const amxc_llist_it_t *const reference)
Gets the next iterator in the list.
Definition: amxc_llist.h:824
amxc_llist_get_first
AMXC_INLINE amxc_llist_it_t * amxc_llist_get_first(const amxc_llist_t *const llist)
Gets the first item of the linked list.
Definition: amxc_llist.h:713
amxc_string_csv_to_var
amxc_string_split_status_t amxc_string_csv_to_var(const amxc_string_t *const string, amxc_var_t *var, const char **reason)
Split a string in individual parts assuming that the string contains comma separated values.
Definition: amxc_string_split.c:555
AMXC_VAR_ID_CSTRING
#define AMXC_VAR_ID_CSTRING
C-string variant id (aka char *), null terminated string.
Definition: amxc_variant.h:134
AMXC_VAR_ID_LIST
#define AMXC_VAR_ID_LIST
Ambiorix Linked List variant id.
Definition: amxc_variant.h:206
amxc_var_type_of
uint32_t amxc_var_type_of(const amxc_var_t *const var)
Gets the variant type id of a variant.
Definition: amxc_variant.c:668
amxc_var_init
int amxc_var_init(amxc_var_t *const var)
Initializes a variant.
Definition: amxc_variant.c:223
amxc_var_clean
void amxc_var_clean(amxc_var_t *const var)
Clean-up and reset variant.
Definition: amxc_variant.c:237
amxc_var_constcast
#define amxc_var_constcast(type, var)
Takes the content from a variant.
Definition: amxc_variant.h:722
_amxc_llist_it
The linked list iterator structure.
Definition: amxc_llist.h:215
_amxc_var
The variant struct definition.
Definition: amxc_variant.h:861

◆ test_can_split_csv_string_supports_multi_level_array_to_variant()

void test_can_split_csv_string_supports_multi_level_array_to_variant ( UNUSED void **  state)

Definition at line 415 of file test_amxc_string_split.c.

415  {
416  amxc_string_t string;
417  amxc_var_t variant;
418  const amxc_llist_t* string_list = NULL;
419 
420  amxc_var_init(&variant);
421 
422  assert_int_equal(amxc_string_init(&string, 0), 0);
423  assert_int_equal(amxc_string_append(&string, "[part1,[part2,part3,[part4,part5]]]", 35), 0);
424  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
425  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
426  string_list = amxc_var_constcast(amxc_llist_t, &variant);
427  assert_ptr_not_equal(string_list, NULL);
428  assert_int_equal(amxc_llist_size(string_list), 1);
429 
430  amxc_string_clean(&string);
431  amxc_var_clean(&variant);
432 }

◆ test_can_split_csv_string_to_variant()

void test_can_split_csv_string_to_variant ( UNUSED void **  state)

Definition at line 200 of file test_amxc_string_split.c.

200  {
201  amxc_string_t string;
202  amxc_var_t variant;
203  const amxc_llist_t* string_list = NULL;
204  amxc_llist_it_t* it = NULL;
205  amxc_var_t* part = NULL;
206 
207  amxc_var_init(&variant);
208 
209  assert_int_equal(amxc_string_init(&string, 0), 0);
210  assert_int_equal(amxc_string_append(&string, "part1,part2,part3", 17), 0);
211  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
212  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
213  string_list = amxc_var_constcast(amxc_llist_t, &variant);
214  assert_ptr_not_equal(string_list, NULL);
215  assert_int_equal(amxc_llist_size(string_list), 3);
216 
217  it = amxc_llist_get_first(string_list);
218  part = amxc_var_from_llist_it(it);
219  assert_ptr_not_equal(part, NULL);
220  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
221  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
222  assert_string_equal(amxc_var_constcast(cstring_t, part), "part1");
223 
224  it = amxc_llist_it_get_next(it);
225  part = amxc_var_from_llist_it(it);
226  assert_ptr_not_equal(part, NULL);
227  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
228  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
229  assert_string_equal(amxc_var_constcast(cstring_t, part), "part2");
230 
231  it = amxc_llist_it_get_next(it);
232  part = amxc_var_from_llist_it(it);
233  assert_ptr_not_equal(part, NULL);
234  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
235  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
236  assert_string_equal(amxc_var_constcast(cstring_t, part), "part3");
237 
238  assert_int_equal(amxc_string_setf(&string, "Phonebook.Contact.[FirstName=='ward'].PhoneNumber.*,Phonebook.Contact."), 0);
239  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
240  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
241  amxc_var_dump(&variant, 1);
242  string_list = amxc_var_constcast(amxc_llist_t, &variant);
243  assert_ptr_not_equal(string_list, NULL);
244  assert_int_equal(amxc_llist_size(string_list), 2);
245  assert_string_equal(GETI_CHAR(&variant, 0), "Phonebook.Contact.[FirstName=='ward'].PhoneNumber.*");
246  assert_string_equal(GETI_CHAR(&variant, 1), "Phonebook.Contact.");
247 
248  assert_int_not_equal(amxc_string_csv_to_var(NULL, NULL, NULL), 0);
249  assert_int_not_equal(amxc_string_csv_to_var(&string, NULL, NULL), 0);
250 
251  amxc_string_clean(&string);
252  amxc_var_clean(&variant);
253 }
amxc_string_setf
int amxc_string_setf(amxc_string_t *const string, const char *fmt,...) __attribute__((format(printf
Sets the content of the string using printf like formatting.
amxc_var_dump
int amxc_var_dump(const amxc_var_t *const var, int fd)
Dumps the content of the variant in a human readable manner.
Definition: amxc_variant_dump.c:340
GETI_CHAR
#define GETI_CHAR(a, i)
Convenience macro for getting a char* out of a composite variant by index.
Definition: amxc_variant.h:507

◆ test_can_split_csv_string_with_double_quotes_to_variant()

void test_can_split_csv_string_with_double_quotes_to_variant ( UNUSED void **  state)

Definition at line 476 of file test_amxc_string_split.c.

476  {
477  amxc_string_t string;
478  amxc_var_t variant;
479  const amxc_llist_t* string_list = NULL;
480  amxc_llist_it_t* it = NULL;
481  amxc_var_t* part = NULL;
482 
483  amxc_var_init(&variant);
484 
485  assert_int_equal(amxc_string_init(&string, 0), 0);
486  assert_int_equal(amxc_string_append(&string, "part1,\"[part2,part3],part4\"", 27), 0);
487  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
488  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
489  string_list = amxc_var_constcast(amxc_llist_t, &variant);
490  assert_ptr_not_equal(string_list, NULL);
491  assert_int_equal(amxc_llist_size(string_list), 2);
492 
493  it = amxc_llist_get_first(string_list);
494  part = amxc_var_from_llist_it(it);
495  assert_ptr_not_equal(part, NULL);
496  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
497  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
498  assert_string_equal(amxc_var_constcast(cstring_t, part), "part1");
499 
500  it = amxc_llist_it_get_next(it);
501  part = amxc_var_from_llist_it(it);
502  assert_ptr_not_equal(part, NULL);
503  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
504  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
505  assert_string_equal(amxc_var_constcast(cstring_t, part), "\"[part2,part3],part4\"");
506 
507  amxc_string_clean(&string);
508  amxc_var_clean(&variant);
509 }

◆ test_can_split_csv_string_with_multi_array_to_variant()

void test_can_split_csv_string_with_multi_array_to_variant ( UNUSED void **  state)

Definition at line 333 of file test_amxc_string_split.c.

333  {
334  amxc_string_t string;
335  amxc_var_t variant;
336  const amxc_llist_t* string_list = NULL;
337  amxc_llist_it_t* it = NULL;
338  amxc_var_t* part = NULL;
339 
340  amxc_var_init(&variant);
341 
342  assert_int_equal(amxc_string_init(&string, 0), 0);
343  assert_int_equal(amxc_string_append(&string, "part1,[part2,part3],part4", 25), 0);
344  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
345  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
346  string_list = amxc_var_constcast(amxc_llist_t, &variant);
347  assert_ptr_not_equal(string_list, NULL);
348  assert_int_equal(amxc_llist_size(string_list), 3);
349 
350  it = amxc_llist_get_first(string_list);
351  part = amxc_var_from_llist_it(it);
352  assert_ptr_not_equal(part, NULL);
353  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
354  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
355  assert_string_equal(amxc_var_constcast(cstring_t, part), "part1");
356 
357  it = amxc_llist_it_get_next(it);
358  part = amxc_var_from_llist_it(it);
359  assert_ptr_not_equal(part, NULL);
360  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_LIST);
361  assert_ptr_not_equal(amxc_var_constcast(amxc_llist_t, part), NULL);
362 
363  it = amxc_llist_it_get_next(it);
364  part = amxc_var_from_llist_it(it);
365  assert_ptr_not_equal(part, NULL);
366  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
367  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
368  assert_string_equal(amxc_var_constcast(cstring_t, part), "part4");
369 
370  amxc_string_clean(&string);
371  amxc_var_clean(&variant);
372 }

◆ test_can_split_csv_string_with_single_quotes_to_variant()

void test_can_split_csv_string_with_single_quotes_to_variant ( UNUSED void **  state)

Definition at line 434 of file test_amxc_string_split.c.

434  {
435  amxc_string_t string;
436  amxc_var_t variant;
437  const amxc_llist_t* string_list = NULL;
438  amxc_llist_it_t* it = NULL;
439  amxc_var_t* part = NULL;
440  char* text = "part1,'[part2,part3],part4',long text";
441  amxc_var_init(&variant);
442 
443  assert_int_equal(amxc_string_init(&string, 0), 0);
444  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
445  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
446  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
447  string_list = amxc_var_constcast(amxc_llist_t, &variant);
448  assert_ptr_not_equal(string_list, NULL);
449  assert_int_equal(amxc_llist_size(string_list), 3);
450 
451  it = amxc_llist_get_first(string_list);
452  part = amxc_var_from_llist_it(it);
453  assert_ptr_not_equal(part, NULL);
454  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
455  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
456  assert_string_equal(amxc_var_constcast(cstring_t, part), "part1");
457 
458  it = amxc_llist_it_get_next(it);
459  part = amxc_var_from_llist_it(it);
460  assert_ptr_not_equal(part, NULL);
461  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
462  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
463  assert_string_equal(amxc_var_constcast(cstring_t, part), "'[part2,part3],part4'");
464 
465  it = amxc_llist_it_get_next(it);
466  part = amxc_var_from_llist_it(it);
467  assert_ptr_not_equal(part, NULL);
468  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
469  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
470  assert_string_equal(amxc_var_constcast(cstring_t, part), "long text");
471 
472  amxc_string_clean(&string);
473  amxc_var_clean(&variant);
474 }

◆ test_can_split_ssv_string_to_variant()

void test_can_split_ssv_string_to_variant ( UNUSED void **  state)

Definition at line 547 of file test_amxc_string_split.c.

547  {
548  amxc_string_t string;
549  amxc_var_t variant;
550  const amxc_llist_t* string_list = NULL;
551  amxc_llist_it_t* it = NULL;
552  amxc_var_t* part = NULL;
553 
554  amxc_var_init(&variant);
555 
556  assert_int_equal(amxc_string_init(&string, 0), 0);
557  assert_int_equal(amxc_string_append(&string, "part1 part2 part3", 17), 0);
558  assert_int_equal(amxc_string_ssv_to_var(&string, &variant, NULL), 0);
559  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
560  string_list = amxc_var_constcast(amxc_llist_t, &variant);
561  assert_ptr_not_equal(string_list, NULL);
562  assert_int_equal(amxc_llist_size(string_list), 3);
563 
564  it = amxc_llist_get_first(string_list);
565  part = amxc_var_from_llist_it(it);
566  assert_ptr_not_equal(part, NULL);
567  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
568  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
569  assert_string_equal(amxc_var_constcast(cstring_t, part), "part1");
570 
571  it = amxc_llist_it_get_next(it);
572  part = amxc_var_from_llist_it(it);
573  assert_ptr_not_equal(part, NULL);
574  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
575  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
576  assert_string_equal(amxc_var_constcast(cstring_t, part), "part2");
577 
578  it = amxc_llist_it_get_next(it);
579  part = amxc_var_from_llist_it(it);
580  assert_ptr_not_equal(part, NULL);
581  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
582  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
583  assert_string_equal(amxc_var_constcast(cstring_t, part), "part3");
584 
585  assert_int_not_equal(amxc_string_ssv_to_var(NULL, NULL, NULL), 0);
586  assert_int_not_equal(amxc_string_ssv_to_var(&string, NULL, NULL), 0);
587 
588  amxc_string_clean(&string);
589  amxc_var_clean(&variant);
590 }
amxc_string_ssv_to_var
amxc_string_split_status_t amxc_string_ssv_to_var(const amxc_string_t *const string, amxc_var_t *var, const char **reason)
Split a string in individual parts assuming that the string contains space separated values.
Definition: amxc_string_split.c:562

◆ test_can_split_ssv_string_with_multi_array_to_variant()

void test_can_split_ssv_string_with_multi_array_to_variant ( UNUSED void **  state)

Definition at line 705 of file test_amxc_string_split.c.

705  {
706  amxc_string_t string;
707  amxc_var_t variant;
708  const amxc_llist_t* string_list = NULL;
709  amxc_llist_it_t* it = NULL;
710  amxc_var_t* part = NULL;
711 
712  amxc_var_init(&variant);
713 
714  assert_int_equal(amxc_string_init(&string, 0), 0);
715  assert_int_equal(amxc_string_append(&string, "part1 [part2 part3] part4", 25), 0);
716  assert_int_equal(amxc_string_ssv_to_var(&string, &variant, NULL), 0);
717  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
718  string_list = amxc_var_constcast(amxc_llist_t, &variant);
719  assert_ptr_not_equal(string_list, NULL);
720  assert_int_equal(amxc_llist_size(string_list), 3);
721 
722  it = amxc_llist_get_first(string_list);
723  part = amxc_var_from_llist_it(it);
724  assert_ptr_not_equal(part, NULL);
725  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
726  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
727  assert_string_equal(amxc_var_constcast(cstring_t, part), "part1");
728 
729  it = amxc_llist_it_get_next(it);
730  part = amxc_var_from_llist_it(it);
731  assert_ptr_not_equal(part, NULL);
732  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_LIST);
733  assert_ptr_not_equal(amxc_var_constcast(amxc_llist_t, part), NULL);
734 
735  it = amxc_llist_it_get_next(it);
736  part = amxc_var_from_llist_it(it);
737  assert_ptr_not_equal(part, NULL);
738  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
739  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
740  assert_string_equal(amxc_var_constcast(cstring_t, part), "part4");
741 
742  amxc_string_clean(&string);
743  amxc_var_clean(&variant);
744 }

◆ test_can_split_ssv_string_with_single_quotes_to_variant()

void test_can_split_ssv_string_with_single_quotes_to_variant ( UNUSED void **  state)

Definition at line 652 of file test_amxc_string_split.c.

652  {
653  amxc_string_t string;
654  amxc_var_t variant;
655  const amxc_llist_t* string_list = NULL;
656  amxc_llist_it_t* it = NULL;
657  amxc_var_t* part = NULL;
658 
659  amxc_var_init(&variant);
660 
661  assert_int_equal(amxc_string_init(&string, 0), 0);
662  assert_int_equal(amxc_string_append(&string, "part1 '[part2 part3] part4'", 27), 0);
663  assert_int_equal(amxc_string_ssv_to_var(&string, &variant, NULL), 0);
664  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
665  string_list = amxc_var_constcast(amxc_llist_t, &variant);
666  assert_ptr_not_equal(string_list, NULL);
667  assert_int_equal(amxc_llist_size(string_list), 2);
668 
669  it = amxc_llist_get_first(string_list);
670  part = amxc_var_from_llist_it(it);
671  assert_ptr_not_equal(part, NULL);
672  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
673  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
674  assert_string_equal(amxc_var_constcast(cstring_t, part), "part1");
675 
676  it = amxc_llist_it_get_next(it);
677  part = amxc_var_from_llist_it(it);
678  assert_ptr_not_equal(part, NULL);
679  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
680  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
681  assert_string_equal(amxc_var_constcast(cstring_t, part), "'[part2 part3] part4'");
682 
683  amxc_string_clean(&string);
684  amxc_var_clean(&variant);
685 }

◆ test_can_split_string_using_separator()

void test_can_split_string_using_separator ( UNUSED void **  state)

Definition at line 76 of file test_amxc_string_split.c.

76  {
77  test_cases_t cases[] = {
78  {3, ',', "a,[b,c],d"},
79  {2, ',', "Phonebook.Contact.[FirstName=='ward'].PhoneNumber.*,Phonebook.Contact."},
80  {4, ',', "a , b , c , d"},
81  {8, ',', "a,,b,,c,,d,"},
82  {4, ',', "ab,cd,ef,gh"},
83  {3, ',', "a,\"b,c\",d"},
84  {5, ',', " , ab cd , ef gh , ij kl, "},
85  {5, ',', " , ab cd , 'ef gh, ef gh' , ij kl, "},
86  {5, ',', "[text1 , , , text2,text3]"},
87  {3, ',', "[text1 , ,] , text2,text3"},
88  {4, ',', "text1 , , , [text2,text3]"},
89  {3, ',', "text1 , [ , , text2], text3"},
90  {0, 0, NULL}
91  };
92  amxc_string_t string;
93  amxc_llist_t string_list;
94 
95  amxc_llist_init(&string_list);
96  amxc_string_init(&string, 0);
97  for(int i = 0; cases[i].text != NULL; i++) {
98  char* data = NULL;
99  printf("Split string : %s\n", cases[i].text);
100  fflush(stdout);
101  data = strdup(cases[i].text);
102  amxc_string_push_buffer(&string, data, strlen(cases[i].text) + 1);
103  assert_int_equal(amxc_string_split_to_llist(&string, &string_list, cases[i].separator), 0);
104  assert_int_equal(amxc_llist_size(&string_list), cases[i].parts);
105  amxc_string_take_buffer(&string);
106  free(data);
107  amxc_llist_clean(&string_list, amxc_string_list_it_free);
108  }
109 }
amxc_string_split_to_llist
amxc_string_split_status_t amxc_string_split_to_llist(const amxc_string_t *const string, amxc_llist_t *list, const char separator)
Simple split function using a single character separator.
Definition: amxc_string_split.c:569
amxc_string_push_buffer
int amxc_string_push_buffer(amxc_string_t *const string, char *buffer, size_t length)
Sets the string buffer.
Definition: amxc_string.c:372
amxc_string_take_buffer
char * amxc_string_take_buffer(amxc_string_t *const string)
Takes the string buffer.
Definition: amxc_string.c:356
_test_cases
Definition: test_amxc_string_split.c:69
_test_cases::text
char * text
Definition: test_amxc_string_split.c:72
data
char data[]
Definition: test_amxc_array.c:69

◆ test_can_split_string_using_space_separators()

void test_can_split_string_using_space_separators ( UNUSED void **  state)

Definition at line 111 of file test_amxc_string_split.c.

111  {
112  test_cases_t cases[] = {
113  {1, '\t', "a b c d"},
114  {4, ' ', "a b c d"},
115  {3, '\t', "a [b\t c] d"},
116  {2, '\n', "ab cd\nef\tgh"},
117  {3, ' ', "a \"b c\" d"},
118  {3, ' ', "[text1 text2 text3]"},
119  {3, ' ', " [text1 text2 text3] "},
120  {0, 0, NULL}
121  };
122  amxc_string_t string;
123  amxc_llist_t string_list;
124 
125  amxc_llist_init(&string_list);
126  amxc_string_init(&string, 0);
127  for(int i = 0; cases[i].text != NULL; i++) {
128  char* data = NULL;
129  printf("Split string : %s\n", cases[i].text);
130  data = strdup(cases[i].text);
131  amxc_string_push_buffer(&string, data, strlen(cases[i].text) + 1);
132  assert_int_equal(amxc_string_split_to_llist(&string, &string_list, cases[i].separator), 0);
133  assert_int_equal(amxc_llist_size(&string_list), cases[i].parts);
134  amxc_string_take_buffer(&string);
135  free(data);
136  amxc_llist_clean(&string_list, amxc_string_list_it_free);
137  }
138 }

◆ test_check_parts_are_correct()

void test_check_parts_are_correct ( UNUSED void **  state)

Definition at line 140 of file test_amxc_string_split.c.

140  {
141  amxc_string_t string;
142  char* txt = strdup("a,[b,c],d");
143  amxc_llist_t string_list;
144 
145  amxc_llist_init(&string_list);
146  amxc_string_init(&string, 0);
147  amxc_string_push_buffer(&string, txt, strlen(txt) + 1);
148 
149  assert_int_equal(amxc_string_split_to_llist(&string, &string_list, ','), 0);
150  assert_int_equal(amxc_llist_size(&string_list), 3);
151  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 0), "a");
152  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 1), "[b,c]");
153  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 2), "d");
154  amxc_string_take_buffer(&string);
155  amxc_llist_clean(&string_list, amxc_string_list_it_free);
156  free(txt);
157 
158  txt = strdup("a[b\t c]d");
159  amxc_string_push_buffer(&string, txt, strlen(txt) + 1);
160  assert_int_equal(amxc_string_split_to_llist(&string, &string_list, ','), 0);
161  assert_int_equal(amxc_llist_size(&string_list), 1);
162  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 0), "a[b\tc]d");
163  amxc_llist_clean(&string_list, amxc_string_list_it_free);
164 
165  assert_int_equal(amxc_string_split_to_llist(&string, &string_list, ' '), 0);
166  assert_int_equal(amxc_llist_size(&string_list), 3);
167  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 0), "a");
168  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 1), "[b\tc]");
169  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 2), "d");
170  amxc_string_take_buffer(&string);
171  amxc_llist_clean(&string_list, amxc_string_list_it_free);
172  free(txt);
173 
174  txt = strdup("a [b\t c] d");
175  amxc_string_push_buffer(&string, txt, strlen(txt) + 1);
176  assert_int_equal(amxc_string_split_to_llist(&string, &string_list, ' '), 0);
177  assert_int_equal(amxc_llist_size(&string_list), 3);
178  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 0), "a");
179  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 1), "[b\tc]");
180  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 2), "d");
181  amxc_string_take_buffer(&string);
182  amxc_llist_clean(&string_list, amxc_string_list_it_free);
183  free(txt);
184 
185  txt = strdup("[a b\tc d text more text]");
186  amxc_string_push_buffer(&string, txt, strlen(txt) + 1);
187  assert_int_equal(amxc_string_split_to_llist(&string, &string_list, ' '), 0);
188  assert_int_equal(amxc_llist_size(&string_list), 6);
189  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 0), "a");
190  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 1), "b\tc");
191  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 2), "d");
192  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 3), "text");
193  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 4), "more");
194  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 5), "text");
195  amxc_string_take_buffer(&string);
196  amxc_llist_clean(&string_list, amxc_string_list_it_free);
197  free(txt);
198 }

◆ test_functions_validates_input_arguments()

void test_functions_validates_input_arguments ( UNUSED void **  state)

Definition at line 1006 of file test_amxc_string_split.c.

1006  {
1007  amxc_string_t string;
1008  amxc_llist_t string_list;
1009 
1010  const char* text = "some,more [text,here";
1011  amxc_llist_init(&string_list);
1012  assert_int_equal(amxc_string_init(&string, 0), 0);
1013  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
1014 
1015  assert_int_not_equal(amxc_string_split_to_llist(NULL, &string_list, ':'), 0);
1016  assert_int_equal(amxc_llist_size(&string_list), 0);
1017  assert_int_not_equal(amxc_string_split_to_llist(&string, NULL, ':'), 0);
1018  assert_int_equal(amxc_llist_size(&string_list), 0);
1019  assert_int_not_equal(amxc_string_split_to_llist(&string, &string_list, 'a'), 0);
1020  assert_int_equal(amxc_llist_size(&string_list), 0);
1021  assert_int_not_equal(amxc_string_split_to_llist(&string, &string_list, '9'), 0);
1022  assert_int_equal(amxc_llist_size(&string_list), 0);
1023  assert_int_not_equal(amxc_string_split_to_llist(&string, &string_list, ']'), 0);
1024  assert_int_equal(amxc_llist_size(&string_list), 0);
1025  assert_int_not_equal(amxc_string_split_to_llist(&string, &string_list, '['), 0);
1026  assert_int_equal(amxc_llist_size(&string_list), 0);
1027  assert_int_not_equal(amxc_string_split_to_llist(&string, &string_list, ','), 0);
1028  assert_int_equal(amxc_llist_size(&string_list), 0);
1029 
1030  assert_ptr_equal(amxc_string_get_text_from_llist(&string_list, 100), NULL);
1031  assert_ptr_equal(amxc_string_get_text_from_llist(NULL, 100), NULL);
1032 
1033  amxc_string_clean(&string);
1034  amxc_llist_clean(&string_list, amxc_string_list_it_free);
1035 }

◆ test_split_csv_can_handle_empty_sublist()

void test_split_csv_can_handle_empty_sublist ( UNUSED void **  state)

Definition at line 511 of file test_amxc_string_split.c.

511  {
512  amxc_string_t string;
513  amxc_var_t variant;
514  const amxc_llist_t* string_list = NULL;
515  amxc_llist_it_t* it = NULL;
516  amxc_var_t* part = NULL;
517  const char* txt = "part1,[],part4";
518 
519  amxc_var_init(&variant);
520 
521  assert_int_equal(amxc_string_init(&string, 0), 0);
522  assert_int_equal(amxc_string_append(&string, txt, strlen(txt)), 0);
523  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
524  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
525  string_list = amxc_var_constcast(amxc_llist_t, &variant);
526  assert_ptr_not_equal(string_list, NULL);
527  assert_int_equal(amxc_llist_size(string_list), 3);
528 
529  it = amxc_llist_get_first(string_list);
530  part = amxc_var_from_llist_it(it);
531  assert_ptr_not_equal(part, NULL);
532  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_CSTRING);
533  assert_ptr_not_equal(amxc_var_constcast(cstring_t, part), NULL);
534  assert_string_equal(amxc_var_constcast(cstring_t, part), "part1");
535 
536  it = amxc_llist_it_get_next(it);
537  part = amxc_var_from_llist_it(it);
538  assert_ptr_not_equal(part, NULL);
539  assert_int_equal(amxc_var_type_of(part), AMXC_VAR_ID_LIST);
540  string_list = amxc_var_constcast(amxc_llist_t, part);
541  assert_true(amxc_llist_is_empty(string_list));
542 
543  amxc_string_clean(&string);
544  amxc_var_clean(&variant);
545 }
amxc_llist_is_empty
bool amxc_llist_is_empty(const amxc_llist_t *const llist)
Checks that the linked list is empty.
Definition: amxc_llist.c:165

◆ test_split_csv_handles_sequence_of_commas_as_multiple_items()

void test_split_csv_handles_sequence_of_commas_as_multiple_items ( UNUSED void **  state)

Definition at line 255 of file test_amxc_string_split.c.

255  {
256  amxc_string_t string;
257  amxc_var_t variant;
258  const amxc_llist_t* string_list = NULL;
259  const char* text = "a,,,,,b";
260 
261  amxc_var_init(&variant);
262  assert_int_equal(amxc_string_init(&string, 0), 0);
263  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
264 
265  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
266  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
267  string_list = amxc_var_constcast(amxc_llist_t, &variant);
268  assert_ptr_not_equal(string_list, NULL);
269  assert_int_equal(amxc_llist_size(string_list), 6);
270 
271  amxc_string_clean(&string);
272  amxc_var_clean(&variant);
273 }

◆ test_split_csv_string_handles_comma_in_quotes_correctly()

void test_split_csv_string_handles_comma_in_quotes_correctly ( UNUSED void **  state)

Definition at line 275 of file test_amxc_string_split.c.

275  {
276  amxc_string_t string;
277  amxc_var_t variant;
278  const amxc_llist_t* string_list = NULL;
279  const char* text = "','";
280 
281  amxc_var_init(&variant);
282  assert_int_equal(amxc_string_init(&string, 0), 0);
283  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
284 
285  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
286  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
287  string_list = amxc_var_constcast(amxc_llist_t, &variant);
288  assert_ptr_not_equal(string_list, NULL);
289  assert_int_equal(amxc_llist_size(string_list), 1);
290 
291  amxc_string_reset(&string);
292  text = "\",\"";
293  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
294 
295  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
296  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
297  string_list = amxc_var_constcast(amxc_llist_t, &variant);
298  assert_ptr_not_equal(string_list, NULL);
299  assert_int_equal(amxc_llist_size(string_list), 1);
300 
301  amxc_string_reset(&string);
302  text = ",";
303  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
304 
305  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
306  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
307  string_list = amxc_var_constcast(amxc_llist_t, &variant);
308  assert_ptr_not_equal(string_list, NULL);
309  assert_int_equal(amxc_llist_size(string_list), 2);
310 
311  amxc_string_clean(&string);
312  amxc_var_clean(&variant);
313 }
amxc_string_reset
void amxc_string_reset(amxc_string_t *const string)
Resets the buffer, reset the content to all 0.
Definition: amxc_string.c:203

◆ test_split_csv_string_handles_empty_string_correctly()

void test_split_csv_string_handles_empty_string_correctly ( UNUSED void **  state)

Definition at line 315 of file test_amxc_string_split.c.

315  {
316  amxc_string_t string;
317  amxc_var_t variant;
318  const amxc_llist_t* string_list = NULL;
319 
320  amxc_var_init(&variant);
321  assert_int_equal(amxc_string_init(&string, 0), 0);
322 
323  assert_int_equal(amxc_string_csv_to_var(&string, &variant, NULL), 0);
324  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
325  string_list = amxc_var_constcast(amxc_llist_t, &variant);
326  assert_ptr_not_equal(string_list, NULL);
327  assert_int_equal(amxc_llist_size(string_list), 0);
328 
329  amxc_string_reset(&string);
330  amxc_var_clean(&variant);
331 }

◆ test_split_ssv_handles_sequence_of_spaces_as_one_separator()

void test_split_ssv_handles_sequence_of_spaces_as_one_separator ( UNUSED void **  state)

Definition at line 592 of file test_amxc_string_split.c.

592  {
593  amxc_string_t string;
594  amxc_var_t variant;
595  const amxc_llist_t* string_list = NULL;
596  const char* text = "a \t \tb";
597 
598  amxc_var_init(&variant);
599  assert_int_equal(amxc_string_init(&string, 0), 0);
600  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
601 
602  assert_int_equal(amxc_string_ssv_to_var(&string, &variant, NULL), 0);
603  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
604  string_list = amxc_var_constcast(amxc_llist_t, &variant);
605  assert_ptr_not_equal(string_list, NULL);
606  assert_int_equal(amxc_llist_size(string_list), 2);
607 
608  amxc_string_clean(&string);
609  amxc_var_clean(&variant);
610 }

◆ test_split_ssv_string_handles_empty_string_correctly()

void test_split_ssv_string_handles_empty_string_correctly ( UNUSED void **  state)

Definition at line 687 of file test_amxc_string_split.c.

687  {
688  amxc_string_t string;
689  amxc_var_t variant;
690  const amxc_llist_t* string_list = NULL;
691 
692  amxc_var_init(&variant);
693  assert_int_equal(amxc_string_init(&string, 0), 0);
694 
695  assert_int_equal(amxc_string_ssv_to_var(&string, &variant, NULL), 0);
696  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
697  string_list = amxc_var_constcast(amxc_llist_t, &variant);
698  assert_ptr_not_equal(string_list, NULL);
699  assert_int_equal(amxc_llist_size(string_list), 0);
700 
701  amxc_string_reset(&string);
702  amxc_var_clean(&variant);
703 }

◆ test_split_ssv_string_handles_spaces_in_quotes_correctly()

void test_split_ssv_string_handles_spaces_in_quotes_correctly ( UNUSED void **  state)

Definition at line 612 of file test_amxc_string_split.c.

612  {
613  amxc_string_t string;
614  amxc_var_t variant;
615  const amxc_llist_t* string_list = NULL;
616  const char* text = "' '";
617 
618  amxc_var_init(&variant);
619  assert_int_equal(amxc_string_init(&string, 0), 0);
620  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
621 
622  assert_int_equal(amxc_string_ssv_to_var(&string, &variant, NULL), 0);
623  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
624  string_list = amxc_var_constcast(amxc_llist_t, &variant);
625  assert_ptr_not_equal(string_list, NULL);
626  assert_int_equal(amxc_llist_size(string_list), 1);
627 
628  amxc_string_reset(&string);
629  text = "\" \"";
630  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
631 
632  assert_int_equal(amxc_string_ssv_to_var(&string, &variant, NULL), 0);
633  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
634  string_list = amxc_var_constcast(amxc_llist_t, &variant);
635  assert_ptr_not_equal(string_list, NULL);
636  assert_int_equal(amxc_llist_size(string_list), 1);
637 
638  amxc_string_reset(&string);
639  text = " ";
640  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
641 
642  assert_int_equal(amxc_string_ssv_to_var(&string, &variant, NULL), 0);
643  assert_int_equal(amxc_var_type_of(&variant), AMXC_VAR_ID_LIST);
644  string_list = amxc_var_constcast(amxc_llist_t, &variant);
645  assert_ptr_not_equal(string_list, NULL);
646  assert_int_equal(amxc_llist_size(string_list), 0);
647 
648  amxc_string_clean(&string);
649  amxc_var_clean(&variant);
650 }

◆ test_split_string_on_new_line()

void test_split_string_on_new_line ( UNUSED void **  state)

Definition at line 1037 of file test_amxc_string_split.c.

1037  {
1038  amxc_string_t string;
1039  amxc_llist_t string_list;
1040 
1041  amxc_llist_init(&string_list);
1042  amxc_string_init(&string, 0);
1043  amxc_string_setf(&string, "This is the first line\nThis is the second line");
1044 
1045  assert_int_equal(amxc_string_split_to_llist(&string, &string_list, '\n'), 0);
1046  assert_int_equal(amxc_llist_size(&string_list), 2);
1047 
1048  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 0), "This is the first line");
1049  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 1), "This is the second line");
1050 
1051  amxc_string_clean(&string);
1052  amxc_llist_clean(&string_list, amxc_string_list_it_free);
1053 
1054  amxc_string_setf(&string, "This is the first line \n This is the second line");
1055 
1056  assert_int_equal(amxc_string_split_to_llist(&string, &string_list, '\n'), 0);
1057  assert_int_equal(amxc_llist_size(&string_list), 2);
1058 
1059  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 0), "This is the first line ");
1060  assert_string_equal(amxc_string_get_text_from_llist(&string_list, 1), "This is the second line");
1061 
1062  amxc_llist_clean(&string_list, amxc_string_list_it_free);
1063 
1064  assert_int_equal(amxc_string_split_to_llist(&string, &string_list, ' '), 0);
1065  assert_int_equal(amxc_llist_size(&string_list), 10);
1066 
1067  amxc_string_clean(&string);
1068  amxc_llist_clean(&string_list, amxc_string_list_it_free);
1069 }

◆ test_split_word_checks_curly_brackets()

void test_split_word_checks_curly_brackets ( UNUSED void **  state)

Definition at line 790 of file test_amxc_string_split.c.

790  {
791  amxc_string_t string;
792  amxc_llist_t string_list;
793  const char* text = "{1, 2, 3}";
794  const char* reason = "";
795 
796  amxc_llist_init(&string_list);
797 
798  assert_int_equal(amxc_string_init(&string, 0), 0);
799  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
800  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), 0);
801  assert_int_equal(amxc_llist_size(&string_list), 9);
802 
803  amxc_llist_clean(&string_list, amxc_string_list_it_free);
804  amxc_string_reset(&string);
805 
806  text = "{1, 2, 3";
807  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
808  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), AMXC_ERROR_STRING_MISSING_CBRACKET);
809  assert_int_not_equal(strlen(reason), 0);
810  printf("%s\n", reason);
811  assert_int_equal(amxc_llist_size(&string_list), 0);
812  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), AMXC_ERROR_STRING_MISSING_CBRACKET);
813 
814  amxc_llist_clean(&string_list, amxc_string_list_it_free);
815  amxc_string_reset(&string);
816 
817  text = "1, 2, 3}";
818  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
819  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), AMXC_ERROR_STRING_MISSING_CBRACKET);
820  assert_int_not_equal(strlen(reason), 0);
821  printf("%s\n", reason);
822  assert_int_equal(amxc_llist_size(&string_list), 0);
823  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), AMXC_ERROR_STRING_MISSING_CBRACKET);
824 
825  amxc_llist_clean(&string_list, amxc_string_list_it_free);
826  amxc_string_clean(&string);
827 }
AMXC_ERROR_STRING_MISSING_CBRACKET
@ AMXC_ERROR_STRING_MISSING_CBRACKET
Definition: amxc_string_split.h:89

◆ test_split_word_checks_quotes()

void test_split_word_checks_quotes ( UNUSED void **  state)

Definition at line 746 of file test_amxc_string_split.c.

746  {
747  amxc_string_t string;
748  amxc_llist_t string_list;
749  const char* text = "\"Double quoted string \\\" with double and ' single quote\"";
750  const char* reason = "";
751 
752  amxc_llist_init(&string_list);
753 
754  assert_int_equal(amxc_string_init(&string, 0), 0);
755  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
756  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), 0);
757  assert_int_equal(amxc_llist_size(&string_list), 3);
758 
759  amxc_llist_clean(&string_list, amxc_string_list_it_free);
760  amxc_string_reset(&string);
761  text = "\"Missing double quote";
762  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
763  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), AMXC_ERROR_STRING_MISSING_DQUOTE);
764  assert_int_not_equal(strlen(reason), 0);
765  printf("%s\n", reason);
766  assert_int_equal(amxc_llist_size(&string_list), 0);
767  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), AMXC_ERROR_STRING_MISSING_DQUOTE);
768 
769  amxc_llist_clean(&string_list, amxc_string_list_it_free);
770  amxc_string_reset(&string);
771  text = "'Missing single quote";
772  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
773  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), AMXC_ERROR_STRING_MISSING_SQUOTE);
774  assert_int_not_equal(strlen(reason), 0);
775  printf("%s\n", reason);
776  assert_int_equal(amxc_llist_size(&string_list), 0);
777  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), AMXC_ERROR_STRING_MISSING_SQUOTE);
778 
779  amxc_llist_clean(&string_list, amxc_string_list_it_free);
780  amxc_string_reset(&string);
781  text = "'single quoted string with double \" and \\' single quote'";
782  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
783  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), 0);
784  assert_int_equal(amxc_llist_size(&string_list), 3);
785 
786  amxc_llist_clean(&string_list, amxc_string_list_it_free);
787  amxc_string_clean(&string);
788 }
AMXC_ERROR_STRING_MISSING_SQUOTE
@ AMXC_ERROR_STRING_MISSING_SQUOTE
Definition: amxc_string_split.h:86
AMXC_ERROR_STRING_MISSING_DQUOTE
@ AMXC_ERROR_STRING_MISSING_DQUOTE
Definition: amxc_string_split.h:85

◆ test_split_word_checks_round_brackets()

void test_split_word_checks_round_brackets ( UNUSED void **  state)

Definition at line 868 of file test_amxc_string_split.c.

868  {
869  amxc_string_t string;
870  amxc_llist_t string_list;
871  const char* text = "(1, 2, 3)";
872  const char* reason = "";
873 
874  amxc_llist_init(&string_list);
875 
876  assert_int_equal(amxc_string_init(&string, 0), 0);
877  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
878  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), 0);
879  assert_int_equal(amxc_llist_size(&string_list), 9);
880 
881  amxc_llist_clean(&string_list, amxc_string_list_it_free);
882  amxc_string_reset(&string);
883 
884  text = "(1, 2, 3";
885  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
886  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), AMXC_ERROR_STRING_MISSING_RBRACKET);
887  assert_int_not_equal(strlen(reason), 0);
888  printf("%s\n", reason);
889  assert_int_equal(amxc_llist_size(&string_list), 0);
890  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), AMXC_ERROR_STRING_MISSING_RBRACKET);
891 
892  amxc_llist_clean(&string_list, amxc_string_list_it_free);
893  amxc_string_reset(&string);
894 
895  text = "1, 2, 3)";
896  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
897  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), AMXC_ERROR_STRING_MISSING_RBRACKET);
898  assert_int_not_equal(strlen(reason), 0);
899  printf("%s\n", reason);
900  assert_int_equal(amxc_llist_size(&string_list), 0);
901  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), AMXC_ERROR_STRING_MISSING_RBRACKET);
902 
903  amxc_llist_clean(&string_list, amxc_string_list_it_free);
904  amxc_string_clean(&string);
905 }
AMXC_ERROR_STRING_MISSING_RBRACKET
@ AMXC_ERROR_STRING_MISSING_RBRACKET
Definition: amxc_string_split.h:87

◆ test_split_word_checks_square_brackets()

void test_split_word_checks_square_brackets ( UNUSED void **  state)

Definition at line 829 of file test_amxc_string_split.c.

829  {
830  amxc_string_t string;
831  amxc_llist_t string_list;
832  const char* text = "[1, 2, 3]";
833  const char* reason = "";
834 
835  amxc_llist_init(&string_list);
836 
837  assert_int_equal(amxc_string_init(&string, 0), 0);
838  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
839  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), 0);
840  assert_int_equal(amxc_llist_size(&string_list), 9);
841 
842  amxc_llist_clean(&string_list, amxc_string_list_it_free);
843  amxc_string_reset(&string);
844 
845  text = "[1, 2, 3";
846  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
847  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), AMXC_ERROR_STRING_MISSING_SBRACKET);
848  assert_int_not_equal(strlen(reason), 0);
849  printf("%s\n", reason);
850  assert_int_equal(amxc_llist_size(&string_list), 0);
851  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), AMXC_ERROR_STRING_MISSING_SBRACKET);
852 
853  amxc_llist_clean(&string_list, amxc_string_list_it_free);
854  amxc_string_reset(&string);
855 
856  text = "1, 2, 3]";
857  assert_int_equal(amxc_string_append(&string, text, strlen(text)), 0);
858  assert_int_equal(amxc_string_split_word(&string, &string_list, &reason), AMXC_ERROR_STRING_MISSING_SBRACKET);
859  assert_int_not_equal(strlen(reason), 0);
860  printf("%s\n", reason);
861  assert_int_equal(amxc_llist_size(&string_list), 0);
862  assert_int_equal(amxc_string_split_word(&string, &string_list, NULL), AMXC_ERROR_STRING_MISSING_SBRACKET);
863 
864  amxc_llist_clean(&string_list, amxc_string_list_it_free);
865  amxc_string_clean(&string);
866 }
AMXC_ERROR_STRING_MISSING_SBRACKET
@ AMXC_ERROR_STRING_MISSING_SBRACKET
Definition: amxc_string_split.h:88