test_node_fragment.c

/*
 * test_node_fragment.c
 *
 * Copyright 2022 Jonathan Schöbel <jonathan@Ubermos-2019>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 *
 *
 */


#include <check.h>
#include <stdbool.h>
#include <stdlib.h>

#include "macro.h"
#include "status.h"

#include "node_fragment.c"


START_TEST(test_node_fragment_no_status)
{
	struct SH_NodeFragment * fragment;
	SH_Data * data;
	const char * tag = "tag";

	data = SH_Data_new (NULL);

	fragment = (struct SH_NodeFragment *)
	           SH_NodeFragment_new (tag, data, NULL);

	ck_assert_ptr_ne (NULL, fragment);

	ck_assert_ptr_eq (NULL, fragment->base.parent);
	ck_assert_str_eq (fragment->tag, tag);

	ck_assert_int_eq (0, fragment->attr_n);
	ck_assert_int_eq (0, fragment->attr_s);

	ck_assert_int_eq (0, fragment->child_n);
	ck_assert_int_eq (0, fragment->child_s);

	SH_NodeFragment_free (fragment);

	SH_Data_free (data);
}
END_TEST

START_TEST(test_node_fragment_with_status)
{
	struct SH_Status status;
	struct SH_NodeFragment * fragment;
	SH_Data * data;
	const char * tag = "tag";

	data = SH_Data_new (NULL);

	_status_preinit (status);
	fragment = (struct SH_NodeFragment *)
	           SH_NodeFragment_new (tag, data, &status);

	ck_assert_ptr_ne (NULL, fragment);
	ck_assert (succeed (&status));

	ck_assert_ptr_eq (NULL, fragment->base.parent);
	ck_assert_str_eq (fragment->tag, tag);

	ck_assert_int_eq (0, fragment->attr_n);
	ck_assert_int_eq (0, fragment->attr_s);

	ck_assert_int_eq (0, fragment->child_n);
	ck_assert_int_eq (0, fragment->child_s);

	SH_NodeFragment_free (fragment);

	SH_Data_free (data);
}
END_TEST

START_TEST(test_node_fragment_raw_no_status)
{
	struct SH_NodeFragment * fragment;
	SH_Data * data;
	char * tag = strdup ("tag");

	data = SH_Data_new (NULL);

	fragment = (struct SH_NodeFragment *)
	           SH_NodeFragment_raw_new (tag, data, NULL);

	ck_assert_ptr_ne (NULL, fragment);

	ck_assert_ptr_eq (NULL, fragment->base.parent);
	ck_assert_ptr_eq (fragment->tag, tag);

	ck_assert_int_eq (0, fragment->attr_n);
	ck_assert_int_eq (0, fragment->attr_s);

	ck_assert_int_eq (0, fragment->child_n);
	ck_assert_int_eq (0, fragment->child_s);

	SH_NodeFragment_free (fragment);

	SH_Data_free (data);
}
END_TEST

START_TEST(test_node_fragment_raw_with_status)
{
	struct SH_Status status;
	struct SH_NodeFragment * fragment;
	SH_Data * data;
	char * tag = strdup ("tag");

	data = SH_Data_new (NULL);

	_status_preinit (status);
	fragment = (struct SH_NodeFragment *)
	           SH_NodeFragment_raw_new (tag, data, &status);

	ck_assert_ptr_ne (NULL, fragment);
	ck_assert (succeed (&status));

	ck_assert_ptr_eq (NULL, fragment->base.parent);
	ck_assert_ptr_eq (fragment->tag, tag);

	ck_assert_int_eq (0, fragment->attr_n);
	ck_assert_int_eq (0, fragment->attr_s);

	ck_assert_int_eq (0, fragment->child_n);
	ck_assert_int_eq (0, fragment->child_s);

	SH_NodeFragment_free (fragment);

	SH_Data_free (data);
}
END_TEST

