From ead560413ff7ad7b4853921faed2284fd89049c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jonathan=20Sch=C3=B6bel?= <jonathan@xn--schbel-yxa.info>
Date: Sat, 3 Jun 2023 16:01:27 +0200
Subject: [PATCH] NodeFragment: added tests for insert Attr methods.
Hand in still missing tests.
---
sefht.geany | 2 +-
tests/test_node_fragment.c | 1162 ++++++++++++++++++++++++++++++++++++
2 files changed, 1163 insertions(+), 1 deletion(-)
diff --git a/sefht.geany b/sefht.geany
index 0714a82..6518873 100644
--- a/sefht.geany
+++ b/sefht.geany
@@ -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
diff --git a/tests/test_node_fragment.c b/tests/test_node_fragment.c
index 88f9ff0..4f4ab5f 100644
--- a/tests/test_node_fragment.c
+++ b/tests/test_node_fragment.c
@@ -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);
--
GitLab