The common code to cleanup in case of an error was bundled at the end of
the function. For people complaining about the use of goto: this is the
exact use case, where it is recommended!

Two alternatives are provided: remove_attr and pop_attr. While the
former free's the Attr's data, the latter allocates a new Attr, to store
and return the data. Both functionality is provided by a single
(internal) static method.

This method needs to be used in places where freeing the src-pointer is
not possible, as it may be not allocated. If freeing is needed, it is
now in the responsibility of the caller. As it turns out this approach
is not even more useful, it is also less work, as it can be determined
from the fact, that adjusting the tests to the new behavior means
actually removing lines, that were previously working around the quirks,
that the old approach introduced.

Until now, the configure script just checked for check to be installed,
which is needed to compile the tests.
Now, configure provides a conditional (MISSING_CHECK) depending on its
presence for use by automake. If check is missing, the tests aren't
compiled. Instead a special script is executed to inform the user of the
problem and stops the testsuite. Note, that it was not possible to
directly stop the generation of the testsuite by injecting a rule to a
Makefile without relying on implementation details of automake.
See:
https://stackoverflow.com/questions/76376806/automake-how-to-portably-throw-an-error-and-aborting-the-target/76382437
To allow the script to issue messages to stderr, AM_TESTS_FD_REDIRECT is
used, because the parallel test harness redirects output of its tests to
logfiles. This isn't used for the serial test harness, because there is
no redirection to logfiles, but there AM_TESTS_FD_REDIRECT is also not
taken into account.
See:
https://www.gnu.org/software/automake/manual/html_node/Testsuite-Environment-Overrides.html
Additionaly configure also provides an argument to enforce both
behaviours. When specifying --enable-tests=no the tests are not compiled
regardless of the presence of check. If --enable-tests=yes, it is
assumed, that tests are really needed and the mandantory check for check
is performed thus providing the former behaviour. If not specified
--enable-tests default to auto, which results in the same behaviour as
--enable-tests=yes, if check is present, and like --enable-tests=no
otherwise.

Hiding files, that are generated during build, shouldn't be a personal
choice, thus they should be added to the global .gitignore.
Note that in this project it is choosen, to not include generated files
into the version control system, but of course they must be always
included for distributions.

The prepend_child and append_child methods were previously not tested.
They are now added to testing.

Hand in still missing tests.

added tests for getter

This is a severe bug. The purpose of Attr_free is to free the internal
data, while leaving the outer structure unfreed. What is needed here is
quite the opposite: freeing the outer structure but leaving the internal
data intact. Of course the internal data is still needed, as it is data
that was just assigned to the dest Attr. This bug introduced a double
free, which is undefined behaviour with all of it's scary effects.

Sometimes it is interesting to know, whether to Attr are referring to
the same attribute. Note that it is not intended to provide a method for
the values, as that would be meaningless on its own and if it is used in
a more complex tasks, this is still possible with the current set of
methods, which is prefered as the complex task can then be implemented
on the outside completely.

A method to compare two Attr's for exact equality was added both to
internal and external methods.

Sometimes you want to reuse an Attr after adding it, this is done via
the insert_copy methods.

When a child is removed, the array may be reallocated, to not waste
unused memory. If the child is removed out of the middle, all subsequent
childs have to be moved. However, if it turns out that the reallocation
is not currently possible, the method should return the NodeFragment in
a state, as if the call to the remove method never happened. This means,
that all the childs, that were moved before the realloc call, have to be
moved back and the original child has also to be written back. This was
forgotten, which is clearly a bug, which is fixed hereby.
Note that it would be theoretically possible to not move everything back
and forth, by storing the last value before the call to realloc and only
in case of success move everything. While this is possible and more
efficient, it is also a bit more complicated, and as this only takes
effect, if the OS fails to provide memory, which should be an uncommon
event, the algorithm is not changed, leaving that possible inefficient
approach.

The method SH_NodeFragment_get_attr provides a pointer to an Attr, by
its index. Note, that it directly points to the internal data, instead
of copying the data to a new Attr, which would be unneccessary overhead,
if only reading access is needed. That's why it is also a const pointer.
If the user intends to modify it, a copy should be taken via
SH_Attr_copy.

Multiple insert methods allow either to add an existing Attr, or to
create a new one implicitly. If the Attr is not already used beforehand,
it is more efficient to call the attr_new methods. Also an old Attr is
freed, after it was inserted, thus it can't be used afterwards. This is
neccessary, as for efficiency reasons an array of Attr is used directly,
instead of the indirect approach of storing a pointer of Attr. This
means, that the contents of the Attr has to be copied to the internal
structure. If the old Attr would be left unfreed, there would be two
Attrs, the original one and the implicit one, referring to the same
data, which would lead to at least data corruption, or undefined
behaviour like a double free, which would be a serious threat for a
library which is to be used on a webserver. ...
For each of the two insert modes, there is a method to prepend, append
or insert at a specific position. An incorrect position is handled
inside of the external method and an E_VALUE is thrown. The internal
method doesn't handle this, so special care must be taken to not make
undefined behaviour. However enforcing this check would be unneccessary
overhead for the prepend and append methods, which are known to have
correct indicies, as well for other internal methods, where the internal
method may be used.

The tests for the new methods are still missing, as well as the methods
to remove an Attr. As the implementation is already a bit dated, the
changes are commited now anyways.

Added the allocation part of the implementation of attributes. Also some
tests were improved.
The functions to add and remove attributes are not implemented, as well
as the generation of the html for the attributes. Thats why also test
can't really test the attributes as it is not possible to add
attributes.

Copy the the contents from one Attr to another and clear the first one.

For every function there is also a static method/function which can
perform the same work, but doesn't rely on really having an struct Attr.
This is useful for example in an array to manipulate a single element
while still using the same code.
Also the orginal methods are implemented with the new internal ones
themselves.

They are used later, if another internal module wants to use them.

This is used later, if another internal module wants to include the
declaration.

When used with care, it is possible to bypass many strdup calls.

When used with care, it is possible to bypass many strdup calls.
To also save the instructions for the call, which are a lot of overhead
now, link time optimization is turned on. (-flto)

Sometimes a copy is useful.

As usual it should be also possible to bypass calls to strdup, while
also taking care.

The structure SH_Attr implements an HTML Attribute.

The function get_alloc_size was renamed to get_child_alloc_size as the
attributes will need another function.

Various remove methods were added, which are all implemented by an
static method, analog to the last commit.

The single method (formerly SH_NodeFragment_append_child) to add a child
at the end of the child list was replaced, by a bunch of methods to
insert a child at the beginning (SH_NodeFragment_prepend_child), at the
end (SH_NodeFragment_append_child), at a specific position
(SH_NodeFragment_insert_child) and directly before
(SH_NodeFragment_insert_child_before) or after another child
(SH_NodeFragment_insert_child_after). All these methods are implemented
by a single internal one (insert_child), as there isn't really much
difference in inserting one or the other way.
But this internal method doesn't check whether this insertion request is
actually doable, to save overhead as not every insertion method requires
this check. This is done by the respective method. However if the check
is not done correctly the internal method will attempt to write at not
allocated space, which will hopefully result in a segfault.

The child list is implemented as an array. To reduce the overhead to
realloc calls, the array is allocated in chunks of childs. The
calculation how many has to be allocated is done by another static
method and determined by the macro CHILD_CHUNK. This is set to 5, which
is just a guess. It should be somewhere around the average number of
childs per html element, to reduce unused overhead.

Also some predicates (SH_NodeFragment_is_parent,
SH_NodeFragment_is_ancestor) were added to check whether a relationship
exists between to nodes, thus whether they are linked through one or
multiple levels. These functions could replace the old ones
(SH_NodeFragment_is_child, SH_NodeFragment_is_descendant) semantically.
Furthermore they are more efficient as this is now possible to check
over the parent pointer. The internal insert method also uses these
methods to check whether the child node is actually a parent of the
parent node, which would result in errors later one.

The old test is now obsolete but remained, as it is not bad to test
more.

Removed some unnecessary type casts.
Added some forgotten calls to free.

Every fragment has a parent now, this is useful for both traversing the
tree and checking for cycles when a node is added, which would cause
problems, like freeing things twice or similar nice bugs. Both wouldn't
be possible otherwise. These features are not implemented yet.

The library provides a way to directly access the tag in a read-only
way, which saves an call to strdup. This is useful if only reading is
necessary , but needs special care by developers, as it is neither
allowed to modify it nor to free it. Disregarding this will lead to a
segfault in the best, and to silent data corruption and security bugs in
the worst case.