START_TEST(test_node_fragment_copy_no_status)
{
	struct SH_NodeFragment * fragment;
	struct SH_NodeFragment * copy;
	SH_Data * data;

	data = SH_Data_new (NULL);

	fragment = (struct SH_NodeFragment *)
	           SH_NodeFragment_new ("html", data, NULL);

	copy = (struct SH_NodeFragment *)
	       SH_NodeFragment_copy (fragment, NULL);

	ck_assert_ptr_ne (copy, NULL);
	ck_assert_ptr_ne (fragment, copy);
	ck_assert_ptr_eq (NULL, copy->base.parent);
	ck_assert_str_eq (fragment->tag, copy->tag);
	ck_assert_int_eq (0, copy->attr_n);
	ck_assert_int_eq (0, copy->attr_s);
	ck_assert_int_eq (0, copy->child_n);
	ck_assert_int_eq (0, copy->child_s);
	ck_assert_ptr_ne (NULL, copy->childs);

	SH_NodeFragment_free (fragment);
	SH_NodeFragment_free (copy);

	SH_Data_free (data);
}
END_TEST

START_TEST(test_node_fragment_copy_with_status)
{
	struct SH_Status status;
	struct SH_NodeFragment * fragment;
	struct SH_NodeFragment * copy;
	SH_Data * data;

	data = SH_Data_new (NULL);

	fragment = (struct SH_NodeFragment *)
	           SH_NodeFragment_new ("html", data, NULL);

	_status_preinit (status);
	copy = (struct SH_NodeFragment *)
	       SH_NodeFragment_copy (fragment, &status);
	ck_assert (succeed (&status));

	ck_assert_ptr_ne (copy, NULL);
	ck_assert_ptr_ne (fragment, copy);
	ck_assert_ptr_eq (NULL, copy->base.parent);
	ck_assert_str_eq (fragment->tag, copy->tag);
	ck_assert_int_eq (0, copy->attr_n);
	ck_assert_int_eq (0, copy->attr_s);
	ck_assert_int_eq (0, copy->child_n);
	ck_assert_int_eq (0, copy->child_s);
	ck_assert_ptr_ne (NULL, copy->childs);

	SH_NodeFragment_free (fragment);
	SH_NodeFragment_free (copy);

	SH_Data_free (data);
}
END_TEST

static void
check_childs (struct SH_NodeFragment * fragment,
              struct SH_NodeFragment * copy)
{
	size_t index;

	ck_assert_str_eq (fragment->tag, copy->tag);
	ck_assert_int_eq (fragment->attr_n, copy->attr_n);
	ck_assert_int_eq (fragment->attr_s, copy->attr_s);
	ck_assert_int_eq (fragment->child_n, copy->child_n);
	ck_assert_int_eq (fragment->child_s, copy->child_s);
	ck_assert_ptr_ne (fragment->childs, copy->childs);

	for (index = 0; index < copy->child_n; index++)
	{
		ck_assert_ptr_ne (fragment->childs[index],
				  copy->childs[index]);
		ck_assert_ptr_eq (copy, get_parent (copy->childs[index]));

		check_childs (((struct SH_NodeFragment *)
		              fragment->childs[index]),
			      ((struct SH_NodeFragment *)
			      copy->childs[index]));
	}

	return;
}

START_TEST(test_node_fragment_deepcopy_no_status)
{
	struct SH_NodeFragment * fragment;
	struct SH_NodeFragment * copy;
	struct SH_Fragment * child1;
	struct SH_Fragment * child2;
	SH_Data * data;

	data = SH_Data_new (NULL);

	fragment = (struct SH_NodeFragment *)
	           SH_NodeFragment_new ("html", data, NULL);

	child1 = SH_NodeFragment_new ("head", data, NULL);
	SH_NodeFragment_append_child (fragment, child1, NULL);

	child2 = SH_NodeFragment_new ("title", data, NULL);
	SH_NodeFragment_append_child ((struct SH_NodeFragment *)child1,
	                              child2, NULL);


	child1 = SH_NodeFragment_new ("body", data, NULL);
	SH_NodeFragment_append_child (fragment, child1, NULL);

	child2 = SH_NodeFragment_new ("header", data, NULL);
	SH_NodeFragment_append_child ((struct SH_NodeFragment *)child1,
	                              child2, NULL);

	child2 = SH_NodeFragment_new ("main", data, NULL);
	SH_NodeFragment_append_child ((struct SH_NodeFragment *)child1,
	                              child2, NULL);

	child2 = SH_NodeFragment_new ("footer", data, NULL);
	SH_NodeFragment_append_child ((struct SH_NodeFragment *)child1,
	                              child2, NULL);


	copy = (struct SH_NodeFragment *)
	       SH_NodeFragment_deepcopy (fragment, NULL);

	ck_assert_ptr_ne (NULL, copy);
	ck_assert_ptr_ne (fragment, copy);
	ck_assert_ptr_eq (NULL, copy->base.parent);

	check_childs (fragment, copy);

	SH_NodeFragment_free (fragment);
	SH_NodeFragment_free (copy);

	SH_Data_free (data);
}
END_TEST

