Skip to content
Snippets Groups Projects
Commit ead56041 authored by Jonathan Schöbel's avatar Jonathan Schöbel
Browse files

NodeFragment: added tests for insert Attr methods. 

Hand in still missing tests.
parent e8deb8ce
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
sefht.geany
+ 1
− 1
View file @ ead56041
......@@ -60,7 +60,7 @@ FILE_NAME_27=1078;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fp
FILE_NAME_28=1044;Make;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2FMakefile.am;0;8
FILE_NAME_29=1085;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_cms.c;0;8
FILE_NAME_30=3283;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_data.c;0;8
FILE_NAME_31=12038;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_node_fragment.c;0;8
FILE_NAME_31=89037;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_node_fragment.c;0;8
FILE_NAME_32=15195;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_attr.c;0;8
FILE_NAME_33=11068;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_text.c;0;8
FILE_NAME_34=5744;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_validator.c;0;8
......
tests/test_node_fragment.c
+ 1162
− 0
View file @ ead56041
......@@ -519,6 +519,1156 @@ START_TEST(test_node_fragment_attr_get_with_status)
}
END_TEST
START_TEST(test_node_fragment_attr_insert_no_status)
{
char * name;
char * value;
SH_Attr * attr;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
struct SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test insert - success */
attr = SH_Attr_copy (attr1, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
result = insert_attr (fragment, attr, 0, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (1, fragment->attr_n);
ck_assert_int_le (1, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[0].name);
ck_assert_str_eq (attr1->value, fragment->attrs[0].value);
/* test insert before - success */
attr = SH_Attr_copy (attr2, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
result = insert_attr (fragment, attr, 0, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (2, fragment->attr_n);
ck_assert_int_le (2, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
ck_assert_str_eq (attr2->name, fragment->attrs[0].name);
ck_assert_str_eq (attr2->value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[1].name);
ck_assert_str_eq (attr1->value, fragment->attrs[1].value);
/* test insert after - success */
attr = SH_Attr_copy (attr3, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
result = insert_attr (fragment, attr, 2, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert_int_le (3, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (name, fragment->attrs[2].name);
ck_assert_ptr_eq (value, fragment->attrs[2].value);
ck_assert_str_eq (attr2->name, fragment->attrs[0].name);
ck_assert_str_eq (attr2->value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[1].name);
ck_assert_str_eq (attr1->value, fragment->attrs[1].value);
ck_assert_str_eq (attr3->name, fragment->attrs[2].name);
ck_assert_str_eq (attr3->value, fragment->attrs[2].value);
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
SH_Attr_free (attr1);
SH_Attr_free (attr2);
SH_Attr_free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_with_status)
{
struct SH_Status status;
char * name;
char * value;
SH_Attr * attr;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
struct SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test insert - success */
attr = SH_Attr_copy (attr1, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
_status_preinit (status);
result = insert_attr (fragment, attr, 0, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_int_eq (1, fragment->attr_n);
ck_assert_int_le (1, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[0].name);
ck_assert_str_eq (attr1->value, fragment->attrs[0].value);
/* test insert before - success */
attr = SH_Attr_copy (attr2, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
_status_preinit (status);
result = insert_attr (fragment, attr, 0, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_int_eq (2, fragment->attr_n);
ck_assert_int_le (2, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
ck_assert_str_eq (attr2->name, fragment->attrs[0].name);
ck_assert_str_eq (attr2->value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[1].name);
ck_assert_str_eq (attr1->value, fragment->attrs[1].value);
/* test insert after - success */
attr = SH_Attr_copy (attr3, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
_status_preinit (status);
result = insert_attr (fragment, attr, 2, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert_int_le (3, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (name, fragment->attrs[2].name);
ck_assert_ptr_eq (value, fragment->attrs[2].value);
ck_assert_str_eq (attr2->name, fragment->attrs[0].name);
ck_assert_str_eq (attr2->value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[1].name);
ck_assert_str_eq (attr1->value, fragment->attrs[1].value);
ck_assert_str_eq (attr3->name, fragment->attrs[2].name);
ck_assert_str_eq (attr3->value, fragment->attrs[2].value);
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
SH_Attr_free (attr1);
SH_Attr_free (attr2);
SH_Attr_free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_new_no_status)
{
char * name;
char * value;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
struct SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test insert - success */
name = Attr_get_name (attr1);
value = Attr_get_value (attr1);
result = insert_attr_new (fragment, name, value, 0, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (1, fragment->attr_n);
ck_assert_int_le (1, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (attr1->name, fragment->attrs[0].name);
ck_assert_ptr_eq (attr1->value, fragment->attrs[0].value);
/* test insert before - success */
name = Attr_get_name (attr2);
value = Attr_get_value (attr2);
result = insert_attr_new (fragment, name, value, 0, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (2, fragment->attr_n);
ck_assert_int_le (2, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (attr2->name, fragment->attrs[0].name);
ck_assert_ptr_eq (attr2->value, fragment->attrs[0].value);
ck_assert_ptr_eq (attr1->name, fragment->attrs[1].name);
ck_assert_ptr_eq (attr1->value, fragment->attrs[1].value);
/* test insert after - success */
name = Attr_get_name (attr3);
value = Attr_get_value (attr3);
result = insert_attr_new (fragment, name, value, 2, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert_int_le (3, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (attr2->name, fragment->attrs[0].name);
ck_assert_ptr_eq (attr2->value, fragment->attrs[0].value);
ck_assert_ptr_eq (attr1->name, fragment->attrs[1].name);
ck_assert_ptr_eq (attr1->value, fragment->attrs[1].value);
ck_assert_ptr_eq (attr3->name, fragment->attrs[2].name);
ck_assert_ptr_eq (attr3->value, fragment->attrs[2].value);
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
free (attr1);
free (attr2);
free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_new_with_status)
{
struct SH_Status status;
char * name;
char * value;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
struct SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test insert - success */
name = Attr_get_name (attr1);
value = Attr_get_value (attr1);
_status_preinit (status);
result = insert_attr_new (fragment, name, value, 0, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_int_eq (1, fragment->attr_n);
ck_assert_int_le (1, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (attr1->name, fragment->attrs[0].name);
ck_assert_ptr_eq (attr1->value, fragment->attrs[0].value);
/* test insert before - success */
name = Attr_get_name (attr2);
value = Attr_get_value (attr2);
_status_preinit (status);
result = insert_attr_new (fragment, name, value, 0, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_int_eq (2, fragment->attr_n);
ck_assert_int_le (2, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (attr2->name, fragment->attrs[0].name);
ck_assert_ptr_eq (attr2->value, fragment->attrs[0].value);
ck_assert_ptr_eq (attr1->name, fragment->attrs[1].name);
ck_assert_ptr_eq (attr1->value, fragment->attrs[1].value);
/* test insert after - success */
name = Attr_get_name (attr3);
value = Attr_get_value (attr3);
_status_preinit (status);
result = insert_attr_new (fragment, name, value, 2, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert_int_le (3, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_eq (attr2->name, fragment->attrs[0].name);
ck_assert_ptr_eq (attr2->value, fragment->attrs[0].value);
ck_assert_ptr_eq (attr1->name, fragment->attrs[1].name);
ck_assert_ptr_eq (attr1->value, fragment->attrs[1].value);
ck_assert_ptr_eq (attr3->name, fragment->attrs[2].name);
ck_assert_ptr_eq (attr3->value, fragment->attrs[2].value);
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
free (attr1);
free (attr2);
free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_copy_no_status)
{
char * name;
char * value;
SH_Attr * attr;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
struct SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test insert - success */
attr = SH_Attr_copy (attr1, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
result = insert_attr_copy (fragment, attr, 0, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (1, fragment->attr_n);
ck_assert_int_le (1, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_ne (name, fragment->attrs[0].name);
ck_assert_ptr_ne (value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[0].name);
ck_assert_str_eq (attr1->value, fragment->attrs[0].value);
/* test insert before - success */
attr = SH_Attr_copy (attr2, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
result = insert_attr_copy (fragment, attr, 0, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (2, fragment->attr_n);
ck_assert_int_le (2, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_ne (name, fragment->attrs[0].name);
ck_assert_ptr_ne (value, fragment->attrs[0].value);
ck_assert_str_eq (attr2->name, fragment->attrs[0].name);
ck_assert_str_eq (attr2->value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[1].name);
ck_assert_str_eq (attr1->value, fragment->attrs[1].value);
/* test insert after - success */
attr = SH_Attr_copy (attr3, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
result = insert_attr_copy (fragment, attr, 2, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert_int_le (3, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_ne (name, fragment->attrs[2].name);
ck_assert_ptr_ne (value, fragment->attrs[2].value);
ck_assert_str_eq (attr2->name, fragment->attrs[0].name);
ck_assert_str_eq (attr2->value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[1].name);
ck_assert_str_eq (attr1->value, fragment->attrs[1].value);
ck_assert_str_eq (attr3->name, fragment->attrs[2].name);
ck_assert_str_eq (attr3->value, fragment->attrs[2].value);
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
SH_Attr_free (attr1);
SH_Attr_free (attr2);
SH_Attr_free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_copy_with_status)
{
struct SH_Status status;
char * name;
char * value;
SH_Attr * attr;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
struct SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test insert - success */
attr = SH_Attr_copy (attr1, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
_status_preinit (status);
result = insert_attr_copy (fragment, attr, 0, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_int_eq (1, fragment->attr_n);
ck_assert_int_le (1, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_ne (name, fragment->attrs[0].name);
ck_assert_ptr_ne (value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[0].name);
ck_assert_str_eq (attr1->value, fragment->attrs[0].value);
/* test insert before - success */
attr = SH_Attr_copy (attr2, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
_status_preinit (status);
result = insert_attr_copy (fragment, attr, 0, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_int_eq (2, fragment->attr_n);
ck_assert_int_le (2, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_ne (name, fragment->attrs[0].name);
ck_assert_ptr_ne (value, fragment->attrs[0].value);
ck_assert_str_eq (attr2->name, fragment->attrs[0].name);
ck_assert_str_eq (attr2->value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[1].name);
ck_assert_str_eq (attr1->value, fragment->attrs[1].value);
/* test insert after - success */
attr = SH_Attr_copy (attr3, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
_status_preinit (status);
result = insert_attr_copy (fragment, attr, 2, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert_int_le (3, fragment->attr_s);
ck_assert_int_eq (ATTR_CHUNK, fragment->attr_s);
ck_assert_ptr_ne (name, fragment->attrs[2].name);
ck_assert_ptr_ne (value, fragment->attrs[2].value);
ck_assert_str_eq (attr2->name, fragment->attrs[0].name);
ck_assert_str_eq (attr2->value, fragment->attrs[0].value);
ck_assert_str_eq (attr1->name, fragment->attrs[1].name);
ck_assert_str_eq (attr1->value, fragment->attrs[1].value);
ck_assert_str_eq (attr3->name, fragment->attrs[2].name);
ck_assert_str_eq (attr3->value, fragment->attrs[2].value);
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
SH_Attr_free (attr1);
SH_Attr_free (attr2);
SH_Attr_free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_insert_no_status)
{
char * name;
char * value;
SH_Attr * attr;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test - out of bounds */
result = SH_NodeFragment_insert_attr (fragment, attr1, 1, NULL);
ck_assert_int_eq (FALSE, result);
/* test */
attr = SH_Attr_copy (attr2, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
result = SH_NodeFragment_insert_attr (fragment, attr, 0, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
/* test - insert before */
attr = SH_Attr_copy (attr1, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
result = SH_NodeFragment_prepend_attr (fragment, attr, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
/* test - insert after */
attr = SH_Attr_copy (attr3, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
result = SH_NodeFragment_append_attr (fragment, attr, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_ptr_eq (name, fragment->attrs[2].name);
ck_assert_ptr_eq (value, fragment->attrs[2].value);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert (Attr_is_equal (attr1, &fragment->attrs[0]));
ck_assert (Attr_is_equal (attr2, &fragment->attrs[1]));
ck_assert (Attr_is_equal (attr3, &fragment->attrs[2]));
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
SH_Attr_free (attr1);
SH_Attr_free (attr2);
SH_Attr_free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_insert_with_status)
{
struct SH_Status status;
char * name;
char * value;
SH_Attr * attr;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test - out of bounds */
_status_preinit (status);
result = SH_NodeFragment_insert_attr (fragment, attr1, 1, &status);
ck_assert_int_eq (FALSE, result);
ck_assert_int_eq (E_VALUE, status.status);
/* test */
attr = SH_Attr_copy (attr2, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
_status_preinit (status);
result = SH_NodeFragment_insert_attr (fragment, attr, 0, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
/* test - insert before */
attr = SH_Attr_copy (attr1, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
_status_preinit (status);
result = SH_NodeFragment_prepend_attr (fragment, attr, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
/* test - insert after */
attr = SH_Attr_copy (attr3, NULL);
ck_assert_ptr_ne (NULL, attr);
name = Attr_get_name (attr);
value = Attr_get_value (attr);
_status_preinit (status);
result = SH_NodeFragment_append_attr (fragment, attr, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_ptr_eq (name, fragment->attrs[2].name);
ck_assert_ptr_eq (value, fragment->attrs[2].value);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert (Attr_is_equal (attr1, &fragment->attrs[0]));
ck_assert (Attr_is_equal (attr2, &fragment->attrs[1]));
ck_assert (Attr_is_equal (attr3, &fragment->attrs[2]));
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
SH_Attr_free (attr1);
SH_Attr_free (attr2);
SH_Attr_free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_insert_new_no_status)
{
char * name;
char * value;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test - out of bounds */
name = Attr_get_name (attr1);
value = Attr_get_value (attr1);
result = SH_NodeFragment_insert_attr_new (fragment, name, value,
1, NULL);
ck_assert_int_eq (FALSE, result);
/* test */
name = Attr_get_name (attr2);
value = Attr_get_value (attr2);
result = SH_NodeFragment_insert_attr_new (fragment, name, value,
0, NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
/* test - insert before */
name = Attr_get_name (attr1);
value = Attr_get_value (attr1);
result = SH_NodeFragment_prepend_attr_new (fragment, name, value,
NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
/* test - insert after */
name = Attr_get_name (attr3);
value = Attr_get_value (attr3);
result = SH_NodeFragment_append_attr_new (fragment, name, value,
NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_ptr_eq (name, fragment->attrs[2].name);
ck_assert_ptr_eq (value, fragment->attrs[2].value);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert (Attr_is_equal (attr1, &fragment->attrs[0]));
ck_assert (Attr_is_equal (attr2, &fragment->attrs[1]));
ck_assert (Attr_is_equal (attr3, &fragment->attrs[2]));
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
free (attr1);
free (attr2);
free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_insert_new_with_status)
{
struct SH_Status status;
char * name;
char * value;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test - out of bounds */
name = Attr_get_name (attr1);
value = Attr_get_value (attr1);
_status_preinit (status);
result = SH_NodeFragment_insert_attr_new (fragment, name, value,
1, &status);
ck_assert_int_eq (FALSE, result);
ck_assert_int_eq (E_VALUE, status.status);
/* test */
name = Attr_get_name (attr2);
value = Attr_get_value (attr2);
_status_preinit (status);
result = SH_NodeFragment_insert_attr_new (fragment, name, value,
0, &status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
/* test - insert before */
name = Attr_get_name (attr1);
value = Attr_get_value (attr1);
_status_preinit (status);
result = SH_NodeFragment_prepend_attr_new (fragment, name, value,
&status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_ptr_eq (name, fragment->attrs[0].name);
ck_assert_ptr_eq (value, fragment->attrs[0].value);
/* test - insert after */
name = Attr_get_name (attr3);
value = Attr_get_value (attr3);
_status_preinit (status);
result = SH_NodeFragment_append_attr_new (fragment, name, value,
&status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_ptr_eq (name, fragment->attrs[2].name);
ck_assert_ptr_eq (value, fragment->attrs[2].value);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert (Attr_is_equal (attr1, &fragment->attrs[0]));
ck_assert (Attr_is_equal (attr2, &fragment->attrs[1]));
ck_assert (Attr_is_equal (attr3, &fragment->attrs[2]));
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
free (attr1);
free (attr2);
free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_insert_copy_no_status)
{
char * name;
char * value;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test - out of bounds */
result = SH_NodeFragment_insert_attr_copy (fragment, attr1, 1,
NULL);
ck_assert_int_eq (FALSE, result);
/* test */
name = Attr_get_name (attr2);
value = Attr_get_value (attr2);
result = SH_NodeFragment_insert_attr_copy (fragment, attr2, 0,
NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_ptr_ne (name, fragment->attrs[0].name);
ck_assert_ptr_ne (value, fragment->attrs[0].value);
/* test - insert before */
name = Attr_get_name (attr1);
value = Attr_get_value (attr1);
result = SH_NodeFragment_prepend_attr_copy (fragment, attr1,
NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_ptr_ne (name, fragment->attrs[0].name);
ck_assert_ptr_ne (value, fragment->attrs[0].value);
/* test - insert after */
name = Attr_get_name (attr3);
value = Attr_get_value (attr3);
result = SH_NodeFragment_append_attr_copy (fragment, attr3,
NULL);
ck_assert_int_eq (TRUE, result);
ck_assert_ptr_ne (name, fragment->attrs[2].name);
ck_assert_ptr_ne (value, fragment->attrs[2].value);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert (Attr_is_equal (attr1, &fragment->attrs[0]));
ck_assert (Attr_is_equal (attr2, &fragment->attrs[1]));
ck_assert (Attr_is_equal (attr3, &fragment->attrs[2]));
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
SH_Attr_free (attr1);
SH_Attr_free (attr2);
SH_Attr_free (attr3);
}
END_TEST
START_TEST(test_node_fragment_attr_insert_insert_copy_with_status)
{
struct SH_Status status;
char * name;
char * value;
SH_Attr * attr1;
SH_Attr * attr2;
SH_Attr * attr3;
SH_Data * data;
SH_NodeFragment * fragment;
bool result;
/* setup */
attr1 = SH_Attr_new ("name1", "value1", NULL);
ck_assert_ptr_ne (NULL, attr1);
attr2 = SH_Attr_new ("name2", "value2", NULL);
ck_assert_ptr_ne (NULL, attr2);
attr3 = SH_Attr_new ("name3", "value3", NULL);
ck_assert_ptr_ne (NULL, attr3);
data = SH_Data_new (NULL);
ck_assert_ptr_ne (NULL, data);
fragment = (SH_NodeFragment *)SH_NodeFragment_new ("html", data,
NULL);
ck_assert_ptr_ne (NULL, fragment);
/* test - out of bounds */
_status_preinit (status);
result = SH_NodeFragment_insert_attr_copy (fragment, attr1, 1,
&status);
ck_assert_int_eq (FALSE, result);
ck_assert_int_eq (E_VALUE, status.status);
/* test */
name = Attr_get_name (attr2);
value = Attr_get_value (attr2);
_status_preinit (status);
result = SH_NodeFragment_insert_attr_copy (fragment, attr2, 0,
&status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_ptr_ne (name, fragment->attrs[0].name);
ck_assert_ptr_ne (value, fragment->attrs[0].value);
/* test - insert before */
name = Attr_get_name (attr1);
value = Attr_get_value (attr1);
_status_preinit (status);
result = SH_NodeFragment_prepend_attr_copy (fragment, attr1,
&status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_ptr_ne (name, fragment->attrs[0].name);
ck_assert_ptr_ne (value, fragment->attrs[0].value);
/* test - insert after */
name = Attr_get_name (attr3);
value = Attr_get_value (attr3);
_status_preinit (status);
result = SH_NodeFragment_append_attr_copy (fragment, attr3,
&status);
ck_assert_int_eq (TRUE, result);
ck_assert_int_eq (SUCCESS, status.status);
ck_assert_ptr_ne (name, fragment->attrs[2].name);
ck_assert_ptr_ne (value, fragment->attrs[2].value);
ck_assert_int_eq (3, fragment->attr_n);
ck_assert (Attr_is_equal (attr1, &fragment->attrs[0]));
ck_assert (Attr_is_equal (attr2, &fragment->attrs[1]));
ck_assert (Attr_is_equal (attr3, &fragment->attrs[2]));
/* cleanup */
SH_NodeFragment_free (fragment);
SH_Data_free (data);
SH_Attr_free (attr1);
SH_Attr_free (attr2);
SH_Attr_free (attr3);
}
END_TEST
START_TEST(test_node_fragment_child_alloc)
{
#define alloc_size get_child_alloc_size
......@@ -1913,6 +3063,18 @@ Suite * fragment_suite (void)
tcase_add_test (tc_core, test_node_fragment_attr_alloc);
tcase_add_test (tc_core, test_node_fragment_attr_get_no_status);
tcase_add_test (tc_core, test_node_fragment_attr_get_with_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_no_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_with_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_new_no_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_new_with_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_copy_no_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_copy_with_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_insert_no_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_insert_with_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_insert_new_no_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_insert_new_with_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_insert_copy_no_status);
tcase_add_test (tc_core, test_node_fragment_attr_insert_insert_copy_with_status);
tcase_add_test (tc_core, test_node_fragment_child_alloc);
tcase_add_test (tc_core, test_node_fragment_child);
tcase_add_test (tc_core, test_node_fragment_get_child);
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment