diff --git a/sefht.geany b/sefht.geany
index 0714a82800b104b16839c7a9e3cb937c84a11c89..651887352096c6dfadd4cbe0122313ef3feec20b 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 88f9ff02d5a46386a6c6ed0a7bdf75839fd39e98..4f4ab5f555d096d7f0acd432bed631b6dc5e38e6 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);