diff --git a/sefht.geany b/sefht.geany
index a14e19abae447b5da39d15d8d2756481c9976a39..4efdebe7a98b6c1872fa7c2cbe59b43039728b79 100644
--- a/sefht.geany
+++ b/sefht.geany
@@ -28,7 +28,7 @@ long_line_behaviour=1
 long_line_column=72
 
 [files]
-current_page=35
+current_page=54
 FILE_NAME_0=139;None;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2FREADME;0;8
 FILE_NAME_1=134;None;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2F.gitignore;0;8
 FILE_NAME_2=1737;Sh;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fconfigure.ac;0;8
@@ -64,9 +64,9 @@ FILE_NAME_31=1111;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fp
 FILE_NAME_32=14059;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fvalidator_tag.c;0;8
 FILE_NAME_33=1148;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fvalidator_tag.h;0;8
 FILE_NAME_34=1124;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fvalidator_tag_data.h;0;8
-FILE_NAME_35=13076;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fvalidator_attr.c;0;8
-FILE_NAME_36=1682;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fvalidator_attr.h;0;8
-FILE_NAME_37=1111;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fvalidator_attr_data.h;0;8
+FILE_NAME_35=16395;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fvalidator_attr.c;0;8
+FILE_NAME_36=1051;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fvalidator_attr.h;0;8
+FILE_NAME_37=1413;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fvalidator_attr_data.h;0;8
 FILE_NAME_38=924;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fstatus.h;0;8
 FILE_NAME_39=18;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Flog.h;0;4
 FILE_NAME_40=20;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fsrc%2Flib%2Fsefht%2Fmacro.h;0;8
@@ -83,7 +83,7 @@ FILE_NAME_50=4221;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fp
 FILE_NAME_51=994;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_text_mark.c;0;8
 FILE_NAME_52=2447;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_validator.c;0;8
 FILE_NAME_53=3880;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_validator_tag.c;0;8
-FILE_NAME_54=29231;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_validator_attr.c;0;8
+FILE_NAME_54=28881;C;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftests%2Ftest_validator_attr.c;0;8
 FILE_NAME_55=547;None;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Ftodo.txt;0;8
 FILE_NAME_56=201;YAML;0;EUTF-8;0;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2F.gitlab-ci.yml;0;4
 FILE_NAME_57=71;Sh;0;EUTF-8;1;1;0;%2Fhome%2Fjonathan%2FDokumente%2Fprojekte%2Fprgm%2Finternet%2Fweb%2FSeFHT%2Fgitlab-ci%2Fupload.sh.in;0;8
diff --git a/src/lib/sefht/validator_attr.c b/src/lib/sefht/validator_attr.c
index 72101f872d56e5a9552c438ad9a70ed0212e23fb..d8720eb3e578f9cd682044b7aa57b2402bee99c6 100644
--- a/src/lib/sefht/validator_attr.c
+++ b/src/lib/sefht/validator_attr.c
@@ -38,11 +38,9 @@ static inline
 bool
 init_attrs (/*@special@*/ struct SH_Validator * validator)
 	/*@defines validator->attrs,
-	           validator->attr_n,
-	           validator->last_attr@*/
+	           validator->attr_n@*/
 	/*@modifies validator->attrs@*/
-	/*@modifies validator->attr_n@*/
-	/*@modifies validator->last_attr@*/;
+	/*@modifies validator->attr_n@*/;
 
 static inline
 bool
@@ -50,11 +48,9 @@ copy_attrs (/*@special@*/ struct SH_Validator * copy,
             const struct SH_Validator * validator,
             /*@null@*/ /*@out@*/ struct SH_Status * status)
 	/*@defines copy->attrs,
-	           copy->attr_n,
-	           copy->last_attr@*/
+	           copy->attr_n@*/
 	/*@modifies copy->attrs@*/
 	/*@modifies copy->attr_n@*/
-	/*@modifies copy->last_attr@*/
 	/*@globals fileSystem@*/
 	/*@modifies fileSystem@*/
 	/*@modifies status@*/;
@@ -86,7 +82,7 @@ find_attr_tag (const struct attr_info * attr,
 	/*@modifies index@*/;
 
 static inline
-Attr
+bool
 add_attr (struct SH_Validator * validator,
           const char * attr,
           /*@dependent@*/ const char * tag,
@@ -94,39 +90,10 @@ add_attr (struct SH_Validator * validator,
           /*@null@*/ /*@out@*/ struct SH_Status * status)
 	/*@modifies validator->attrs@*/
 	/*@modifies validator->attr_n@*/
-	/*@modifies validator->last_attr@*/
-	/*@globals fileSystem@*/
-	/*@modifies fileSystem@*/
-	/*@modifies status@*/;
-
-/*@unused@*/
-static inline
-bool
-is_attr_id (struct SH_Validator * validator, Attr id)
-	/*@*/;
-
-static inline
-bool
-is_attr_name (struct SH_Validator * validator, const char * name)
-	/*@*/;
-
-/*@unused@*/
-static inline
-/*@null@*/
-char *
-get_attr_name_by_id (struct SH_Validator * validator, Attr id,
-                     /*@null@*/ /*@out@*/ struct SH_Status * status)
 	/*@globals fileSystem@*/
 	/*@modifies fileSystem@*/
 	/*@modifies status@*/;
 
-static inline
-Attr
-get_attr_id_by_name (struct SH_Validator * validator,
-                     const char * name,
-                     /*@out@*/ size_t * index)
-	/*@modifies index@*/;
-
 static inline
 bool
 remove_attr (struct SH_Validator * validator,
@@ -134,7 +101,6 @@ remove_attr (struct SH_Validator * validator,
              /*@null@*/ /*@out@*/ struct SH_Status  * status)
 	/*@modifies validator->attrs@*/
 	/*@modifies validator->attr_n@*/
-	/*@modifies validator->last_attr@*/
 	/*@globals fileSystem@*/
 	/*@modifies fileSystem@*/
 	/*@modifies status@*/;
@@ -169,7 +135,6 @@ remove_tag_for_all_attrs (struct SH_Validator * validator,
                           struct SH_Status * status)
 	/*@modifies validator->attrs@*/
 	/*@modifies validator->attr_n@*/
-	/*@modifies validator->last_attr@*/
 	/*@globals fileSystem@*/
 	/*@modifies fileSystem@*/
 	/*@modifies status@*/;
@@ -179,15 +144,12 @@ static inline
 bool
 init_attrs (/*@special@*/ struct SH_Validator * validator)
 	/*@defines validator->attrs,
-	           validator->attr_n,
-	           validator->last_attr@*/
+	           validator->attr_n@*/
 	/*@modifies validator->attrs@*/
 	/*@modifies validator->attr_n@*/
-	/*@modifies validator->last_attr@*/
 {
 	validator->attrs = malloc (0);
 	validator->attr_n = 0;
-	validator->last_attr = ATTR_ERR;
 	return TRUE;
 }
 
@@ -196,11 +158,9 @@ bool
 copy_attr (/*@special@*/ struct attr_info * copy,
            const struct attr_info * attr,
           /*@null@*/ /*@out@*/ struct SH_Status * status)
-	/*@defines copy->id,
-	           copy->name,
+	/*@defines copy->name,
 	           copy->tag_n,
 	           copy->tags@*/
-	/*@modifies copy->id@*/
 	/*@modifies copy->name@*/
 	/*@modifies copy->tag_n@*/
 	/*@modifies copy->tags@*/
@@ -227,7 +187,6 @@ copy_attr (/*@special@*/ struct attr_info * copy,
 		return FALSE;
 	}
 
-	copy->id = attr->id;
 	copy->name = name;
 	copy->tag_n = attr->tag_n;
 	copy->tags = tags;
@@ -245,11 +204,9 @@ copy_attrs (/*@special@*/ struct SH_Validator * copy,
             const struct SH_Validator * validator,
             /*@null@*/ /*@out@*/ struct SH_Status * status)
 	/*@defines copy->attrs,
-	           copy->attr_n,
-	           copy->last_attr@*/
+	           copy->attr_n@*/
 	/*@modifies copy->attrs@*/
 	/*@modifies copy->attr_n@*/
-	/*@modifies copy->last_attr@*/
 	/*@globals fileSystem@*/
 	/*@modifies fileSystem@*/
 	/*@modifies status@*/
@@ -280,7 +237,6 @@ copy_attrs (/*@special@*/ struct SH_Validator * copy,
 	}
 
 	copy->attr_n = validator->attr_n;
-	copy->last_attr = validator->last_attr;
 
 	return TRUE;
 }
@@ -392,7 +348,7 @@ find_attr_tag (const struct attr_info * attr,
 }
 
 static inline
-Attr
+bool
 add_attr (struct SH_Validator * validator,
           const char * attr,
           /*@dependent@*/ const char * tag,
@@ -400,7 +356,6 @@ add_attr (struct SH_Validator * validator,
           /*@null@*/ /*@out@*/ struct SH_Status * status)
 	/*@modifies validator->attrs@*/
 	/*@modifies validator->attr_n@*/
-	/*@modifies validator->last_attr@*/
 	/*@globals fileSystem@*/
 	/*@modifies fileSystem@*/
 	/*@modifies status@*/
@@ -411,22 +366,20 @@ add_attr (struct SH_Validator * validator,
 	/* abort on overflow:
 	 * - no unused Attr or
 	 * - no unused index */
-	if ((validator->last_attr == ATTR_MAX)
-	|| (validator->attr_n == SIZE_MAX)
+	if ((validator->attr_n == SIZE_MAX)
 	|| ((validator->attr_n + 1)
 	            > (SIZE_MAX / sizeof (struct attr_info))))
 	{
 		set_status (status, E_DOMAIN, 2,
 		            "maximum number of attributes reached");
-		return ATTR_ERR;
+		return FALSE;
 	}
 
-	attr_data.id = NEXT_ATTR (validator->last_attr);
 	attr_data.name = strdup (attr);
 	if (NULL == attr_data.name)
 	{
 		set_status (status, E_ALLOC, 3, "strdup failed");
-		return ATTR_ERR;
+		return FALSE;
 	}
 
 	attr_data.tags = malloc (sizeof (struct attr_tag_info));
@@ -434,7 +387,7 @@ add_attr (struct SH_Validator * validator,
 	{
 		set_status (status, E_ALLOC, 3, "malloc failed");
 		free (attr_data.name);
-		return ATTR_ERR;
+		return FALSE;
 	}
 
 	attr_data.tags[0].name = tag;
@@ -457,98 +410,22 @@ add_attr (struct SH_Validator * validator,
 		validator->attrs = (void *) 0x12345;
 #endif
 		free_attr (attr_data);
-		return ATTR_ERR;
+		return FALSE;
 	}
 
 	validator->attrs = new_attrs;
 
-	for (size_t index2 = validator->attr_n; index2 > index; index2--)
+	for (size_t i = validator->attr_n; i > index; i--)
 	{
-		validator->attrs[index2] = validator->attrs[index2-1];
+		validator->attrs[i] = validator->attrs[i-1];
 	}
 
 	/* commit changes */
 	validator->attrs[index] = attr_data;
 	validator->attr_n++;
-	validator->last_attr = attr_data.id;
 
 	set_success (status);
-	return attr_data.id;
-}
-
-/*@unused@*/
-static inline
-bool
-is_attr_id (struct SH_Validator * validator, Attr id)
-	/*@*/
-{
-	size_t index;
-
-	for (index = 0; index < validator->attr_n; index++)
-	{
-		if (id == validator->attrs[index].id)
-		{
-			return TRUE;
-		}
-	}
-
-	return FALSE;
-}
-
-static inline
-bool
-is_attr_name (struct SH_Validator * validator, const char * name)
-	/*@*/
-{
-	size_t index;
-	return find_attr (validator, name, &index);
-}
-
-/*@unused@*/
-static inline
-/*@null@*/
-char *
-get_attr_name_by_id (struct SH_Validator * validator, Attr id,
-                     /*@null@*/ /*@out@*/ struct SH_Status * status)
-	/*@globals fileSystem@*/
-	/*@modifies fileSystem@*/
-	/*@modifies status@*/
-{
-	size_t index;
-	char * name;
-
-	for (index = 0; index < validator->attr_n; index++)
-	{
-		if (id == validator->attrs[index].id)
-		{
-			name = strdup (validator->attrs[index].name);
-			if (name == NULL)
-			{
-				set_status (status, E_ALLOC, 3,
-				            "strdup failed");
-				return NULL;
-			}
-
-			return name;
-		}
-	}
-
-	return NULL;
-}
-
-static inline
-Attr
-get_attr_id_by_name (struct SH_Validator * validator,
-                     const char * name,
-                     /*@out@*/ size_t * index)
-	/*@modifies index@*/
-{
-	if (!find_attr (validator, name, index))
-	{
-		return ATTR_ERR;
-	}
-
-	return validator->attrs[*index].id;
+	return TRUE;
 }
 
 static inline
@@ -558,7 +435,6 @@ remove_attr (struct SH_Validator * validator,
              /*@null@*/ /*@out@*/ struct SH_Status  * status)
 	/*@modifies validator->attrs@*/
 	/*@modifies validator->attr_n@*/
-	/*@modifies validator->last_attr@*/
 	/*@globals fileSystem@*/
 	/*@modifies fileSystem@*/
 	/*@modifies status@*/
@@ -693,7 +569,6 @@ remove_tag_for_all_attrs (struct SH_Validator * validator,
                           struct SH_Status * status)
 	/*@modifies validator->attrs@*/
 	/*@modifies validator->attr_n@*/
-	/*@modifies validator->last_attr@*/
 	/*@globals fileSystem@*/
 	/*@modifies fileSystem@*/
 	/*@modifies status@*/
@@ -761,7 +636,7 @@ SH_Validator_check_attr (struct SH_Validator * validator,
 	return TRUE;
 }
 
-Attr
+bool
 SH_Validator_register_attr (struct SH_Validator * validator,
                             const char * tag,
                             const char * attr,
@@ -769,26 +644,23 @@ SH_Validator_register_attr (struct SH_Validator * validator,
                             struct SH_Status * status)
 	/*@modifies validator->attrs@*/
 	/*@modifies validator->attr_n@*/
-	/*@modifies validator->last_attr@*/
 	/*@globals fileSystem@*/
 	/*@modifies fileSystem@*/
 	/*@modifies status@*/
 {
-	Attr attr_id;
 	/* note, that index is used for three different arrays */
 	size_t index;
 
 	if ((!find_tag (validator, tag, &index))
 	&& (!add_tag (validator, tag, index, status)))
 	{
-		return ATTR_ERR;
+		return FALSE;
 	}
 
 	tag = validator->tags[index].name;
 
 	/* attr already registered */
-	attr_id = get_attr_id_by_name (validator, attr, &index);
-	if (attr_id != ATTR_ERR)
+	if (find_attr (validator, attr, &index))
 	{
 		struct attr_info * attr;
 		attr = &validator->attrs[index];
@@ -796,11 +668,11 @@ SH_Validator_register_attr (struct SH_Validator * validator,
 		if ((!find_attr_tag (attr, tag, &index))
 		&& (!attr_add_tag (attr, index, tag, status)))
 		{
-			return ATTR_ERR;
+			return FALSE;
 		}
 
 		set_success (status);
-		return attr_id;
+		return TRUE;
 	}
 
 	return add_attr (validator, attr, tag, index, status);
@@ -814,7 +686,6 @@ SH_Validator_deregister_attr (struct SH_Validator * validator,
                               struct SH_Status * status)
 	/*@modifies validator->attr_n@*/
 	/*@modifies validator->attrs@*/
-	/*@modifies validator->last_attr@*/
 	/*@globals fileSystem@*/
 	/*@modifies fileSystem@*/
 	/*@modifies status@*/
@@ -836,7 +707,7 @@ SH_Validator_deregister_attr (struct SH_Validator * validator,
 		{
 			/* TODO: define whether this is an error */
 			set_status (status, E_VALUE, 3, "no such tag");
-			return ATTR_ERR;
+			return FALSE;
 		}
 
 		tag = validator->tags[index].name;
@@ -866,7 +737,7 @@ SH_Validator_deregister_attr (struct SH_Validator * validator,
 			{
 				set_status (status, E_VALUE, 2,
 				            "no such tag");
-				return ATTR_ERR;
+				return FALSE;
 			}
 
 			return remove_attr (validator, index, status);
@@ -876,7 +747,7 @@ SH_Validator_deregister_attr (struct SH_Validator * validator,
 		{
 			/* TODO: define whether this is an error */
 			set_status (status, E_VALUE, 3, "no such tag");
-			return ATTR_ERR;
+			return FALSE;
 		}
 
 		tag = validator->tags[index].name;
diff --git a/src/lib/sefht/validator_attr.h b/src/lib/sefht/validator_attr.h
index e17e12aee42b7db5794fe43f8d1077a46a16f8ac..7d8089baa7a0bb4c5b3034980d71f5395a2c1ade 100644
--- a/src/lib/sefht/validator_attr.h
+++ b/src/lib/sefht/validator_attr.h
@@ -35,13 +35,7 @@
 #include "status.h"
 
 
-typedef unsigned int Attr;
-#define ATTR_ERR (Attr) 0
-#define ATTR_MIN (Attr) 1
-#define ATTR_MAX (Attr) SIZE_MAX
-
-
-Attr
+bool
 SH_Validator_register_attr (SH_Validator * validator,
                             const char * tag,
                             const char * attr,
diff --git a/src/lib/sefht/validator_attr_data.h b/src/lib/sefht/validator_attr_data.h
index 858a1b2df4a64c70b8900351151ac8466c5ec639..b877f117a0cbc00e89d5bdc5f620b41ec1f82cf3 100644
--- a/src/lib/sefht/validator_attr_data.h
+++ b/src/lib/sefht/validator_attr_data.h
@@ -36,17 +36,13 @@ struct attr_tag_info
 
 struct attr_info
 {
-	Attr id;
 	/*@only@*/ char * name;
 	size_t tag_n;
 	struct attr_tag_info * tags;
 };
 
-#define NEXT_ATTR(attr) (attr + 1)
-
 #define ATTR_DATA                                                      \
 	/*@only@*/ struct attr_info * attrs;                           \
 	size_t attr_n;                                                 \
-	Attr last_attr;                                                \
 
 #endif /* SEFHT_VALIDATOR_ATTR_DATA_H */
diff --git a/tests/test_validator_attr.c b/tests/test_validator_attr.c
index f6cb44a43b7bd41b0cb9a9a251f33a29df78df7d..fd769a13a6a1bfa4dacacb58c5af64343fe5b580 100644
--- a/tests/test_validator_attr.c
+++ b/tests/test_validator_attr.c
@@ -50,7 +50,6 @@ START_TEST(test_validator_no_status)
 	ck_assert_ptr_ne (NULL, validator);
 
 	ck_assert_int_eq (0, validator->attr_n);
-	ck_assert_int_eq (ATTR_ERR, validator->last_attr);
 
 	SH_Validator_free (validator);
 }
@@ -67,7 +66,6 @@ START_TEST(test_validator_with_status)
 	ck_assert_int_eq (status.status, SUCCESS);
 
 	ck_assert_int_eq (0, validator->attr_n);
-	ck_assert_int_eq (ATTR_ERR, validator->last_attr);
 
 	SH_Validator_free (validator);
 }
@@ -77,17 +75,19 @@ START_TEST(test_validator_copy_no_status)
 {
 	struct SH_Validator * validator;
 	struct SH_Validator * copy;
-	Attr attr;
+	bool result;
 
 	/* setup */
 	validator = SH_Validator_new_html5 (NULL);
 	ck_assert_ptr_ne (NULL, validator);
 
-	attr = SH_Validator_register_attr (validator, "body", "id", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
+	result = SH_Validator_register_attr (validator, "body", "id",
+	                                     NULL);
+	ck_assert_int_ne (FALSE, result);
 
-	attr = SH_Validator_register_attr (validator, "html", "lang", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
+	result = SH_Validator_register_attr (validator, "html", "lang",
+	                                     NULL);
+	ck_assert_int_ne (FALSE, result);
 
 	/* test */
 	copy = SH_Validator_copy (validator, NULL);
@@ -96,7 +96,6 @@ START_TEST(test_validator_copy_no_status)
 	ck_assert_ptr_ne (NULL, copy->attrs);
 	ck_assert_ptr_ne (validator->attrs, copy->attrs);
 	ck_assert_int_eq (validator->attr_n, copy->attr_n);
-	ck_assert_int_eq (validator->last_attr, copy->last_attr);
 
 	#define TEST_INT(I) ck_assert_int_eq (validator->I, copy->I);
 	#define TEST_PTR(P) ck_assert_ptr_eq (validator->P, copy->P);
@@ -105,7 +104,6 @@ START_TEST(test_validator_copy_no_status)
 
 	for (size_t index = 0; index < copy->attr_n; index++)
 	{
-		TEST_INT(attrs[index].id)
 		TEST_STR(attrs[index].name)
 
 		TEST_INT(attrs[index].tag_n)
@@ -128,17 +126,19 @@ START_TEST(test_validator_copy_with_status)
 	struct SH_Status status;
 	struct SH_Validator * validator;
 	struct SH_Validator * copy;
-	Attr attr;
+	bool result;
 
 	/* setup */
 	validator = SH_Validator_new_html5 (NULL);
 	ck_assert_ptr_ne (NULL, validator);
 
-	attr = SH_Validator_register_attr (validator, "body", "id", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
+	result = SH_Validator_register_attr (validator, "body", "id",
+	                                     NULL);
+	ck_assert_int_ne (FALSE, result);
 
-	attr = SH_Validator_register_attr (validator, "html", "lang", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
+	result = SH_Validator_register_attr (validator, "html", "lang",
+	                                     NULL);
+	ck_assert_int_ne (FALSE, result);
 
 	/* test */
 	_status_preinit (status);
@@ -149,7 +149,6 @@ START_TEST(test_validator_copy_with_status)
 	ck_assert_ptr_ne (NULL, copy->attrs);
 	ck_assert_ptr_ne (validator->attrs, copy->attrs);
 	ck_assert_int_eq (validator->attr_n, copy->attr_n);
-	ck_assert_int_eq (validator->last_attr, copy->last_attr);
 
 	#define TEST_INT(I) ck_assert_int_eq (validator->I, copy->I);
 	#define TEST_PTR(P) ck_assert_ptr_eq (validator->P, copy->P);
@@ -158,7 +157,6 @@ START_TEST(test_validator_copy_with_status)
 
 	for (size_t index = 0; index < copy->attr_n; index++)
 	{
-		TEST_INT(attrs[index].id)
 		TEST_STR(attrs[index].name)
 
 		TEST_INT(attrs[index].tag_n)
@@ -190,110 +188,112 @@ START_TEST(test_validator_register_no_status)
 	const char * attr4 = "src";
 	const char * attr5 = "content";
 	char * attrN;
-	Tag attr;
-	Tag attr_;
+	bool result;
 
 	/* setup */
 	validator = SH_Validator_new_html5 (NULL);
 	ck_assert_ptr_ne (NULL, validator);
 
 	/* test - register */
-	attr = SH_Validator_register_attr (validator, tag1, attr1, NULL);
-	ck_assert_int_eq (1, attr);
-
-	ck_assert_int_eq (validator->attr_n, 1);
-	ck_assert_int_eq (validator->last_attr, attr);
+	result = SH_Validator_register_attr (validator, tag1, attr1,
+	                                     NULL);
+	ck_assert_int_eq (TRUE, result);
 
-	ck_assert_int_eq (validator->attrs[0].id, attr);
-	ck_assert_ptr_ne (validator->attrs[0].name, attr1);
-	ck_assert_str_eq (validator->attrs[0].name, attr1);
+	ck_assert_int_eq (1, validator->attr_n);
+	ck_assert_ptr_ne (attr1, validator->attrs[0].name);
+	ck_assert_str_eq (attr1, validator->attrs[0].name);
 
-	ck_assert_int_eq (validator->attrs[0].tag_n, 1);
-	ck_assert_ptr_ne (validator->attrs[0].tags[0].name, tag1);
-	ck_assert_str_eq (validator->attrs[0].tags[0].name, tag1);
+	ck_assert_int_eq (1, validator->attrs[0].tag_n);
+	ck_assert_ptr_ne (tag1, validator->attrs[0].tags[0].name);
+	ck_assert_str_eq (tag1, validator->attrs[0].tags[0].name);
 
 	/* test - duplicate registration */
-	attr_ = SH_Validator_register_attr (validator, tag1, attr1, NULL);
-	ck_assert_int_eq (attr_, attr);
-
-	ck_assert_int_eq (validator->attr_n, 1);
-	ck_assert_int_eq (validator->last_attr, attr);
+	result = SH_Validator_register_attr (validator, tag1, attr1,
+	                                     NULL);
+	ck_assert_int_eq (TRUE, result);
 
-	ck_assert_int_eq (validator->attrs[0].id, attr);
-	ck_assert_ptr_ne (validator->attrs[0].name, attr1);
-	ck_assert_str_eq (validator->attrs[0].name, attr1);
+	ck_assert_int_eq (1, validator->attr_n);
+	ck_assert_ptr_ne (attr1, validator->attrs[0].name);
+	ck_assert_str_eq (attr1, validator->attrs[0].name);
 
-	ck_assert_int_eq (validator->attrs[0].tag_n, 1);
-	ck_assert_ptr_ne (validator->attrs[0].tags[0].name, tag1);
-	ck_assert_str_eq (validator->attrs[0].tags[0].name, tag1);
+	ck_assert_int_eq (1, validator->attrs[0].tag_n);
+	ck_assert_ptr_ne (tag1, validator->attrs[0].tags[0].name);
+	ck_assert_str_eq (tag1, validator->attrs[0].tags[0].name);
 
 	/* test - automatic tag register */
-	attr = SH_Validator_register_attr (validator, tag2, attr1, NULL);
-	ck_assert_int_eq (1, attr);
+	result = SH_Validator_register_attr (validator, tag2, attr1,
+	                                     NULL);
+	ck_assert_int_eq (TRUE, result);
 
-	ck_assert_int_eq (validator->attr_n, 1);
-	ck_assert_int_eq (validator->last_attr, attr);
+	ck_assert_int_eq (1, validator->attr_n);
+	ck_assert_ptr_ne (attr1, validator->attrs[0].name);
+	ck_assert_str_eq (attr1, validator->attrs[0].name);
 
-	ck_assert_int_eq (validator->attrs[0].id, attr);
-	ck_assert_str_eq (validator->attrs[0].name, attr1);
+	#define TEST_STR(S1, S2) ck_assert_ptr_ne (S1, S2);            \
+	                         ck_assert_str_eq (S1, S2);
 
-	ck_assert_int_eq (validator->attrs[0].tag_n, 2);
+	ck_assert_int_eq (2, validator->attrs[0].tag_n);
 	/* The storage order depends on the relative position of memory,
 	 * allocated by different malloc calls. This can change and
 	 * thus must be determined. */
 	if (validator->attrs[0].tags[0].name[0]
 	  > validator->attrs[0].tags[1].name[0])
 	{
-		ck_assert_ptr_ne (validator->attrs[0].tags[0].name, tag1);
-		ck_assert_str_eq (validator->attrs[0].tags[0].name, tag1);
-		ck_assert_ptr_ne (validator->attrs[0].tags[1].name, tag2);
-		ck_assert_str_eq (validator->attrs[0].tags[1].name, tag2);
+		TEST_STR(tag1, validator->attrs[0].tags[0].name)
+		TEST_STR(tag2, validator->attrs[0].tags[1].name)
 	}
 	else
 	{
-		ck_assert_ptr_ne (validator->attrs[0].tags[1].name, tag1);
-		ck_assert_str_eq (validator->attrs[0].tags[1].name, tag1);
-		ck_assert_ptr_ne (validator->attrs[0].tags[0].name, tag2);
-		ck_assert_str_eq (validator->attrs[0].tags[0].name, tag2);
+		TEST_STR(tag2, validator->attrs[0].tags[0].name)
+		TEST_STR(tag1, validator->attrs[0].tags[1].name)
 	}
 
-	/* test - order (attr) */
-	attr = SH_Validator_register_attr (validator, tag1, attr3, NULL);
-	ck_assert_int_eq (attr, 2);
+	#undef TEST_STR
 
-	attr = SH_Validator_register_attr (validator, tag1, attr4, NULL);
-	ck_assert_int_eq (attr, 3);
+	/* test - order (attr) */
+	result = SH_Validator_register_attr (validator, tag1, attr3,
+	                                     NULL);
+	ck_assert_int_eq (TRUE, result);
 
-	attr = SH_Validator_register_attr (validator, tag1, attr5, NULL);
-	ck_assert_int_eq (attr, 4);
+	result = SH_Validator_register_attr (validator, tag1, attr4,
+	                                     NULL);
+	ck_assert_int_eq (TRUE, result);
 
-	ck_assert_int_eq (validator->attr_n, 4);
+	result = SH_Validator_register_attr (validator, tag1, attr5,
+	                                     NULL);
+	ck_assert_int_eq (TRUE, result);
 
-	ck_assert_str_eq (validator->attrs[0].name, attr5);
-	ck_assert_str_eq (validator->attrs[1].name, attr1);
-	ck_assert_str_eq (validator->attrs[2].name, attr3);
-	ck_assert_str_eq (validator->attrs[3].name, attr4);
+	ck_assert_int_eq (4, validator->attr_n);
+	ck_assert_str_eq (attr5, validator->attrs[0].name);
+	ck_assert_str_eq (attr1, validator->attrs[1].name);
+	ck_assert_str_eq (attr3, validator->attrs[2].name);
+	ck_assert_str_eq (attr4, validator->attrs[3].name);
 
 	/* test - order (tag) */
-	attr = SH_Validator_register_attr (validator, tag2, attr4, NULL);
-	ck_assert_int_eq (attr, 3);
-
-	attr = SH_Validator_register_attr (validator, tag3, attr4, NULL);
-	ck_assert_int_eq (attr, 3);
+	result = SH_Validator_register_attr (validator, tag2, attr4,
+	                                     NULL);
+	ck_assert_int_eq (TRUE, result);
 
-	attr = SH_Validator_register_attr (validator, tag4, attr4, NULL);
-	ck_assert_int_eq (attr, 3);
+	result = SH_Validator_register_attr (validator, tag3, attr4,
+	                                     NULL);
+	ck_assert_int_eq (TRUE, result);
 
-	attr = SH_Validator_register_attr (validator, tag5, attr4, NULL);
-	ck_assert_int_eq (attr, 3);
+	result = SH_Validator_register_attr (validator, tag4, attr4,
+	                                     NULL);
+	ck_assert_int_eq (TRUE, result);
 
-	ck_assert_int_eq (5, validator->attrs[3].tag_n);
+	result = SH_Validator_register_attr (validator, tag5, attr4,
+	                                     NULL);
+	ck_assert_int_eq (TRUE, result);
 
-	for (size_t i = 0; i < validator->attrs[3].tag_n-1; i++)
+	#define attr validator->attrs[3]
+	ck_assert_int_eq (5, attr.tag_n);
+	for (size_t i = 0; i < attr.tag_n-1; i++)
 	{
-		ck_assert_int_lt ((size_t)validator->attrs[3].tags[i].name,
-		                  (size_t)validator->attrs[3].tags[i+1].name);
+		ck_assert_int_lt ((size_t)attr.tags[i].name,
+		                  (size_t)attr.tags[i+1].name);
 	}
+	#undef attr
 
 	/* test - overflow detection */
 	/* make method fail by filling with garbage until
@@ -312,25 +312,16 @@ START_TEST(test_validator_register_no_status)
 	{
 		sprintf (attrN, "attr%zu", validator->attr_n);
 	}
-	while (ATTR_ERR != SH_Validator_register_attr (validator, tag1, attrN, NULL));
+	while (SH_Validator_register_attr (validator, tag1, attrN, NULL));
 
 	free (attrN);
 
-	/* test overflow #1 */
-	attr = SH_Validator_register_attr (validator, tag1, attr2, NULL);
-	ck_assert_int_eq (ATTR_ERR, attr);
-
-	ck_assert_int_eq (validator->attr_n, 10);
-
-	/* test overflow #2 */
-	validator->attr_n = 1;
-	validator->last_attr = ATTR_MAX;
-
-	attr = SH_Validator_register_attr (validator, tag1, attr2, NULL);
-	ck_assert_int_eq (ATTR_ERR, attr);
+	/* test overflow */
+	result = SH_Validator_register_attr (validator, tag1, attr2,
+	                                     NULL);
+	ck_assert_int_eq (FALSE, result);
 
-	ck_assert_int_eq (validator->attr_n, 1);
-	ck_assert_int_eq (validator->last_attr, ATTR_MAX);
+	ck_assert_int_eq (10, validator->attr_n);
 
 	/* cleanup */
 	/* also free garbage created for overflow test */
@@ -353,8 +344,7 @@ START_TEST(test_validator_register_with_status)
 	const char * attr4 = "src";
 	const char * attr5 = "content";
 	char * attrN;
-	Tag attr;
-	Tag attr_;
+	bool result;
 
 	/* setup */
 	validator = SH_Validator_new_html5 (NULL);
@@ -362,121 +352,126 @@ START_TEST(test_validator_register_with_status)
 
 	/* test - register */
 	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag1, attr1, &status);
-	ck_assert_int_eq (1, attr);
+	result = SH_Validator_register_attr (validator, tag1, attr1,
+	                                     &status);
+	ck_assert_int_eq (TRUE, result);
 	ck_assert_int_eq (SUCCESS, status.status);
 
-	ck_assert_int_eq (validator->attr_n, 1);
-	ck_assert_int_eq (validator->last_attr, attr);
+	ck_assert_int_eq (1, validator->attr_n);
+	ck_assert_ptr_ne (attr1, validator->attrs[0].name);
+	ck_assert_str_eq (attr1, validator->attrs[0].name);
 
-	ck_assert_int_eq (validator->attrs[0].id, attr);
-	ck_assert_ptr_ne (validator->attrs[0].name, attr1);
-	ck_assert_str_eq (validator->attrs[0].name, attr1);
-
-	ck_assert_int_eq (validator->attrs[0].tag_n, 1);
-	ck_assert_ptr_ne (validator->attrs[0].tags[0].name, tag1);
-	ck_assert_str_eq (validator->attrs[0].tags[0].name, tag1);
+	ck_assert_int_eq (1, validator->attrs[0].tag_n);
+	ck_assert_ptr_ne (tag1, validator->attrs[0].tags[0].name);
+	ck_assert_str_eq (tag1, validator->attrs[0].tags[0].name);
 
 	/* test - duplicate registration */
 	_status_preinit (status);
-	attr_ = SH_Validator_register_attr (validator, tag1, attr1, &status);
-	ck_assert_int_eq (attr_, attr);
+	result = SH_Validator_register_attr (validator, tag1, attr1,
+	                                     &status);
+	ck_assert_int_eq (TRUE, result);
 	ck_assert_int_eq (SUCCESS, status.status);
 
-	ck_assert_int_eq (validator->attr_n, 1);
-	ck_assert_int_eq (validator->last_attr, attr);
+	ck_assert_int_eq (1, validator->attr_n);
+	ck_assert_ptr_ne (attr1, validator->attrs[0].name);
+	ck_assert_str_eq (attr1, validator->attrs[0].name);
 
-	ck_assert_int_eq (validator->attrs[0].id, attr);
-	ck_assert_ptr_ne (validator->attrs[0].name, attr1);
-	ck_assert_str_eq (validator->attrs[0].name, attr1);
-
-	ck_assert_int_eq (validator->attrs[0].tag_n, 1);
-	ck_assert_ptr_ne (validator->attrs[0].tags[0].name, tag1);
-	ck_assert_str_eq (validator->attrs[0].tags[0].name, tag1);
+	ck_assert_int_eq (1, validator->attrs[0].tag_n);
+	ck_assert_ptr_ne (tag1, validator->attrs[0].tags[0].name);
+	ck_assert_str_eq (tag1, validator->attrs[0].tags[0].name);
 
 	/* test - automatic tag register */
 	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag2, attr1, &status);
-	ck_assert_int_eq (1, attr);
+	result = SH_Validator_register_attr (validator, tag2, attr1,
+	                                     &status);
+	ck_assert_int_eq (TRUE, result);
 	ck_assert_int_eq (SUCCESS, status.status);
 
-	ck_assert_int_eq (validator->attr_n, 1);
-	ck_assert_int_eq (validator->last_attr, attr);
+	ck_assert_int_eq (1, validator->attr_n);
+	ck_assert_ptr_ne (attr1, validator->attrs[0].name);
+	ck_assert_str_eq (attr1, validator->attrs[0].name);
 
-	ck_assert_int_eq (validator->attrs[0].id, attr);
-	ck_assert_str_eq (validator->attrs[0].name, attr1);
+	#define TEST_STR(S1, S2) ck_assert_ptr_ne (S1, S2);            \
+	                         ck_assert_str_eq (S1, S2);
 
-	ck_assert_int_eq (validator->attrs[0].tag_n, 2);
+	ck_assert_int_eq (2, validator->attrs[0].tag_n);
 	/* The storage order depends on the relative position of memory,
 	 * allocated by different malloc calls. This can change and
 	 * thus must be determined. */
 	if (validator->attrs[0].tags[0].name[0]
 	  > validator->attrs[0].tags[1].name[0])
 	{
-		ck_assert_ptr_ne (validator->attrs[0].tags[0].name, tag1);
-		ck_assert_str_eq (validator->attrs[0].tags[0].name, tag1);
-		ck_assert_ptr_ne (validator->attrs[0].tags[1].name, tag2);
-		ck_assert_str_eq (validator->attrs[0].tags[1].name, tag2);
+		TEST_STR(tag1, validator->attrs[0].tags[0].name)
+		TEST_STR(tag2, validator->attrs[0].tags[1].name)
 	}
 	else
 	{
-		ck_assert_ptr_ne (validator->attrs[0].tags[1].name, tag1);
-		ck_assert_str_eq (validator->attrs[0].tags[1].name, tag1);
-		ck_assert_ptr_ne (validator->attrs[0].tags[0].name, tag2);
-		ck_assert_str_eq (validator->attrs[0].tags[0].name, tag2);
+		TEST_STR(tag2, validator->attrs[0].tags[0].name)
+		TEST_STR(tag1, validator->attrs[0].tags[1].name)
 	}
 
+	#undef TEST_STR
+
 	/* test - order (attr) */
 	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag1, attr3, &status);
-	ck_assert_int_eq (attr, 2);
-	ck_assert_int_eq (status.status, SUCCESS);
+	result = SH_Validator_register_attr (validator, tag1, attr3,
+	                                     &status);
+	ck_assert_int_eq (TRUE, result);
+	ck_assert_int_eq (SUCCESS, status.status);
 
 	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag1, attr4, &status);
-	ck_assert_int_eq (attr, 3);
-	ck_assert_int_eq (status.status, SUCCESS);
+	result = SH_Validator_register_attr (validator, tag1, attr4,
+	                                     &status);
+	ck_assert_int_eq (TRUE, result);
+	ck_assert_int_eq (SUCCESS, status.status);
 
 	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag1, attr5, &status);
-	ck_assert_int_eq (attr, 4);
-	ck_assert_int_eq (status.status, SUCCESS);
-
-	ck_assert_int_eq (validator->attr_n, 4);
+	result = SH_Validator_register_attr (validator, tag1, attr5,
+	                                     &status);
+	ck_assert_int_eq (TRUE, result);
+	ck_assert_int_eq (SUCCESS, status.status);
 
-	ck_assert_str_eq (validator->attrs[0].name, attr5);
-	ck_assert_str_eq (validator->attrs[1].name, attr1);
-	ck_assert_str_eq (validator->attrs[2].name, attr3);
-	ck_assert_str_eq (validator->attrs[3].name, attr4);
+	ck_assert_int_eq (4, validator->attr_n);
+	ck_assert_str_eq (attr5, validator->attrs[0].name);
+	ck_assert_str_eq (attr1, validator->attrs[1].name);
+	ck_assert_str_eq (attr3, validator->attrs[2].name);
+	ck_assert_str_eq (attr4, validator->attrs[3].name);
 
 	/* test - order (tag) */
 	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag2, attr4, &status);
-	ck_assert_int_eq (attr, 3);
-	ck_assert_int_eq (status.status, SUCCESS);
+	result = SH_Validator_register_attr (validator, tag2, attr4,
+	                                     &status);
+	ck_assert_int_eq (TRUE, result);
+	ck_assert_int_eq (SUCCESS, status.status);
 
 	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag3, attr4, &status);
-	ck_assert_int_eq (attr, 3);
-	ck_assert_int_eq (status.status, SUCCESS);
+	result = SH_Validator_register_attr (validator, tag3, attr4,
+	                                     &status);
+	ck_assert_int_eq (TRUE, result);
+	ck_assert_int_eq (SUCCESS, status.status);
 
 	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag4, attr4, &status);
-	ck_assert_int_eq (attr, 3);
-	ck_assert_int_eq (status.status, SUCCESS);
+	result = SH_Validator_register_attr (validator, tag4, attr4,
+	                                     &status);
+	ck_assert_int_eq (TRUE, result);
+	ck_assert_int_eq (SUCCESS, status.status);
 
 	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag5, attr4, &status);
-	ck_assert_int_eq (attr, 3);
-	ck_assert_int_eq (status.status, SUCCESS);
+	result = SH_Validator_register_attr (validator, tag5, attr4,
+	                                     &status);
+	ck_assert_int_eq (TRUE, result);
+	ck_assert_int_eq (SUCCESS, status.status);
 
 	ck_assert_int_eq (5, validator->attrs[3].tag_n);
 
-	for (size_t i = 0; i < validator->attrs[3].tag_n-1; i++)
+	#define attr validator->attrs[3]
+	ck_assert_int_eq (5, attr.tag_n);
+	for (size_t i = 0; i < attr.tag_n-1; i++)
 	{
-		ck_assert_int_lt ((size_t)validator->attrs[3].tags[i].name,
-		                  (size_t)validator->attrs[3].tags[i+1].name);
+		ck_assert_int_lt ((size_t)attr.tags[i].name,
+		                  (size_t)attr.tags[i+1].name);
 	}
+	#undef attr
 
 	/* test - overflow detection */
 	/* make method fail by filling with garbage until
@@ -495,29 +490,18 @@ START_TEST(test_validator_register_with_status)
 	{
 		sprintf (attrN, "attr%zu", validator->attr_n);
 	}
-	while (ATTR_ERR != SH_Validator_register_attr (validator, tag1, attrN, NULL));
+	while (SH_Validator_register_attr (validator, tag1, attrN, NULL));
 
 	free (attrN);
 
-	/* test overflow #1 */
-	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag1, attr2, &status);
-	ck_assert_int_eq (ATTR_ERR, attr);
-	ck_assert_int_eq (E_DOMAIN, status.status);
-
-	ck_assert_int_eq (validator->attr_n, 10);
-
-	/* test overflow #2 */
-	validator->attr_n = 1;
-	validator->last_attr = ATTR_MAX;
-
+	/* test overflow */
 	_status_preinit (status);
-	attr = SH_Validator_register_attr (validator, tag1, attr2, &status);
-	ck_assert_int_eq (ATTR_ERR, attr);
+	result = SH_Validator_register_attr (validator, tag1, attr2,
+	                                     &status);
+	ck_assert_int_eq (FALSE, result);
 	ck_assert_int_eq (E_DOMAIN, status.status);
 
-	ck_assert_int_eq (validator->attr_n, 1);
-	ck_assert_int_eq (validator->last_attr, ATTR_MAX);
+	ck_assert_int_eq (10, validator->attr_n);
 
 	/* cleanup */
 	/* also free garbage created for overflow test */
@@ -528,29 +512,30 @@ START_TEST(test_validator_register_with_status)
 START_TEST(test_validator_deregister_no_status)
 {
 	struct SH_Validator * validator;
-	Attr attr;
 	bool result;
 
 	/* setup */
 	validator = SH_Validator_new (NULL);
 	ck_assert_ptr_ne (NULL, validator);
 
-	attr = SH_Validator_register_attr (validator, "html", "attr", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "html", "id", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "html", "name", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "html", "class", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "body", "attr", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "body", "id", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "body", "name", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "body", "class", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
+	#define REGISTER SH_Validator_register_attr
+	result = REGISTER (validator, "html", "attr", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "html", "id", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "html", "name", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "html", "class", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "body", "attr", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "body", "id", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "body", "name", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "body", "class", NULL);
+	ck_assert_int_ne (FALSE, result);
+	#undef REGISTER
 
 	/* test - consistency */
 	ck_assert_int_eq (4, validator->attr_n);
@@ -563,47 +548,48 @@ START_TEST(test_validator_deregister_no_status)
 	ck_assert_int_eq (2, validator->attrs[2].tag_n);
 	ck_assert_int_eq (2, validator->attrs[3].tag_n);
 
+	#define STR_EQ ck_assert_str_eq
 	/* The storage order depends on the relative position of memory,
 	 * allocated by different malloc calls. This can change and
 	 * thus must be determined. */
 	if (validator->attrs[0].tags[0].name[0]
 	  > validator->attrs[0].tags[1].name[0])
 	{
-		ck_assert_str_eq ("html", validator->attrs[0].tags[0].name);
-		ck_assert_str_eq ("html", validator->attrs[1].tags[0].name);
-		ck_assert_str_eq ("html", validator->attrs[2].tags[0].name);
-		ck_assert_str_eq ("html", validator->attrs[3].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[0].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[1].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[2].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[3].tags[1].name);
+		STR_EQ ("html", validator->attrs[0].tags[0].name);
+		STR_EQ ("html", validator->attrs[1].tags[0].name);
+		STR_EQ ("html", validator->attrs[2].tags[0].name);
+		STR_EQ ("html", validator->attrs[3].tags[0].name);
+		STR_EQ ("body", validator->attrs[0].tags[1].name);
+		STR_EQ ("body", validator->attrs[1].tags[1].name);
+		STR_EQ ("body", validator->attrs[2].tags[1].name);
+		STR_EQ ("body", validator->attrs[3].tags[1].name);
 	}
 	else
 	{
-		ck_assert_str_eq ("html", validator->attrs[0].tags[1].name);
-		ck_assert_str_eq ("html", validator->attrs[1].tags[1].name);
-		ck_assert_str_eq ("html", validator->attrs[2].tags[1].name);
-		ck_assert_str_eq ("html", validator->attrs[3].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[0].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[1].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[2].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[3].tags[0].name);
+		STR_EQ ("html", validator->attrs[0].tags[1].name);
+		STR_EQ ("html", validator->attrs[1].tags[1].name);
+		STR_EQ ("html", validator->attrs[2].tags[1].name);
+		STR_EQ ("html", validator->attrs[3].tags[1].name);
+		STR_EQ ("body", validator->attrs[0].tags[0].name);
+		STR_EQ ("body", validator->attrs[1].tags[0].name);
+		STR_EQ ("body", validator->attrs[2].tags[0].name);
+		STR_EQ ("body", validator->attrs[3].tags[0].name);
 	}
-
+	#undef STR_EQ
 
 	/* test - existent attr */
-	result = SH_Validator_deregister_attr (validator, "html", "attr",
-	                                       NULL);
+	result = SH_Validator_deregister_attr (validator,
+	                                       "html", "attr", NULL);
 	ck_assert_int_eq (TRUE, result);
 
 	/* test - non existent tag */
-	result = SH_Validator_deregister_attr (validator, "html", "attr",
-	                                       NULL);
+	result = SH_Validator_deregister_attr (validator,
+	                                       "html", "attr", NULL);
 	ck_assert_int_eq (FALSE, result);
 
 	/* test - existent attr, auto remove */
-	result = SH_Validator_deregister_attr (validator, "body", "attr",
-	                                       NULL);
+	result = SH_Validator_deregister_attr (validator,
+	                                       "body", "attr", NULL);
 	ck_assert_int_eq (TRUE, result);
 
 	/* test - consistency */
@@ -638,24 +624,27 @@ START_TEST(test_validator_deregister_no_status)
 	ck_assert_int_eq (2, validator->attrs[0].tag_n);
 	ck_assert_int_eq (2, validator->attrs[1].tag_n);
 
+
+	#define STR_EQ ck_assert_str_eq
 	/* The storage order depends on the relative position of memory,
 	 * allocated by different malloc calls. This can change and
 	 * thus must be determined. */
 	if (validator->attrs[0].tags[0].name[0]
 	  > validator->attrs[0].tags[1].name[0])
 	{
-		ck_assert_str_eq ("html", validator->attrs[0].tags[0].name);
-		ck_assert_str_eq ("html", validator->attrs[1].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[0].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[1].tags[1].name);
+		STR_EQ ("html", validator->attrs[0].tags[0].name);
+		STR_EQ ("html", validator->attrs[1].tags[0].name);
+		STR_EQ ("body", validator->attrs[0].tags[1].name);
+		STR_EQ ("body", validator->attrs[1].tags[1].name);
 	}
 	else
 	{
-		ck_assert_str_eq ("html", validator->attrs[0].tags[1].name);
-		ck_assert_str_eq ("html", validator->attrs[1].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[0].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[1].tags[0].name);
+		STR_EQ ("html", validator->attrs[0].tags[1].name);
+		STR_EQ ("html", validator->attrs[1].tags[1].name);
+		STR_EQ ("body", validator->attrs[0].tags[0].name);
+		STR_EQ ("body", validator->attrs[1].tags[0].name);
 	}
+	#undef STR_EQ
 
 
 	/* test - existent tag, total remove */
@@ -695,29 +684,30 @@ START_TEST(test_validator_deregister_with_status)
 {
 	struct SH_Status status;
 	struct SH_Validator * validator;
-	Attr attr;
 	bool result;
 
 	/* setup */
 	validator = SH_Validator_new (NULL);
 	ck_assert_ptr_ne (NULL, validator);
 
-	attr = SH_Validator_register_attr (validator, "html", "attr", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "html", "id", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "html", "name", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "html", "class", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "body", "attr", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "body", "id", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "body", "name", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, "body", "class", NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
+	#define REGISTER SH_Validator_register_attr
+	result = REGISTER (validator, "html", "attr", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "html", "id", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "html", "name", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "html", "class", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "body", "attr", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "body", "id", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "body", "name", NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, "body", "class", NULL);
+	ck_assert_int_ne (FALSE, result);
+	#undef REGISTER
 
 	/* test - consistency */
 	ck_assert_int_eq (4, validator->attr_n);
@@ -730,32 +720,34 @@ START_TEST(test_validator_deregister_with_status)
 	ck_assert_int_eq (2, validator->attrs[2].tag_n);
 	ck_assert_int_eq (2, validator->attrs[3].tag_n);
 
+	#define STR_EQ ck_assert_str_eq
 	/* The storage order depends on the relative position of memory,
 	 * allocated by different malloc calls. This can change and
 	 * thus must be determined. */
 	if (validator->attrs[0].tags[0].name[0]
 	  > validator->attrs[0].tags[1].name[0])
 	{
-		ck_assert_str_eq ("html", validator->attrs[0].tags[0].name);
-		ck_assert_str_eq ("html", validator->attrs[1].tags[0].name);
-		ck_assert_str_eq ("html", validator->attrs[2].tags[0].name);
-		ck_assert_str_eq ("html", validator->attrs[3].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[0].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[1].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[2].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[3].tags[1].name);
+		STR_EQ ("html", validator->attrs[0].tags[0].name);
+		STR_EQ ("html", validator->attrs[1].tags[0].name);
+		STR_EQ ("html", validator->attrs[2].tags[0].name);
+		STR_EQ ("html", validator->attrs[3].tags[0].name);
+		STR_EQ ("body", validator->attrs[0].tags[1].name);
+		STR_EQ ("body", validator->attrs[1].tags[1].name);
+		STR_EQ ("body", validator->attrs[2].tags[1].name);
+		STR_EQ ("body", validator->attrs[3].tags[1].name);
 	}
 	else
 	{
-		ck_assert_str_eq ("html", validator->attrs[0].tags[1].name);
-		ck_assert_str_eq ("html", validator->attrs[1].tags[1].name);
-		ck_assert_str_eq ("html", validator->attrs[2].tags[1].name);
-		ck_assert_str_eq ("html", validator->attrs[3].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[0].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[1].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[2].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[3].tags[0].name);
+		STR_EQ ("html", validator->attrs[0].tags[1].name);
+		STR_EQ ("html", validator->attrs[1].tags[1].name);
+		STR_EQ ("html", validator->attrs[2].tags[1].name);
+		STR_EQ ("html", validator->attrs[3].tags[1].name);
+		STR_EQ ("body", validator->attrs[0].tags[0].name);
+		STR_EQ ("body", validator->attrs[1].tags[0].name);
+		STR_EQ ("body", validator->attrs[2].tags[0].name);
+		STR_EQ ("body", validator->attrs[3].tags[0].name);
 	}
+	#undef STR_EQ
 
 
 	/* test - existent attr */
@@ -817,24 +809,27 @@ START_TEST(test_validator_deregister_with_status)
 	ck_assert_int_eq (2, validator->attrs[0].tag_n);
 	ck_assert_int_eq (2, validator->attrs[1].tag_n);
 
+
+	#define STR_EQ ck_assert_str_eq
 	/* The storage order depends on the relative position of memory,
 	 * allocated by different malloc calls. This can change and
 	 * thus must be determined. */
 	if (validator->attrs[0].tags[0].name[0]
 	  > validator->attrs[0].tags[1].name[0])
 	{
-		ck_assert_str_eq ("html", validator->attrs[0].tags[0].name);
-		ck_assert_str_eq ("html", validator->attrs[1].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[0].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[1].tags[1].name);
+		STR_EQ ("html", validator->attrs[0].tags[0].name);
+		STR_EQ ("html", validator->attrs[1].tags[0].name);
+		STR_EQ ("body", validator->attrs[0].tags[1].name);
+		STR_EQ ("body", validator->attrs[1].tags[1].name);
 	}
 	else
 	{
-		ck_assert_str_eq ("html", validator->attrs[0].tags[1].name);
-		ck_assert_str_eq ("html", validator->attrs[1].tags[1].name);
-		ck_assert_str_eq ("body", validator->attrs[0].tags[0].name);
-		ck_assert_str_eq ("body", validator->attrs[1].tags[0].name);
+		STR_EQ ("html", validator->attrs[0].tags[1].name);
+		STR_EQ ("html", validator->attrs[1].tags[1].name);
+		STR_EQ ("body", validator->attrs[0].tags[0].name);
+		STR_EQ ("body", validator->attrs[1].tags[0].name);
 	}
+	#undef STR_EQ
 
 
 	/* test - existent tag, total remove */
@@ -887,17 +882,19 @@ START_TEST(test_validator_check)
 	const char * attr2  = "id";
 	const char * attr3  = "class";
 	const char * attr4  = "name";
-	Tag attr;
 	bool result;
 
 	/* setup */
 	validator = SH_Validator_new (NULL);
 	ck_assert_ptr_ne (NULL, validator);
 
-	attr = SH_Validator_register_attr (validator, tag1, attr1, NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
-	attr = SH_Validator_register_attr (validator, tag3, attr3, NULL);
-	ck_assert_int_ne (ATTR_ERR, attr);
+
+	#define REGISTER SH_Validator_register_attr
+	result = REGISTER (validator, tag1, attr1, NULL);
+	ck_assert_int_ne (FALSE, result);
+	result = REGISTER (validator, tag3, attr3, NULL);
+	ck_assert_int_ne (FALSE, result);
+	#undef REGISTER
 
 	/* test */
 	result = SH_Validator_check_attr (validator, tag1, attr1);