START_TEST(test_node_fragment_deepcopy_with_status)
{
	struct SH_Status status;
	struct SH_NodeFragment * fragment;
	struct SH_NodeFragment * copy;
	struct SH_Fragment * child1;
	struct SH_Fragment * child2;
	SH_Data * data;

	data = SH_Data_new (NULL);

	fragment = (struct SH_NodeFragment *)
	           SH_NodeFragment_new ("html", data, NULL);

	child1 = SH_NodeFragment_new ("head", data, NULL);
	SH_NodeFragment_append_child (fragment, child1, NULL);

	child2 = SH_NodeFragment_new ("title", data, NULL);
	SH_NodeFragment_append_child ((struct SH_NodeFragment *)child1,
	                              child2, NULL);


	child1 = SH_NodeFragment_new ("body", data, NULL);
	SH_NodeFragment_append_child (fragment, child1, NULL);

	child2 = SH_NodeFragment_new ("header", data, NULL);
	SH_NodeFragment_append_child ((struct SH_NodeFragment *)child1,
	                              child2, NULL);

	child2 = SH_NodeFragment_new ("main", data, NULL);
	SH_NodeFragment_append_child ((struct SH_NodeFragment *)child1,
	                              child2, NULL);

	child2 = SH_NodeFragment_new ("footer", data, NULL);
	SH_NodeFragment_append_child ((struct SH_NodeFragment *)child1,
	                              child2, NULL);


	_status_preinit (status);
	copy = (struct SH_NodeFragment *)
	       SH_NodeFragment_deepcopy (fragment, &status);
	ck_assert (succeed (&status));

	ck_assert_ptr_ne (NULL, copy);
	ck_assert_ptr_ne (fragment, copy);
	ck_assert_ptr_eq (NULL, copy->base.parent);

	check_childs (fragment, copy);

	SH_NodeFragment_free (fragment);
	SH_NodeFragment_free (copy);

	SH_Data_free (data);
}
END_TEST

START_TEST(test_node_fragment_tag_no_status)
{
	struct SH_Fragment * fragment;
	SH_Data * data;
	char * tag;
	const char * tag1 = "html";

	data = SH_Data_new (NULL);

	/* no error */
	fragment = SH_NodeFragment_new (tag1, data, NULL);

	tag = SH_NodeFragment_get_tag ((struct SH_NodeFragment *)
	                               fragment,
	                               NULL);
	ck_assert_str_eq (tag, tag1);
	free (tag);

	SH_Fragment_free (fragment);
	SH_Data_free (data);
}
END_TEST

START_TEST(test_node_fragment_tag_with_status)
{
	struct SH_Status status;
	struct SH_Fragment * fragment;
	SH_Data * data;
	char * tag;
	const char * tag1 = "html";

	data = SH_Data_new (NULL);

	fragment = SH_NodeFragment_new (tag1, data, NULL);

	_status_preinit (status);
	tag = SH_NodeFragment_get_tag ((struct SH_NodeFragment *)
	                               fragment,
	                               &status);
	ck_assert_str_eq (tag, tag1);
	ck_assert (succeed (&status));
	free (tag);

	SH_Fragment_free (fragment);
	SH_Data_free (data);
}
END_TEST

START_TEST(test_node_fragment_tag_raw)
{
	struct SH_Fragment * fragment;
	SH_Data * data;
	char * tag;
	const char * tag1 = "html";

	data = SH_Data_new (NULL);

	fragment = SH_NodeFragment_new (tag1, data, NULL);

	tag = SH_NodeFragment_raw_get_tag (((struct SH_NodeFragment *)
	                                   fragment));
	ck_assert_str_eq (tag, tag1);

	SH_Fragment_free (fragment);
	SH_Data_free (data);
}
END_TEST

START_TEST(test_node_fragment_attr_alloc)
{
	#define alloc_size get_attr_alloc_size
	ck_assert_int_eq (0, alloc_size (0));
	ck_assert_int_eq (CHILD_CHUNK, alloc_size (1));
	ck_assert_int_eq (CHILD_CHUNK, alloc_size (CHILD_CHUNK));
	ck_assert_int_eq (2*CHILD_CHUNK, alloc_size (CHILD_CHUNK+1));
	ck_assert_int_eq (SIZE_MAX, alloc_size (SIZE_MAX));
	for (size_t i = 0; i < CHILD_CHUNK; i++)
	{
		ck_assert_int_le (SIZE_MAX-i, alloc_size (SIZE_MAX-i));
	}
	#undef alloc_size
}
END_TEST

START_TEST(test_node_fragment_attr_get_no_status)
{
	SH_Attr * attr1;
	const SH_Attr * attr2;
	SH_Data * data;
	SH_NodeFragment * fragment;
	bool result;

	/* setup */
	attr1 = SH_Attr_new ("name", "value", NULL);
	ck_assert_ptr_ne (NULL, attr1);

	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);

	result = SH_NodeFragment_append_attr_copy (fragment, attr1, NULL);
	ck_assert_int_eq (TRUE, result);

	/* test - success */
	attr2 = SH_NodeFragment_get_attr (fragment, 0, NULL);
	ck_assert_ptr_ne (NULL, attr2);

	ck_assert (Attr_is_equal (attr1, attr2));

	/* test - fail */
	attr2 = SH_NodeFragment_get_attr (fragment, 1, NULL);
	ck_assert_ptr_eq (NULL, attr2);

	/* cleanup */
	SH_NodeFragment_free (fragment);
	SH_Data_free (data);
	SH_Attr_free (attr1);
}
END_TEST

START_TEST(test_node_fragment_attr_get_with_status)
{
	struct SH_Status status;
	SH_Attr * attr1;
	const SH_Attr * attr2;
	SH_Data * data;
	SH_NodeFragment * fragment;
	bool result;

	/* setup */
	attr1 = SH_Attr_new ("name", "value", NULL);
	ck_assert_ptr_ne (NULL, attr1);

	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);

	result = SH_NodeFragment_append_attr_copy (fragment, attr1, NULL);
	ck_assert_int_eq (TRUE, result);

	/* test - success */
	_status_preinit (status);
	attr2 = SH_NodeFragment_get_attr (fragment, 0, &status);
	ck_assert_ptr_ne (NULL, attr2);
	ck_assert_int_eq (SUCCESS, status.status);

	ck_assert (Attr_is_equal (attr1, attr2));

	/* test - fail */
	_status_preinit (status);
	attr2 = SH_NodeFragment_get_attr (fragment, 1, &status);
	ck_assert_ptr_eq (NULL, attr2);
	ck_assert_int_eq (E_VALUE, status.status);

	/* cleanup */
	SH_NodeFragment_free (fragment);
	SH_Data_free (data);
	SH_Attr_free (attr1);
}
END_TEST

START_TEST(test_node_fragment_attr_insert_no_status)
{
	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 */
	result = insert_attr (fragment, attr1, 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 */
	result = insert_attr (fragment, attr2, 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 */
	result = insert_attr (fragment, attr3, 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_with_status)
{
	struct SH_Status status;
	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 */
	_status_preinit (status);
	result = insert_attr (fragment, attr1, 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 */
	_status_preinit (status);
	result = insert_attr (fragment, attr2, 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 */
	_status_preinit (status);
	result = insert_attr (fragment, attr3, 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_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);