Initial commit

.gitignore

@@ -0,0 +1,85 @@
+# specific name of executable generated
+toh_main_driver
+toh_test_driver
+
+# Created by https://www.gitignore.io/api/c++,macos,linux
+# Edit at https://www.gitignore.io/?templates=c++,macos,linux
+
+### C++ ###
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### macOS ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# End of https://www.gitignore.io/api/c++,macos,linux

README.md

@@ -0,0 +1,6 @@
+### if.04.22 Procedural Programming
+# Assignment – Sorting and Searching
+
+With this assignment you shall implement sorting and searching algorithms in C.
+
+Clone this assignment, open the index.html, read the assignment instructions and try to make all unit tests green.

allocator.c

@@ -0,0 +1,108 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Title:			Allocator for lists and list elements.
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Implementation of memory allocation functions.
+ * ----------------------------------------------------------
+ */
+
+#include "allocator.h"
+#include <stdio.h>
+#include <string.h>
+#include "shortcut.h"
+
+/* ===================================================================== */
+/* Private memory allocation functions */
+#define MAX_BLOCK_CNT 64
+struct MemAllocStat {
+    bool block_alloc_calls;
+    int alloc_call_cnt;
+    int free_call_cnt;
+    int mem_block_cnt;
+    void* mem_blocks[MAX_BLOCK_CNT];
+};
+static struct MemAllocStat mem_stat = {false, 0, 0, 0, {0}};
+
+void mem_reset_calls() {
+    mem_stat.block_alloc_calls = false;
+    mem_stat.alloc_call_cnt = 0;
+    mem_stat.free_call_cnt = 0;
+}
+
+void mem_reset_stat() {
+    mem_reset_calls();
+    memset(mem_stat.mem_blocks, 0, MAX_BLOCK_CNT * sizeof(void*));
+    mem_stat.mem_block_cnt = 0;
+}
+
+static int mem_get_alloc_idx(void* p) {
+    if (p == 0) {
+        return MAX_BLOCK_CNT;
+    }
+    
+    int idx = 0;
+    for (; idx < MAX_BLOCK_CNT && p != mem_stat.mem_blocks[idx]; idx++);
+    return idx;
+}
+
+bool mem_is_allocated(void* p) {
+    return mem_get_alloc_idx(p) < MAX_BLOCK_CNT;
+}
+
+void mem_block_allocs(bool block) {
+    mem_stat.block_alloc_calls = block;
+}
+
+int mem_get_alloc_call_cnt() {
+    return mem_stat.alloc_call_cnt;
+}
+
+int mem_get_free_call_cnt() {
+    return mem_stat.free_call_cnt;
+}
+
+int mem_get_allocated_block_cnt() {
+    return mem_stat.mem_block_cnt;
+}
+
+/* ===================================================================== */
+
+void* alloc_mem(size_t size) {
+    void* p = 0;
+    mem_stat.alloc_call_cnt++;
+    if (!mem_stat.block_alloc_calls) {
+        p = malloc(size);
+        if (p != 0) {
+            int idx = 0;
+            for (; idx < MAX_BLOCK_CNT && mem_stat.mem_blocks[idx] != 0; idx++);
+            if (idx < MAX_BLOCK_CNT) {
+                mem_stat.mem_blocks[idx] = p;
+                mem_stat.mem_block_cnt++;
+            } else {
+                free(p);
+                p = 0;
+            }
+        }
+    }
+    return p;
+}
+
+void free_mem(void* p_mem) {
+    mem_stat.free_call_cnt++;
+    if(p_mem == 0) {
+		printf("\tFailure: Freeing 0 (NULL)\n");
+    } else {
+        int mem_block_idx = mem_get_alloc_idx(p_mem);
+        if(mem_block_idx >= MAX_BLOCK_CNT) {
+            printf("\tFailure: Freeing memory that is not allocated [%p]\n", p_mem);
+        } else {
+            mem_stat.mem_blocks[mem_block_idx] = 0;
+            mem_stat.mem_block_cnt--;
+        }
+    }
+    free(p_mem);
+}
+

allocator.h

@@ -0,0 +1,50 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Title:			Dynamic memory allocator.
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Declaration of memory allocation functions.
+ * ----------------------------------------------------------
+ */
+
+#ifndef ___ALLOCATOR__H
+#define ___ALLOCATOR__H
+
+#include <stdlib.h>
+#include <stdbool.h>
+
+/**
+ * Allocates a memory block of the given size in bytes
+ * in a similar way as `malloc(size)`.
+ * 
+ * Note: use `sizeof(X)` function to determines the size
+ * of a specfic type or value.
+ * 
+ * @param size The number of bytes to allocate.
+ * @return The pointer to the allocated memory block or 0,
+ * if no memory could be allocated.
+ */
+void* alloc_mem(size_t size);
+
+/**
+ * Release the addressed memory block that was allocated via function `alloc_mem(...)`.
+ * 
+ * @param p_mem The pointer to the memory to free.
+ */
+void free_mem(void* p_mem);
+
+/* ==================================================== */
+/* functions used for testing only! */
+
+void mem_reset_calls();
+void mem_reset_stat();
+bool mem_is_allocated(void* p);
+void mem_block_allocs(bool block);
+int mem_get_alloc_call_cnt();
+int mem_get_free_call_cnt();
+int mem_get_allocated_block_cnt();
+
+
+#endif

array_backed_list.c

@@ -0,0 +1,65 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Class: <your class>
+ * ---------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Array backed List implementation
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Implementation of an array backed list.
+ * ----------------------------------------------------------
+ */
+
+/*
+  Implementation notes:
+
+  1) The 'ListData' struct of this linked list SHALL have
+     - a buffer for the payload data (array of integer), 
+     - the capacity of the buffer (length of the array)
+     - and the size of the list (number actual element in the list)
+    as members!
+
+  2) List allocation: 
+     Use functions `mem_alloc(…)` and `mem_free(…)`
+     declared in `allocator.h`. DO NOT use `malloc(…)` and `free(…)` directly
+     as unit tests will fail.
+
+    Note:
+     a) `list_obtain` shall allocate only the list data, but NOT the payload buffer
+     b) The payload buffer shall be allocated when a value is inserted the first time.
+        The payload buffer shall be increased if an additional item shall be inserted 
+        (via one of the insert functions) no capacity is left. All  values contained in the list
+        shall be copied into the increased buffer.
+        Initial allocation of the payload buffer and increasing the payload buffer is actually
+        the same case, because the initial capacity is 0 and therefore no capacity is left.
+        The payload buffer shall be increased by `CAPACITY_INCREMENT` (`config.h`) items.        
+     c) `list_clear` shall NOT free the payload buffer. Setting the size to 0 is sufficient.
+     d) `list_release` shall free the payload buffer, if it was allocated.
+
+  3) Use 'limits.h' to get maximum and minimum values for numeric types, if needed.
+
+*/
+
+#include "array_backed_list.h"
+
+/* add includes as needed */
+
+#include "config.h"
+#include "allocator.h"
+
+
+/** The implementation of list data: payload-buffer, capacity, size */
+struct IntListData {
+};
+
+/* ===================================================================== */
+/* private list functions */
+
+/** 
+ * Enlarges the backing array by the given amount of items. 
+ * Hint: memcpy may be used to copy all bytes(!) from the existing to the new buffer
+ */
+static void increase_buffer(IntList list, unsigned int additional_capacity) {
+}
+
+/* ===================================================================== */

array_backed_list.h

@@ -0,0 +1,26 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Class: <your class>
+ * ---------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Array backed List
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * The declaration of an abstract data type
+ * based on an implementation of an array backed list.
+ * ----------------------------------------------------------
+ */
+
+#ifndef ___ARRAY_BACKED_LIST__H
+#define ___ARRAY_BACKED_LIST__H
+
+#include "list.h"
+
+/** This header file maps only the common 'list' interface
+ * into naming conventions for doubly linked list implementation.
+ * 
+ * It does (for now) not extend or alter the function prototypes of the
+ * common interface.
+ */
+
+#endif

bubble_sort.c

@@ -0,0 +1,14 @@
+/*-----------------------------------------------------------------------------
+ *				HTBLA-Leonding
+ *-----------------------------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Bubble sort implementation
+ * Author:			*/<your name>;/*
+ *-----------------------------------------------------------------------------
+ * Description:
+ * Implements the bubble sort strategy
+ *-----------------------------------------------------------------------------
+*/
+
+#include "bubble_sort.h"
+

bubble_sort.h

@@ -0,0 +1,39 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Bubble sort
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Implements the bubble sort strategy
+ * ----------------------------------------------------------
+ */
+#ifndef ___BUBBLE_SORT_H
+#define ___BUBBLE_SORT_H
+
+#include "list.h"
+#include "sorting_criteria.h"
+
+/* NOTE: Either list or array variant is required! */
+
+/**
+ * Sorts the given list according to the bubble sort strategy.
+ * 
+ * @param list The list to be sorted.
+ * @param criterion The pointer to the function that implements the sorting criterion.
+ * That function accepts two integer parameters and returns a boolean value.
+ */
+void bubble_sort_list(<params>);
+
+/**
+ * Sorts the given array according to the bubble sort strategy.
+ * 
+ * @param array The array to be sorted.
+ * @param length The length of the array.
+ * @param criterion The pointer to the function that implements the sorting criterion.
+ * That function accepts two integer parameters and returns a boolean value.
+ */
+void bubble_sort_array(<params>);
+
+#endif

config.h

@@ -0,0 +1,27 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: n/a
+ * Title:			Configuration Options
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Global application configuration options
+ * ----------------------------------------------------------
+ */
+#ifndef ___CONFIGURATION_H
+#define ___CONFIGURATION_H
+
+/** 
+ * Selects the implementation based on list.h. 
+ * To use an array instead, comment this define. 
+ */
+#define LIST_VARIANT 1
+
+/** The number of additional items when the list capacity need to be incremented. */
+#define CAPACITY_INCREMENT 256
+
+/** The largest value that is generated by the randomizer */
+#define MAX_VALUE 1024 * 1024
+
+#endif

doxygen_extra.css

@@ -0,0 +1,14 @@
+code {
+    background: #eaeaea;
+    padding: 0 0.3em;
+    border-radius: 4px;
+}
+div.fragment {
+    padding: 0.5em;
+    border-radius: 4px;
+    margin: 1em 0;
+}
+
+div.line {
+    line-height: 1.4;
+}

general.h

@@ -0,0 +1,20 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: n/a
+ * Title:			general.h
+ * Author:			P. Bauer, S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * General usable definitions and types.
+ * ----------------------------------------------------------
+ */
+#ifndef ___GENERAL_H
+#define ___GENERAL_H
+
+/** Convenience macro do get maximum of two numbers */
+#define MAX(x, y) ((x) > (y) ? (x) : (y))
+/** Convenience macro do get maximum of two numbers */
+#define MIN(x, y) ((x) < (y) ? (x) : (y))
+
+#endif

html/doxygen_extra.css

@@ -0,0 +1,14 @@
+code {
+    background: #eaeaea;
+    padding: 0 0.3em;
+    border-radius: 4px;
+}
+div.fragment {
+    padding: 0.5em;
+    border-radius: 4px;
+    margin: 1em 0;
+}
+
+div.line {
+    line-height: 1.4;
+}

html/dynsections.js

@@ -0,0 +1,121 @@
+/*
+ @licstart  The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ and associated documentation files (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or
+ substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ @licend  The above is the entire license notice for the JavaScript code in this file
+ */
+function toggleVisibility(linkObj)
+{
+ var base = $(linkObj).attr('id');
+ var summary = $('#'+base+'-summary');
+ var content = $('#'+base+'-content');
+ var trigger = $('#'+base+'-trigger');
+ var src=$(trigger).attr('src');
+ if (content.is(':visible')===true) {
+   content.hide();
+   summary.show();
+   $(linkObj).addClass('closed').removeClass('opened');
+   $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png');
+ } else {
+   content.show();
+   summary.hide();
+   $(linkObj).removeClass('closed').addClass('opened');
+   $(trigger).attr('src',src.substring(0,src.length-10)+'open.png');
+ }
+ return false;
+}
+
+function updateStripes()
+{
+  $('table.directory tr').
+       removeClass('even').filter(':visible:even').addClass('even');
+}
+
+function toggleLevel(level)
+{
+  $('table.directory tr').each(function() {
+    var l = this.id.split('_').length-1;
+    var i = $('#img'+this.id.substring(3));
+    var a = $('#arr'+this.id.substring(3));
+    if (l<level+1) {
+      i.removeClass('iconfopen iconfclosed').addClass('iconfopen');
+      a.html('&#9660;');
+      $(this).show();
+    } else if (l==level+1) {
+      i.removeClass('iconfclosed iconfopen').addClass('iconfclosed');
+      a.html('&#9658;');
+      $(this).show();
+    } else {
+      $(this).hide();
+    }
+  });
+  updateStripes();
+}
+
+function toggleFolder(id)
+{
+  // the clicked row
+  var currentRow = $('#row_'+id);
+
+  // all rows after the clicked row
+  var rows = currentRow.nextAll("tr");
+
+  var re = new RegExp('^row_'+id+'\\d+_$', "i"); //only one sub
+
+  // only match elements AFTER this one (can't hide elements before)
+  var childRows = rows.filter(function() { return this.id.match(re); });
+
+  // first row is visible we are HIDING
+  if (childRows.filter(':first').is(':visible')===true) {
+    // replace down arrow by right arrow for current row
+    var currentRowSpans = currentRow.find("span");
+    currentRowSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
+    currentRowSpans.filter(".arrow").html('&#9658;');
+    rows.filter("[id^=row_"+id+"]").hide(); // hide all children
+  } else { // we are SHOWING
+    // replace right arrow by down arrow for current row
+    var currentRowSpans = currentRow.find("span");
+    currentRowSpans.filter(".iconfclosed").removeClass("iconfclosed").addClass("iconfopen");
+    currentRowSpans.filter(".arrow").html('&#9660;');
+    // replace down arrows by right arrows for child rows
+    var childRowsSpans = childRows.find("span");
+    childRowsSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
+    childRowsSpans.filter(".arrow").html('&#9658;');
+    childRows.show(); //show all children
+  }
+  updateStripes();
+}
+
+
+function toggleInherit(id)
+{
+  var rows = $('tr.inherit.'+id);
+  var img = $('tr.inherit_header.'+id+' img');
+  var src = $(img).attr('src');
+  if (rows.filter(':first').is(':visible')===true) {
+    rows.css('display','none');
+    $(img).attr('src',src.substring(0,src.length-8)+'closed.png');
+  } else {
+    rows.css('display','table-row'); // using show() causes jump in firefox
+    $(img).attr('src',src.substring(0,src.length-10)+'open.png');
+  }
+}
+/* @license-end */

html/files.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.18"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>Sorting and Searching Algorithms: File List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen_extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">Sorting and Searching Algorithms
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.18 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">File List</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here is a list of all files with brief descriptions:</div><div class="directory">
+<table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><a href="mainpage_8h_source.html"><span class="icondoc"></span></a><a class="el" href="mainpage_8h.html" target="_self">mainpage.h</a></td><td class="desc"></td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Tue Mar 23 2021 00:58:15 for Sorting and Searching Algorithms by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.18
+</small></address>
+</body>
+</html>

html/index.html

@@ -0,0 +1,222 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.18"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>Sorting and Searching Algorithms: Main Page</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen_extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">Sorting and Searching Algorithms
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.18 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="PageDoc"><div class="header">
+  <div class="headertitle">
+<div class="title">Sorting and Searching Algorithms Documentation</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock"><h1><a class="anchor" id="intro"></a>
+Introduction</h1>
+<p>The implementation and evaluation of a collection of Sorting and Searching Algorithms.</p>
+<h1><a class="anchor" id="objective"></a>
+Assignment Objective</h1>
+<p>The target collection those algorithms are operation on, is an 'Array Backed List'. This list shares (almost) the same interface (<code>list.h</code>) as the linked list from previous assignments but is implemented based on an array. Different sorting and searching algorithms are to be implemented using that list. A stopwatch shall be implemented that is used to measure the time a certain algorithm requires to sort or search. Eventually the measured times for defined number of list items and algorithms are compared.</p>
+<p><b>Configuration</b></p>
+<p>The capacity of the backing array of the list is defined in <code>config.h</code> as <code>#define CAPACITY_INCREMENT</code>. This value defines also the number of items for enlarging the backing array. This means, the array grows always in steps of <code>CAPACITY_INCREMENT</code> items.</p>
+<h1><a class="anchor" id="assignment"></a>
+Assignment</h1>
+<p>In this assignment various sorting and search algorithms shall be implemented in multiple steps.</p>
+<p><b>Step 1:</b></p>
+<p>Implemenation of an 'Array Backed List' by implementing files <code>array_backed_list.h</code>. This file implements <code>list.h</code> using an array as underlying collection instead of a linked list. In contrast to earlier assignments, the function <code>list_append(…)</code> was removed and <code>list_swap(…)</code> was added. The array shall have a certain capacity and need to be increased (with all consequences, such as of copying items) if another item is added to a 'full' list. As a benefit, random access to items is fast, which is required by (most) sorting and searching algorithms. For implementation details read and follow the instructions in file <code>array_backed_list.c</code>.</p>
+<p><b>Step 2:</b></p>
+<ul>
+<li>Implementation of the infrastructure for selecting and using sorting and searching algorithms as well as for measuring the time a certain algorithm takes for completing its operation.</li>
+<li>Implemenation of bubble sort algorithm</li>
+<li>Implementation of insertion algorithm</li>
+<li>Implementation of sorting criteria that can be applied as paramter to the algorithm (function pointer)</li>
+</ul>
+<p><b>Step 3:</b></p>
+<p>Implemenation of the following sorting algorithms:</p><ul>
+<li>- TO BE DEFINED &ndash;</li>
+</ul>
+<h1><a class="anchor" id="instructions"></a>
+Working Instructions</h1>
+<p>The library 'allocator' is provided for memory allocation functionality that integrates with unit testing. Behind the facade, allocats memory dynamically similar to <code>malloc</code>. Allocated memory must be freed when it is not used anymore. The 'allocator' library must be used for memory alloction operations, otherwise unit tests will fail.</p>
+<p><b>Step 1:</b></p>
+<ol type="1">
+<li>Implement 'array_backed_list.c' against interface indirectly declared in 'list.h': Make the program and tests compile: Implement all functions in all relevant files declared in the headers EMTPY (return nothing, 0, false, ... as required).<ul>
+<li>All unit tests shall run but FAIL after this step</li>
+<li><b>&ndash;COMMIT&ndash;</b></li>
+</ul>
+</li>
+<li>Implement the empty functions one by one to make the unit tests.<ul>
+<li>Because most unit tests depends on <code>list_obtain(…)</code>, <code>list_release(…)</code>, <code>list_is_valid(…)</code>, <code>list_is_empty(…)</code>, <code>list_insert(…)</code>, and <code>list_get_size(…)</code> it makes sense to implement those functions in one step.</li>
+<li>The purpose of a function is specified as API documentation within the header files.</li>
+<li>Obey comments in source files. Run the unit tests frequently and fix failures.</li>
+<li><b>&ndash;COMMIT&ndash; after each implemented function.</b></li>
+</ul>
+</li>
+</ol>
+<p><b>Step 2:</b></p><ol type="1">
+<li>Based on 'array_backed_list' from step 1. If you don't own an implementation of that list (for good reasons), then:<ol type="a">
+<li>Implement the sorting algorithms based on a large, simple array (length: &gt;= 2^16, see below).</li>
+<li>Comment the <code>#define LIST_VARIANT</code> in <code>config.h</code> to enable the functions using arrays and disable those for the list.</li>
+<li><b>Note</b> Only one variant need to be implemented.</li>
+</ol>
+</li>
+<li>Implement all functions defined by the file below empty to make the program compile. <b>&ndash;COMMIT&ndash;</b></li>
+<li><code>stopwatch.[h|c]</code> Implement the <code>stopwatch</code>. The stopwatch is required to measure the runtime of algorithms or execution steps. Details about the implementation of the stopwatch can be found in <code>stopwatch.c</code>. Run the unit tests targeting stop watch functionality and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><code>sorting_criteria.[h|c]</code>: Implement the sorting criteria function and the define the function pointer type for those functions. Run the unit tests targeting the sorting criteria functions and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><code>bubble_sort.[h|c]</code>: Implement the bubble sort algorithm. Run the unit tests targeting the bubble sort algorithm and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><code>insertion_sort.[h|c]</code>: Implement the insertion sort algorithm. Run the unit tests targeting the insertion sort algorithm and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><code>sorting.[h|c]</code>: Implement the support functions for the sorting application. These functions include initialization, printing (optional), and selection of the desired sorting algorithm. It also declares an enumeration of all supported sorting algorithms. Details regarding the implementation of those functions are mentioned in the top section of <code>sorting.c</code>. Run the unit tests targeting the sorting support function and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><p class="startli"><code>timed_sorting_main_driver.c</code>: Implement the body of the measurement application. Organize the main application file as wanted. The application shall measure the time for sorting data of different size with all supported algorithms for the average, the best, and the worst case. In addition, it shall measure the time required for setting up and tearing down the data structure.</p>
+<p class="startli">For each supported sorting algorithm defined in <code>sorting.h</code>, starting with an item count of 1:</p><ol type="a">
+<li>Obtain the data structure (list or array) and initialize it randomly using the according function of <code>sorting.h</code>. Measure the time for this step as 'Init' time.</li>
+<li>Sort the data using the selected algorithm and measure the time for this step as 'Sort Avg' time.</li>
+<li>Sort the data using the selected algorithm again (in the same direction) and measure the time for this step as 'Sort Best' time.</li>
+<li>Sort the data using the selected algorithm in reverse direction and measure the time for this step as 'Sort Worst' time.</li>
+<li>Release the data structure (if applicable) and measure the time for this step as 'Release' time.</li>
+<li>Print the measured times as described below.</li>
+<li>Double the number of items to sort and repeat at step a) as long the item counter is less than 20k or 50k item (depending on your system).</li>
+</ol>
+<p class="startli"><b>&ndash;COMMIT&ndash;</b></p>
+<p class="startli">The print outs as described above shall produce a table as shown below. The format pattern for the item count should be <code>%7d</code> and <code>%10.1f</code> for time values. Pipes <code>|</code> herein are not part of the format, they are just reqired for markdown. Such a data table can be examined further in a spreadsheet application such as MS Excel. Describe your observations, verify the runtime complexity based on your time measurements.</p>
+<p class="startli"><b>Note:</b>: You can take time measurements using different value for <code>CAPACITY_INCREMENT</code>. Only <code>Init</code> time should differ significantly.</p>
+</li>
+</ol>
+<table class="markdownTable">
+<tr class="markdownTableHead">
+<th class="markdownTableHeadLeft">Algorithm; </th><th class="markdownTableHeadRight">Items; </th><th class="markdownTableHeadRight">Sort_Avg; </th><th class="markdownTableHeadRight">Sort_Best; </th><th class="markdownTableHeadRight">Sort Worst; </th><th class="markdownTableHeadRight">Init; </th><th class="markdownTableHeadRight">Release  </th></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">1; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">5.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">2; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">3.0; </td><td class="markdownTableBodyRight">0.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">4; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">3.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">8; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">3.0; </td><td class="markdownTableBodyRight">0.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">16; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">3.0; </td><td class="markdownTableBodyRight">3.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">32; </td><td class="markdownTableBodyRight">10.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">10.0; </td><td class="markdownTableBodyRight">17.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">64; </td><td class="markdownTableBodyRight">36.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">40.0; </td><td class="markdownTableBodyRight">4.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">128; </td><td class="markdownTableBodyRight">143.0; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">156.0; </td><td class="markdownTableBodyRight">5.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">256; </td><td class="markdownTableBodyRight">622.0; </td><td class="markdownTableBodyRight">3.0; </td><td class="markdownTableBodyRight">1676.0; </td><td class="markdownTableBodyRight">7.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">512; </td><td class="markdownTableBodyRight">2697.0; </td><td class="markdownTableBodyRight">7.0; </td><td class="markdownTableBodyRight">2855.0; </td><td class="markdownTableBodyRight">14.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">1024; </td><td class="markdownTableBodyRight">12267.0; </td><td class="markdownTableBodyRight">12.0; </td><td class="markdownTableBodyRight">11984.0; </td><td class="markdownTableBodyRight">23.0; </td><td class="markdownTableBodyRight">2.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">2048; </td><td class="markdownTableBodyRight">43619.0; </td><td class="markdownTableBodyRight">25.0; </td><td class="markdownTableBodyRight">44301.0; </td><td class="markdownTableBodyRight">42.0; </td><td class="markdownTableBodyRight">2.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">4096; </td><td class="markdownTableBodyRight">169480.0; </td><td class="markdownTableBodyRight">49.0; </td><td class="markdownTableBodyRight">181360.0; </td><td class="markdownTableBodyRight">78.0; </td><td class="markdownTableBodyRight">2.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">8192; </td><td class="markdownTableBodyRight">667259.0; </td><td class="markdownTableBodyRight">98.0; </td><td class="markdownTableBodyRight">714083.0; </td><td class="markdownTableBodyRight">157.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">16384; </td><td class="markdownTableBodyRight">2683571.0; </td><td class="markdownTableBodyRight">350.0; </td><td class="markdownTableBodyRight">2837608.0; </td><td class="markdownTableBodyRight">408.0; </td><td class="markdownTableBodyRight">33.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">32768; </td><td class="markdownTableBodyRight">10263822.0; </td><td class="markdownTableBodyRight">571.0; </td><td class="markdownTableBodyRight">11325744.0; </td><td class="markdownTableBodyRight">1879.0; </td><td class="markdownTableBodyRight">31.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">1; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">218.0; </td><td class="markdownTableBodyRight">0.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">2; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">4; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">8; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">0.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">16; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">0.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">32; </td><td class="markdownTableBodyRight">5.0; </td><td class="markdownTableBodyRight">1.0; </td><td class="markdownTableBodyRight">7.0; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">0.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">64; </td><td class="markdownTableBodyRight">15.0; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">29.0; </td><td class="markdownTableBodyRight">2.0; </td><td class="markdownTableBodyRight">0.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">128; </td><td class="markdownTableBodyRight">60.0; </td><td class="markdownTableBodyRight">3.0; </td><td class="markdownTableBodyRight">114.0; </td><td class="markdownTableBodyRight">4.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">256; </td><td class="markdownTableBodyRight">219.0; </td><td class="markdownTableBodyRight">5.0; </td><td class="markdownTableBodyRight">583.0; </td><td class="markdownTableBodyRight">6.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">512; </td><td class="markdownTableBodyRight">1010.0; </td><td class="markdownTableBodyRight">12.0; </td><td class="markdownTableBodyRight">2026.0; </td><td class="markdownTableBodyRight">11.0; </td><td class="markdownTableBodyRight">1.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">1024; </td><td class="markdownTableBodyRight">4066.0; </td><td class="markdownTableBodyRight">28.0; </td><td class="markdownTableBodyRight">8800.0; </td><td class="markdownTableBodyRight">32.0; </td><td class="markdownTableBodyRight">2.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">2048; </td><td class="markdownTableBodyRight">16718.0; </td><td class="markdownTableBodyRight">80.0; </td><td class="markdownTableBodyRight">33491.0; </td><td class="markdownTableBodyRight">35.0; </td><td class="markdownTableBodyRight">2.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">4096; </td><td class="markdownTableBodyRight">64592.0; </td><td class="markdownTableBodyRight">205.0; </td><td class="markdownTableBodyRight">129536.0; </td><td class="markdownTableBodyRight">69.0; </td><td class="markdownTableBodyRight">2.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">8192; </td><td class="markdownTableBodyRight">259646.0; </td><td class="markdownTableBodyRight">670.0; </td><td class="markdownTableBodyRight">524065.0; </td><td class="markdownTableBodyRight">142.0; </td><td class="markdownTableBodyRight">2.0  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">16384; </td><td class="markdownTableBodyRight">1094843.0; </td><td class="markdownTableBodyRight">2327.0; </td><td class="markdownTableBodyRight">2075412.0; </td><td class="markdownTableBodyRight">360.0; </td><td class="markdownTableBodyRight">24.0  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Insertion Sort; </td><td class="markdownTableBodyRight">32768; </td><td class="markdownTableBodyRight">4188706.0; </td><td class="markdownTableBodyRight">10525.0; </td><td class="markdownTableBodyRight">8367830.0; </td><td class="markdownTableBodyRight">1677.0; </td><td class="markdownTableBodyRight">34.0  </td></tr>
+</table>
+<h1><a class="anchor" id="notes"></a>
+Notes</h1>
+<ol type="1">
+<li>make cleantest: This new make target for clearing the console, building, and running unit test is available.</li>
+<li>Sometimes changes are not properly detected by incremental builds. If something very strange happens during compilation, try to run <code>make clean</code> followed by <code>make</code> to start a clean build. This approach is also recommended after everthing is done, because some compiler warning appears only in clean builds. </li>
+</ol>
+</div></div><!-- PageDoc -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Tue Mar 23 2021 00:58:15 for Sorting and Searching Algorithms by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.18
+</small></address>
+</body>
+</html>

html/mainpage_8h.html

@@ -0,0 +1,79 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.18"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>Sorting and Searching Algorithms: mainpage.h File Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen_extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">Sorting and Searching Algorithms
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.18 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+</div><!-- top -->
+<div class="header">
+  <div class="headertitle">
+<div class="title">mainpage.h File Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><a href="mainpage_8h_source.html">Go to the source code of this file.</a></p>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Tue Mar 23 2021 00:58:15 for Sorting and Searching Algorithms by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.18
+</small></address>
+</body>
+</html>

html/mainpage_8h_source.html

@@ -0,0 +1,78 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.18"/>
+<meta name="viewport" content="width=device-width, initial-scale=1"/>
+<title>Sorting and Searching Algorithms: mainpage.h Source File</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="search/search.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="search/searchdata.js"></script>
+<script type="text/javascript" src="search/search.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+<link href="doxygen_extra.css" rel="stylesheet" type="text/css"/>
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td id="projectalign" style="padding-left: 0.5em;">
+   <div id="projectname">Sorting and Searching Algorithms
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.18 -->
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+var searchBox = new SearchBox("searchBox", "search",false,'Search');
+/* @license-end */
+</script>
+<script type="text/javascript" src="menudata.js"></script>
+<script type="text/javascript" src="menu.js"></script>
+<script type="text/javascript">
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+$(function() {
+  initMenu('',true,false,'search.php','Search');
+  $(document).ready(function() { init_search(); });
+});
+/* @license-end */</script>
+<div id="main-nav"></div>
+</div><!-- top -->
+<!-- window showing the filter options -->
+<div id="MSearchSelectWindow"
+     onmouseover="return searchBox.OnSearchSelectShow()"
+     onmouseout="return searchBox.OnSearchSelectHide()"
+     onkeydown="return searchBox.OnSearchSelectKey(event)">
+</div>
+
+<!-- iframe showing the search results (closed by default) -->
+<div id="MSearchResultsWindow">
+<iframe src="javascript:void(0)" frameborder="0" 
+        name="MSearchResults" id="MSearchResults">
+</iframe>
+</div>
+
+<div class="header">
+  <div class="headertitle">
+<div class="title">mainpage.h</div>  </div>
+</div><!--header-->
+<div class="contents">
+<a href="mainpage_8h.html">Go to the documentation of this file.</a><div class="fragment"><div class="line"><a name="l00001"></a><span class="lineno">    1</span>&#160; </div>
+</div><!-- fragment --></div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Tue Mar 23 2021 00:58:15 for Sorting and Searching Algorithms by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.18
+</small></address>
+</body>
+</html>

html/menu.js

@@ -0,0 +1,51 @@
+/*
+ @licstart  The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ and associated documentation files (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or
+ substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ @licend  The above is the entire license notice for the JavaScript code in this file
+ */
+function initMenu(relPath,searchEnabled,serverSide,searchPage,search) {
+  function makeTree(data,relPath) {
+    var result='';
+    if ('children' in data) {
+      result+='<ul>';
+      for (var i in data.children) {
+        result+='<li><a href="'+relPath+data.children[i].url+'">'+
+                                data.children[i].text+'</a>'+
+                                makeTree(data.children[i],relPath)+'</li>';
+      }
+      result+='</ul>';
+    }
+    return result;
+  }
+
+  $('#main-nav').append(makeTree(menudata,relPath));
+  $('#main-nav').children(':first').addClass('sm sm-dox').attr('id','main-menu');
+  if (searchEnabled) {
+    if (serverSide) {
+      $('#main-menu').append('<li style="float:right"><div id="MSearchBox" class="MSearchBoxInactive"><div class="left"><form id="FSearchBox" action="'+relPath+searchPage+'" method="get"><img id="MSearchSelect" src="'+relPath+'search/mag.png" alt=""/><input type="text" id="MSearchField" name="query" value="'+search+'" size="20" accesskey="S" onfocus="searchBox.OnSearchFieldFocus(true)" onblur="searchBox.OnSearchFieldFocus(false)"></form></div><div class="right"></div></div></li>');
+    } else {
+      $('#main-menu').append('<li style="float:right"><div id="MSearchBox" class="MSearchBoxInactive"><span class="left"><img id="MSearchSelect" src="'+relPath+'search/mag_sel.png" onmouseover="return searchBox.OnSearchSelectShow()" onmouseout="return searchBox.OnSearchSelectHide()" alt=""/><input type="text" id="MSearchField" value="'+search+'" accesskey="S" onfocus="searchBox.OnSearchFieldFocus(true)" onblur="searchBox.OnSearchFieldFocus(false)" onkeyup="searchBox.OnSearchFieldChange(event)"/></span><span class="right"><a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="'+relPath+'search/close.png" alt=""/></a></span></div></li>');
+    }
+  }
+  $('#main-menu').smartmenus();
+}
+/* @license-end */

html/menudata.js

@@ -0,0 +1,28 @@
+/*
+ @licstart  The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ and associated documentation files (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or
+ substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ @licend  The above is the entire license notice for the JavaScript code in this file
+*/
+var menudata={children:[
+{text:"Main Page",url:"index.html"},
+{text:"Files",url:"files.html",children:[
+{text:"File List",url:"files.html"}]}]}

html/search/all_0.html

@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.18"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="all_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>

html/search/all_0.js

@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['mainpage_2eh_0',['mainpage.h',['../mainpage_8h.html',1,'']]]
+];

html/search/files_0.html

@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta name="generator" content="Doxygen 1.8.18"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="files_0.js"></script>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="Loading">Loading...</div>
+<div id="SRResults"></div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+createResults();
+/* @license-end */
+--></script>
+<div class="SRStatus" id="Searching">Searching...</div>
+<div class="SRStatus" id="NoMatches">No Matches</div>
+<script type="text/javascript"><!--
+/* @license magnet:?xt=urn:btih:cf05388f2679ee054f2beb29a391d25f4e673ac3&amp;dn=gpl-2.0.txt GPL-v2 */
+document.getElementById("Loading").style.display="none";
+document.getElementById("NoMatches").style.display="none";
+var searchResults = new SearchResults("searchResults");
+searchResults.Search();
+window.addEventListener("message", function(event) {
+  if (event.data == "take_focus") {
+    var elem = searchResults.NavNext(0);
+    if (elem) elem.focus();
+  }
+});
+/* @license-end */
+--></script>
+</div>
+</body>
+</html>

html/search/files_0.js

@@ -0,0 +1,4 @@
+var searchData=
+[
+  ['mainpage_2eh_1',['mainpage.h',['../mainpage_8h.html',1,'']]]
+];

html/search/nomatches.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html><head><title></title>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<link rel="stylesheet" type="text/css" href="search.css"/>
+<script type="text/javascript" src="search.js"></script>
+</head>
+<body class="SRPage">
+<div id="SRIndex">
+<div class="SRStatus" id="NoMatches">No Matches</div>
+</div>
+</body>
+</html>

html/search/search.css

@@ -0,0 +1,271 @@
+/*---------------- Search Box */
+
+#FSearchBox {
+    float: left;
+}
+
+#MSearchBox {
+    white-space : nowrap;
+    float: none;
+    margin-top: 8px;
+    right: 0px;
+    width: 170px;
+    height: 24px;
+    z-index: 102;
+}
+
+#MSearchBox .left
+{
+    display:block;
+    position:absolute;
+    left:10px;
+    width:20px;
+    height:19px;
+    background:url('search_l.png') no-repeat;
+    background-position:right;
+}
+
+#MSearchSelect {
+    display:block;
+    position:absolute;
+    width:20px;
+    height:19px;
+}
+
+.left #MSearchSelect {
+    left:4px;
+}
+
+.right #MSearchSelect {
+    right:5px;
+}
+
+#MSearchField {
+    display:block;
+    position:absolute;
+    height:19px;
+    background:url('search_m.png') repeat-x;
+    border:none;
+    width:115px;
+    margin-left:20px;
+    padding-left:4px;
+    color: #909090;
+    outline: none;
+    font: 9pt Arial, Verdana, sans-serif;
+    -webkit-border-radius: 0px;
+}
+
+#FSearchBox #MSearchField {
+    margin-left:15px;
+}
+
+#MSearchBox .right {
+    display:block;
+    position:absolute;
+    right:10px;
+    top:8px;
+    width:20px;
+    height:19px;
+    background:url('search_r.png') no-repeat;
+    background-position:left;
+}
+
+#MSearchClose {
+    display: none;
+    position: absolute;
+    top: 4px;
+    background : none;
+    border: none;
+    margin: 0px 4px 0px 0px;
+    padding: 0px 0px;
+    outline: none;
+}
+
+.left #MSearchClose {
+    left: 6px;
+}
+
+.right #MSearchClose {
+    right: 2px;
+}
+
+.MSearchBoxActive #MSearchField {
+    color: #000000;
+}
+
+/*---------------- Search filter selection */
+
+#MSearchSelectWindow {
+    display: none;
+    position: absolute;
+    left: 0; top: 0;
+    border: 1px solid #90A5CE;
+    background-color: #F9FAFC;
+    z-index: 10001;
+    padding-top: 4px;
+    padding-bottom: 4px;
+    -moz-border-radius: 4px;
+    -webkit-border-top-left-radius: 4px;
+    -webkit-border-top-right-radius: 4px;
+    -webkit-border-bottom-left-radius: 4px;
+    -webkit-border-bottom-right-radius: 4px;
+    -webkit-box-shadow: 5px 5px 5px rgba(0, 0, 0, 0.15);
+}
+
+.SelectItem {
+    font: 8pt Arial, Verdana, sans-serif;
+    padding-left:  2px;
+    padding-right: 12px;
+    border: 0px;
+}
+
+span.SelectionMark {
+    margin-right: 4px;
+    font-family: monospace;
+    outline-style: none;
+    text-decoration: none;
+}
+
+a.SelectItem {
+    display: block;
+    outline-style: none;
+    color: #000000; 
+    text-decoration: none;
+    padding-left:   6px;
+    padding-right: 12px;
+}
+
+a.SelectItem:focus,
+a.SelectItem:active {
+    color: #000000; 
+    outline-style: none;
+    text-decoration: none;
+}
+
+a.SelectItem:hover {
+    color: #FFFFFF;
+    background-color: #3D578C;
+    outline-style: none;
+    text-decoration: none;
+    cursor: pointer;
+    display: block;
+}
+
+/*---------------- Search results window */
+
+iframe#MSearchResults {
+    width: 60ex;
+    height: 15em;
+}
+
+#MSearchResultsWindow {
+    display: none;
+    position: absolute;
+    left: 0; top: 0;
+    border: 1px solid #000;
+    background-color: #EEF1F7;
+    z-index:10000;
+}
+
+/* ----------------------------------- */
+
+
+#SRIndex {
+    clear:both; 
+    padding-bottom: 15px;
+}
+
+.SREntry {
+    font-size: 10pt;
+    padding-left: 1ex;
+}
+
+.SRPage .SREntry {
+    font-size: 8pt;
+    padding: 1px 5px;
+}
+
+body.SRPage {
+    margin: 5px 2px;
+}
+
+.SRChildren {
+    padding-left: 3ex; padding-bottom: .5em 
+}
+
+.SRPage .SRChildren {
+    display: none;
+}
+
+.SRSymbol {
+    font-weight: bold; 
+    color: #425E97;
+    font-family: Arial, Verdana, sans-serif;
+    text-decoration: none;
+    outline: none;
+}
+
+a.SRScope {
+    display: block;
+    color: #425E97; 
+    font-family: Arial, Verdana, sans-serif;
+    text-decoration: none;
+    outline: none;
+}
+
+a.SRSymbol:focus, a.SRSymbol:active,
+a.SRScope:focus, a.SRScope:active {
+    text-decoration: underline;
+}
+
+span.SRScope {
+    padding-left: 4px;
+}
+
+.SRPage .SRStatus {
+    padding: 2px 5px;
+    font-size: 8pt;
+    font-style: italic;
+}
+
+.SRResult {
+    display: none;
+}
+
+DIV.searchresults {
+    margin-left: 10px;
+    margin-right: 10px;
+}
+
+/*---------------- External search page results */
+
+.searchresult {
+    background-color: #F0F3F8;
+}
+
+.pages b {
+   color: white;
+   padding: 5px 5px 3px 5px;
+   background-image: url("../tab_a.png");
+   background-repeat: repeat-x;
+   text-shadow: 0 1px 1px #000000;
+}
+
+.pages {
+    line-height: 17px;
+    margin-left: 4px;
+    text-decoration: none;
+}
+
+.hl {
+    font-weight: bold;
+}
+
+#searchresults {
+    margin-bottom: 20px;
+}
+
+.searchpages {
+    margin-top: 10px;
+}
+

html/search/search.js

@@ -0,0 +1,814 @@
+/*
+ @licstart  The following is the entire license notice for the JavaScript code in this file.
+
+ The MIT License (MIT)
+
+ Copyright (C) 1997-2020 by Dimitri van Heesch
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ and associated documentation files (the "Software"), to deal in the Software without restriction,
+ including without limitation the rights to use, copy, modify, merge, publish, distribute,
+ sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all copies or
+ substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ @licend  The above is the entire license notice for the JavaScript code in this file
+ */
+function convertToId(search)
+{
+  var result = '';
+  for (i=0;i<search.length;i++)
+  {
+    var c = search.charAt(i);
+    var cn = c.charCodeAt(0);
+    if (c.match(/[a-z0-9\u0080-\uFFFF]/))
+    {
+      result+=c;
+    }
+    else if (cn<16)
+    {
+      result+="_0"+cn.toString(16);
+    }
+    else
+    {
+      result+="_"+cn.toString(16);
+    }
+  }
+  return result;
+}
+
+function getXPos(item)
+{
+  var x = 0;
+  if (item.offsetWidth)
+  {
+    while (item && item!=document.body)
+    {
+      x   += item.offsetLeft;
+      item = item.offsetParent;
+    }
+  }
+  return x;
+}
+
+function getYPos(item)
+{
+  var y = 0;
+  if (item.offsetWidth)
+  {
+     while (item && item!=document.body)
+     {
+       y   += item.offsetTop;
+       item = item.offsetParent;
+     }
+  }
+  return y;
+}
+
+/* A class handling everything associated with the search panel.
+
+   Parameters:
+   name - The name of the global variable that will be
+          storing this instance.  Is needed to be able to set timeouts.
+   resultPath - path to use for external files
+*/
+function SearchBox(name, resultsPath, inFrame, label)
+{
+  if (!name || !resultsPath) {  alert("Missing parameters to SearchBox."); }
+
+  // ---------- Instance variables
+  this.name                  = name;
+  this.resultsPath           = resultsPath;
+  this.keyTimeout            = 0;
+  this.keyTimeoutLength      = 500;
+  this.closeSelectionTimeout = 300;
+  this.lastSearchValue       = "";
+  this.lastResultsPage       = "";
+  this.hideTimeout           = 0;
+  this.searchIndex           = 0;
+  this.searchActive          = false;
+  this.insideFrame           = inFrame;
+  this.searchLabel           = label;
+
+  // ----------- DOM Elements
+
+  this.DOMSearchField = function()
+  {  return document.getElementById("MSearchField");  }
+
+  this.DOMSearchSelect = function()
+  {  return document.getElementById("MSearchSelect");  }
+
+  this.DOMSearchSelectWindow = function()
+  {  return document.getElementById("MSearchSelectWindow");  }
+
+  this.DOMPopupSearchResults = function()
+  {  return document.getElementById("MSearchResults");  }
+
+  this.DOMPopupSearchResultsWindow = function()
+  {  return document.getElementById("MSearchResultsWindow");  }
+
+  this.DOMSearchClose = function()
+  {  return document.getElementById("MSearchClose"); }
+
+  this.DOMSearchBox = function()
+  {  return document.getElementById("MSearchBox");  }
+
+  // ------------ Event Handlers
+
+  // Called when focus is added or removed from the search field.
+  this.OnSearchFieldFocus = function(isActive)
+  {
+    this.Activate(isActive);
+  }
+
+  this.OnSearchSelectShow = function()
+  {
+    var searchSelectWindow = this.DOMSearchSelectWindow();
+    var searchField        = this.DOMSearchSelect();
+
+    if (this.insideFrame)
+    {
+      var left = getXPos(searchField);
+      var top  = getYPos(searchField);
+      left += searchField.offsetWidth + 6;
+      top += searchField.offsetHeight;
+
+      // show search selection popup
+      searchSelectWindow.style.display='block';
+      left -= searchSelectWindow.offsetWidth;
+      searchSelectWindow.style.left =  left + 'px';
+      searchSelectWindow.style.top  =  top  + 'px';
+    }
+    else
+    {
+      var left = getXPos(searchField);
+      var top  = getYPos(searchField);
+      top += searchField.offsetHeight;
+
+      // show search selection popup
+      searchSelectWindow.style.display='block';
+      searchSelectWindow.style.left =  left + 'px';
+      searchSelectWindow.style.top  =  top  + 'px';
+    }
+
+    // stop selection hide timer
+    if (this.hideTimeout)
+    {
+      clearTimeout(this.hideTimeout);
+      this.hideTimeout=0;
+    }
+    return false; // to avoid "image drag" default event
+  }
+
+  this.OnSearchSelectHide = function()
+  {
+    this.hideTimeout = setTimeout(this.name +".CloseSelectionWindow()",
+                                  this.closeSelectionTimeout);
+  }
+
+  // Called when the content of the search field is changed.
+  this.OnSearchFieldChange = function(evt)
+  {
+    if (this.keyTimeout) // kill running timer
+    {
+      clearTimeout(this.keyTimeout);
+      this.keyTimeout = 0;
+    }
+
+    var e  = (evt) ? evt : window.event; // for IE
+    if (e.keyCode==40 || e.keyCode==13)
+    {
+      if (e.shiftKey==1)
+      {
+        this.OnSearchSelectShow();
+        var win=this.DOMSearchSelectWindow();
+        for (i=0;i<win.childNodes.length;i++)
+        {
+          var child = win.childNodes[i]; // get span within a
+          if (child.className=='SelectItem')
+          {
+            child.focus();
+            return;
+          }
+        }
+        return;
+      }
+      else
+      {
+        window.frames.MSearchResults.postMessage("take_focus", "*");
+      }
+    }
+    else if (e.keyCode==27) // Escape out of the search field
+    {
+      this.DOMSearchField().blur();
+      this.DOMPopupSearchResultsWindow().style.display = 'none';
+      this.DOMSearchClose().style.display = 'none';
+      this.lastSearchValue = '';
+      this.Activate(false);
+      return;
+    }
+
+    // strip whitespaces
+    var searchValue = this.DOMSearchField().value.replace(/ +/g, "");
+
+    if (searchValue != this.lastSearchValue) // search value has changed
+    {
+      if (searchValue != "") // non-empty search
+      {
+        // set timer for search update
+        this.keyTimeout = setTimeout(this.name + '.Search()',
+                                     this.keyTimeoutLength);
+      }
+      else // empty search field
+      {
+        this.DOMPopupSearchResultsWindow().style.display = 'none';
+        this.DOMSearchClose().style.display = 'none';
+        this.lastSearchValue = '';
+      }
+    }
+  }
+
+  this.SelectItemCount = function(id)
+  {
+    var count=0;
+    var win=this.DOMSearchSelectWindow();
+    for (i=0;i<win.childNodes.length;i++)
+    {
+      var child = win.childNodes[i]; // get span within a
+      if (child.className=='SelectItem')
+      {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  this.SelectItemSet = function(id)
+  {
+    var i,j=0;
+    var win=this.DOMSearchSelectWindow();
+    for (i=0;i<win.childNodes.length;i++)
+    {
+      var child = win.childNodes[i]; // get span within a
+      if (child.className=='SelectItem')
+      {
+        var node = child.firstChild;
+        if (j==id)
+        {
+          node.innerHTML='&#8226;';
+        }
+        else
+        {
+          node.innerHTML='&#160;';
+        }
+        j++;
+      }
+    }
+  }
+
+  // Called when an search filter selection is made.
+  // set item with index id as the active item
+  this.OnSelectItem = function(id)
+  {
+    this.searchIndex = id;
+    this.SelectItemSet(id);
+    var searchValue = this.DOMSearchField().value.replace(/ +/g, "");
+    if (searchValue!="" && this.searchActive) // something was found -> do a search
+    {
+      this.Search();
+    }
+  }
+
+  this.OnSearchSelectKey = function(evt)
+  {
+    var e = (evt) ? evt : window.event; // for IE
+    if (e.keyCode==40 && this.searchIndex<this.SelectItemCount()) // Down
+    {
+      this.searchIndex++;
+      this.OnSelectItem(this.searchIndex);
+    }
+    else if (e.keyCode==38 && this.searchIndex>0) // Up
+    {
+      this.searchIndex--;
+      this.OnSelectItem(this.searchIndex);
+    }
+    else if (e.keyCode==13 || e.keyCode==27)
+    {
+      this.OnSelectItem(this.searchIndex);
+      this.CloseSelectionWindow();
+      this.DOMSearchField().focus();
+    }
+    return false;
+  }
+
+  // --------- Actions
+
+  // Closes the results window.
+  this.CloseResultsWindow = function()
+  {
+    this.DOMPopupSearchResultsWindow().style.display = 'none';
+    this.DOMSearchClose().style.display = 'none';
+    this.Activate(false);
+  }
+
+  this.CloseSelectionWindow = function()
+  {
+    this.DOMSearchSelectWindow().style.display = 'none';
+  }
+
+  // Performs a search.
+  this.Search = function()
+  {
+    this.keyTimeout = 0;
+
+    // strip leading whitespace
+    var searchValue = this.DOMSearchField().value.replace(/^ +/, "");
+
+    var code = searchValue.toLowerCase().charCodeAt(0);
+    var idxChar = searchValue.substr(0, 1).toLowerCase();
+    if ( 0xD800 <= code && code <= 0xDBFF && searchValue > 1) // surrogate pair
+    {
+      idxChar = searchValue.substr(0, 2);
+    }
+
+    var resultsPage;
+    var resultsPageWithSearch;
+    var hasResultsPage;
+
+    var idx = indexSectionsWithContent[this.searchIndex].indexOf(idxChar);
+    if (idx!=-1)
+    {
+       var hexCode=idx.toString(16);
+       resultsPage = this.resultsPath + '/' + indexSectionNames[this.searchIndex] + '_' + hexCode + '.html';
+       resultsPageWithSearch = resultsPage+'?'+escape(searchValue);
+       hasResultsPage = true;
+    }
+    else // nothing available for this search term
+    {
+       resultsPage = this.resultsPath + '/nomatches.html';
+       resultsPageWithSearch = resultsPage;
+       hasResultsPage = false;
+    }
+
+    window.frames.MSearchResults.location = resultsPageWithSearch;
+    var domPopupSearchResultsWindow = this.DOMPopupSearchResultsWindow();
+
+    if (domPopupSearchResultsWindow.style.display!='block')
+    {
+       var domSearchBox = this.DOMSearchBox();
+       this.DOMSearchClose().style.display = 'inline';
+       if (this.insideFrame)
+       {
+         var domPopupSearchResults = this.DOMPopupSearchResults();
+         domPopupSearchResultsWindow.style.position = 'relative';
+         domPopupSearchResultsWindow.style.display  = 'block';
+         var width = document.body.clientWidth - 8; // the -8 is for IE :-(
+         domPopupSearchResultsWindow.style.width    = width + 'px';
+         domPopupSearchResults.style.width          = width + 'px';
+       }
+       else
+       {
+         var domPopupSearchResults = this.DOMPopupSearchResults();
+         var left = getXPos(domSearchBox) + 150; // domSearchBox.offsetWidth;
+         var top  = getYPos(domSearchBox) + 20;  // domSearchBox.offsetHeight + 1;
+         domPopupSearchResultsWindow.style.display = 'block';
+         left -= domPopupSearchResults.offsetWidth;
+         domPopupSearchResultsWindow.style.top     = top  + 'px';
+         domPopupSearchResultsWindow.style.left    = left + 'px';
+       }
+    }
+
+    this.lastSearchValue = searchValue;
+    this.lastResultsPage = resultsPage;
+  }
+
+  // -------- Activation Functions
+
+  // Activates or deactivates the search panel, resetting things to
+  // their default values if necessary.
+  this.Activate = function(isActive)
+  {
+    if (isActive || // open it
+        this.DOMPopupSearchResultsWindow().style.display == 'block'
+       )
+    {
+      this.DOMSearchBox().className = 'MSearchBoxActive';
+
+      var searchField = this.DOMSearchField();
+
+      if (searchField.value == this.searchLabel) // clear "Search" term upon entry
+      {
+        searchField.value = '';
+        this.searchActive = true;
+      }
+    }
+    else if (!isActive) // directly remove the panel
+    {
+      this.DOMSearchBox().className = 'MSearchBoxInactive';
+      this.DOMSearchField().value   = this.searchLabel;
+      this.searchActive             = false;
+      this.lastSearchValue          = ''
+      this.lastResultsPage          = '';
+    }
+  }
+}
+
+// -----------------------------------------------------------------------
+
+// The class that handles everything on the search results page.
+function SearchResults(name)
+{
+    // The number of matches from the last run of <Search()>.
+    this.lastMatchCount = 0;
+    this.lastKey = 0;
+    this.repeatOn = false;
+
+    // Toggles the visibility of the passed element ID.
+    this.FindChildElement = function(id)
+    {
+      var parentElement = document.getElementById(id);
+      var element = parentElement.firstChild;
+
+      while (element && element!=parentElement)
+      {
+        if (element.nodeName == 'DIV' && element.className == 'SRChildren')
+        {
+          return element;
+        }
+
+        if (element.nodeName == 'DIV' && element.hasChildNodes())
+        {
+           element = element.firstChild;
+        }
+        else if (element.nextSibling)
+        {
+           element = element.nextSibling;
+        }
+        else
+        {
+          do
+          {
+            element = element.parentNode;
+          }
+          while (element && element!=parentElement && !element.nextSibling);
+
+          if (element && element!=parentElement)
+          {
+            element = element.nextSibling;
+          }
+        }
+      }
+    }
+
+    this.Toggle = function(id)
+    {
+      var element = this.FindChildElement(id);
+      if (element)
+      {
+        if (element.style.display == 'block')
+        {
+          element.style.display = 'none';
+        }
+        else
+        {
+          element.style.display = 'block';
+        }
+      }
+    }
+
+    // Searches for the passed string.  If there is no parameter,
+    // it takes it from the URL query.
+    //
+    // Always returns true, since other documents may try to call it
+    // and that may or may not be possible.
+    this.Search = function(search)
+    {
+      if (!search) // get search word from URL
+      {
+        search = window.location.search;
+        search = search.substring(1);  // Remove the leading '?'
+        search = unescape(search);
+      }
+
+      search = search.replace(/^ +/, ""); // strip leading spaces
+      search = search.replace(/ +$/, ""); // strip trailing spaces
+      search = search.toLowerCase();
+      search = convertToId(search);
+
+      var resultRows = document.getElementsByTagName("div");
+      var matches = 0;
+
+      var i = 0;
+      while (i < resultRows.length)
+      {
+        var row = resultRows.item(i);
+        if (row.className == "SRResult")
+        {
+          var rowMatchName = row.id.toLowerCase();
+          rowMatchName = rowMatchName.replace(/^sr\d*_/, ''); // strip 'sr123_'
+
+          if (search.length<=rowMatchName.length &&
+             rowMatchName.substr(0, search.length)==search)
+          {
+            row.style.display = 'block';
+            matches++;
+          }
+          else
+          {
+            row.style.display = 'none';
+          }
+        }
+        i++;
+      }
+      document.getElementById("Searching").style.display='none';
+      if (matches == 0) // no results
+      {
+        document.getElementById("NoMatches").style.display='block';
+      }
+      else // at least one result
+      {
+        document.getElementById("NoMatches").style.display='none';
+      }
+      this.lastMatchCount = matches;
+      return true;
+    }
+
+    // return the first item with index index or higher that is visible
+    this.NavNext = function(index)
+    {
+      var focusItem;
+      while (1)
+      {
+        var focusName = 'Item'+index;
+        focusItem = document.getElementById(focusName);
+        if (focusItem && focusItem.parentNode.parentNode.style.display=='block')
+        {
+          break;
+        }
+        else if (!focusItem) // last element
+        {
+          break;
+        }
+        focusItem=null;
+        index++;
+      }
+      return focusItem;
+    }
+
+    this.NavPrev = function(index)
+    {
+      var focusItem;
+      while (1)
+      {
+        var focusName = 'Item'+index;
+        focusItem = document.getElementById(focusName);
+        if (focusItem && focusItem.parentNode.parentNode.style.display=='block')
+        {
+          break;
+        }
+        else if (!focusItem) // last element
+        {
+          break;
+        }
+        focusItem=null;
+        index--;
+      }
+      return focusItem;
+    }
+
+    this.ProcessKeys = function(e)
+    {
+      if (e.type == "keydown")
+      {
+        this.repeatOn = false;
+        this.lastKey = e.keyCode;
+      }
+      else if (e.type == "keypress")
+      {
+        if (!this.repeatOn)
+        {
+          if (this.lastKey) this.repeatOn = true;
+          return false; // ignore first keypress after keydown
+        }
+      }
+      else if (e.type == "keyup")
+      {
+        this.lastKey = 0;
+        this.repeatOn = false;
+      }
+      return this.lastKey!=0;
+    }
+
+    this.Nav = function(evt,itemIndex)
+    {
+      var e  = (evt) ? evt : window.event; // for IE
+      if (e.keyCode==13) return true;
+      if (!this.ProcessKeys(e)) return false;
+
+      if (this.lastKey==38) // Up
+      {
+        var newIndex = itemIndex-1;
+        var focusItem = this.NavPrev(newIndex);
+        if (focusItem)
+        {
+          var child = this.FindChildElement(focusItem.parentNode.parentNode.id);
+          if (child && child.style.display == 'block') // children visible
+          {
+            var n=0;
+            var tmpElem;
+            while (1) // search for last child
+            {
+              tmpElem = document.getElementById('Item'+newIndex+'_c'+n);
+              if (tmpElem)
+              {
+                focusItem = tmpElem;
+              }
+              else // found it!
+              {
+                break;
+              }
+              n++;
+            }
+          }
+        }
+        if (focusItem)
+        {
+          focusItem.focus();
+        }
+        else // return focus to search field
+        {
+           parent.document.getElementById("MSearchField").focus();
+        }
+      }
+      else if (this.lastKey==40) // Down
+      {
+        var newIndex = itemIndex+1;
+        var focusItem;
+        var item = document.getElementById('Item'+itemIndex);
+        var elem = this.FindChildElement(item.parentNode.parentNode.id);
+        if (elem && elem.style.display == 'block') // children visible
+        {
+          focusItem = document.getElementById('Item'+itemIndex+'_c0');
+        }
+        if (!focusItem) focusItem = this.NavNext(newIndex);
+        if (focusItem)  focusItem.focus();
+      }
+      else if (this.lastKey==39) // Right
+      {
+        var item = document.getElementById('Item'+itemIndex);
+        var elem = this.FindChildElement(item.parentNode.parentNode.id);
+        if (elem) elem.style.display = 'block';
+      }
+      else if (this.lastKey==37) // Left
+      {
+        var item = document.getElementById('Item'+itemIndex);
+        var elem = this.FindChildElement(item.parentNode.parentNode.id);
+        if (elem) elem.style.display = 'none';
+      }
+      else if (this.lastKey==27) // Escape
+      {
+        parent.searchBox.CloseResultsWindow();
+        parent.document.getElementById("MSearchField").focus();
+      }
+      else if (this.lastKey==13) // Enter
+      {
+        return true;
+      }
+      return false;
+    }
+
+    this.NavChild = function(evt,itemIndex,childIndex)
+    {
+      var e  = (evt) ? evt : window.event; // for IE
+      if (e.keyCode==13) return true;
+      if (!this.ProcessKeys(e)) return false;
+
+      if (this.lastKey==38) // Up
+      {
+        if (childIndex>0)
+        {
+          var newIndex = childIndex-1;
+          document.getElementById('Item'+itemIndex+'_c'+newIndex).focus();
+        }
+        else // already at first child, jump to parent
+        {
+          document.getElementById('Item'+itemIndex).focus();
+        }
+      }
+      else if (this.lastKey==40) // Down
+      {
+        var newIndex = childIndex+1;
+        var elem = document.getElementById('Item'+itemIndex+'_c'+newIndex);
+        if (!elem) // last child, jump to parent next parent
+        {
+          elem = this.NavNext(itemIndex+1);
+        }
+        if (elem)
+        {
+          elem.focus();
+        }
+      }
+      else if (this.lastKey==27) // Escape
+      {
+        parent.searchBox.CloseResultsWindow();
+        parent.document.getElementById("MSearchField").focus();
+      }
+      else if (this.lastKey==13) // Enter
+      {
+        return true;
+      }
+      return false;
+    }
+}
+
+function setKeyActions(elem,action)
+{
+  elem.setAttribute('onkeydown',action);
+  elem.setAttribute('onkeypress',action);
+  elem.setAttribute('onkeyup',action);
+}
+
+function setClassAttr(elem,attr)
+{
+  elem.setAttribute('class',attr);
+  elem.setAttribute('className',attr);
+}
+
+function createResults()
+{
+  var results = document.getElementById("SRResults");
+  for (var e=0; e<searchData.length; e++)
+  {
+    var id = searchData[e][0];
+    var srResult = document.createElement('div');
+    srResult.setAttribute('id','SR_'+id);
+    setClassAttr(srResult,'SRResult');
+    var srEntry = document.createElement('div');
+    setClassAttr(srEntry,'SREntry');
+    var srLink = document.createElement('a');
+    srLink.setAttribute('id','Item'+e);
+    setKeyActions(srLink,'return searchResults.Nav(event,'+e+')');
+    setClassAttr(srLink,'SRSymbol');
+    srLink.innerHTML = searchData[e][1][0];
+    srEntry.appendChild(srLink);
+    if (searchData[e][1].length==2) // single result
+    {
+      srLink.setAttribute('href',searchData[e][1][1][0]);
+      if (searchData[e][1][1][1])
+      {
+       srLink.setAttribute('target','_parent');
+      }
+      var srScope = document.createElement('span');
+      setClassAttr(srScope,'SRScope');
+      srScope.innerHTML = searchData[e][1][1][2];
+      srEntry.appendChild(srScope);
+    }
+    else // multiple results
+    {
+      srLink.setAttribute('href','javascript:searchResults.Toggle("SR_'+id+'")');
+      var srChildren = document.createElement('div');
+      setClassAttr(srChildren,'SRChildren');
+      for (var c=0; c<searchData[e][1].length-1; c++)
+      {
+        var srChild = document.createElement('a');
+        srChild.setAttribute('id','Item'+e+'_c'+c);
+        setKeyActions(srChild,'return searchResults.NavChild(event,'+e+','+c+')');
+        setClassAttr(srChild,'SRScope');
+        srChild.setAttribute('href',searchData[e][1][c+1][0]);
+        if (searchData[e][1][c+1][1])
+        {
+         srChild.setAttribute('target','_parent');
+        }
+        srChild.innerHTML = searchData[e][1][c+1][2];
+        srChildren.appendChild(srChild);
+      }
+      srEntry.appendChild(srChildren);
+    }
+    srResult.appendChild(srEntry);
+    results.appendChild(srResult);
+  }
+}
+
+function init_search()
+{
+  var results = document.getElementById("MSearchSelectWindow");
+  for (var key in indexSectionLabels)
+  {
+    var link = document.createElement('a');
+    link.setAttribute('class','SelectItem');
+    link.setAttribute('onclick','searchBox.OnSelectItem('+key+')');
+    link.href='javascript:void(0)';
+    link.innerHTML='<span class="SelectionMark">&#160;</span>'+indexSectionLabels[key];
+    results.appendChild(link);
+  }
+  searchBox.OnSelectItem(0);
+}
+/* @license-end */

html/search/searchdata.js

@@ -0,0 +1,18 @@
+var indexSectionsWithContent =
+{
+  0: "m",
+  1: "m"
+};
+
+var indexSectionNames =
+{
+  0: "all",
+  1: "files"
+};
+
+var indexSectionLabels =
+{
+  0: "All",
+  1: "Files"
+};
+

insertion_sort.c

@@ -0,0 +1,13 @@
+/*-----------------------------------------------------------------------------
+ *				HTBLA-Leonding
+ *-----------------------------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Insertion sort implementation
+ * Author:			*/<your name>;/*
+ *-----------------------------------------------------------------------------
+ * Description:
+ * Implements the insertion sort strategy
+ *-----------------------------------------------------------------------------
+*/
+
+#include "insertion_sort.h"

insertion_sort.h

@@ -0,0 +1,39 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Insertion sort
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Implements the insertion sort strategy
+ * ----------------------------------------------------------
+ */
+#ifndef ___INSERTION_SORT_H
+#define ___INSERTION_SORT_H
+
+#include "list.h"
+#include "sorting_criteria.h"
+
+/* NOTE: Either list or array variant is required! */
+
+/**
+ * Sorts the given list according to the insertion sort strategy.
+ * 
+ * @param list The list to be sorted.
+ * @param criterion The pointer to the function that implements the sorting criterion.
+ * That function accepts two integer parameters and returns a boolean value.
+ */
+void insertion_sort_list(<params>);
+
+/**
+ * Sorts the given array according to the insertion sort strategy.
+ * 
+ * @param array The array to be sorted.
+ * @param length The length of the array.
+ * @param criterion The pointer to the function that implements the sorting criterion.
+ * That function accepts two integer parameters and returns a boolean value.
+ */
+void insertion_sort_array(<params>);
+
+#endif

list.h

@@ -0,0 +1,171 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Class: <your class>
+ * ---------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			List Interface
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * The declaration of a list abstract data type.
+ * ----------------------------------------------------------
+ */
+
+#ifndef ___LIST__H
+#define ___LIST__H
+
+#include <stdbool.h>
+
+#include "list_types.h"
+
+/**
+ * Obtains ('creates') and provides a 'new' list instance.
+ * Any list obtained via this function MUST be released using
+ * function `release_list()`.
+ * 
+ * Note: This function does not make any assumptions 
+ * about how list components, esp. nodes, are allocated.
+ * 
+ * @return The list instance or 0, if no list could by instantiated.
+ */
+IntList list_obtain();
+
+/**
+ * Releases a list that was obtained earlier via function `obtain_list`.
+ * Released lists MUST NOT be used anymore.
+ * 
+ * Note: The implementation of this function does not make any assumptions
+ * about the allocation method of list elements, but MUST match the implementation
+ * of function `obtain_list` as its inverse function.
+ * 
+ * @param p_list The pointer to the list to release. The value of the pointer
+ * is set to 0, if the list was successfully released, otherwise it is left untouched.
+ */
+void list_release(IntList* p_list);
+
+/**
+ * Determines whether or not the given list is valid.
+ * 
+ * @param list The list to evaluate.
+ * @return `True` if the list is valid, false otherwise.
+ */
+bool list_is_valid(IntList list);
+
+/**
+ * Determines whether or not the list contains at least one item.
+ * 
+ * @param list The list to evaluate.
+ * @return `False` if the list contains one or more items, `true` otherwise.
+ */
+bool list_is_empty(IntList list);
+
+/**
+ * Provides the number of values stored in the list.
+ * 
+ * @param list The list to evaluate.
+ * @return The number of values the list contains.
+ */
+int list_get_size(IntList list);
+
+/**
+ * Determines whether or not the list given list contains the queried value
+ * at least once.
+ * 
+ * @param list The list to query.
+ * @param value The value.
+ * @return `True` if the list contains at least one instance of the value, 
+ * `false ` otherwise.
+ */
+bool list_contains(IntList list, int value);
+
+/**
+ * Provides the value stored in the list at the given position.
+ * 
+ * @param list The list from which the value shall be retrieved.
+ * @param index The zero-based position index of the value to retrieve.
+ * @return The value stored at the given position or 0, if the position
+ * is not available.
+ */
+int list_get_at(IntList list, unsigned int index);
+
+/**
+ * Inserts the given value at the end of the given list.
+ * 
+ * @param list The list to which the value shall be appended.
+ * @param value The value to append to the list.
+ */
+void list_insert(IntList list, int value);
+
+/**
+ * Inserts the given value at the indexed position in a way the 
+ * the inserted value is on that position. The index is
+ * - similar to arrays - zero-based. If the the list is shorter
+ * than the indexed position, the value is inserted at the end
+ * of the list.
+ * 
+ * @param list The list into which the value shall be appended.
+ * @param index The position index of the value to insert.
+ * @param value  The value to insert.
+ */
+void list_insert_at(IntList list, unsigned int index, int value);
+
+/**
+ * Appends the `list_to_append` at the end of the given `list`.
+ * The appended list is empty afterwards, because all nodes of that list
+ * have been transferred to `list`.
+ * 
+ * @param list The list that receives the other list.
+ * @param list_to_append The list that is appended to `list`.
+ */
+/* This function is not required in this assignment. */
+/* void list_append(IntList list, IntList list_to_append); */
+
+/**
+ * Removes the first occurrance of `value` from the given list.
+ * If the list does not contain that value, the list shall not
+ * be modified.
+ * 
+ * @param list The list from which the given value shall be removed.
+ * @param value The value to remove from the list.
+ */
+void list_remove(IntList list, int value);
+
+/**
+ * Removes all occurrances of `value` from the list.
+ * If the list does not contain that value, the list shall not
+ * be modified.
+ * 
+ * @param list The list from which all occurrances of `value` shall be removed.
+ * @param value The `value` to remove throughout the list.
+ */
+void list_remove_all(IntList list, int value);
+
+/**
+ * Removes the value at the indexed position from the given list
+ * and provides that value. If the list does not have a value
+ * at that position, the list remains unmodified.
+ * 
+ * @param list The list from which the value at the given index shall be returned.
+ * @param index The zero-based index of the value to return.
+ * @return The removed value or 0 in case of errors.
+ */
+int list_remove_at(IntList list, unsigned int index);
+
+/**
+ * Swaps the values at the given indexes, so that value at fst_idx becomes
+ * the value at snd_idx and vice versa. The invocation is ignored, if the 
+ * list is invalid or at least one of the given indexes is out of range.
+ * 
+ * @param list The list to manipulate
+ * @param fst_idx The index of the first item to swap.
+ * @param snd_idx The index of the second item to swap.
+ */
+void list_swap(IntList list, unsigned int fst_idx, unsigned int snd_idx);
+
+/**
+ * Clears the given list by removing all values from the list.
+ * 
+ * @param list The list to clear.
+ */
+void list_clear(IntList list);
+
+#endif

list_types.h

@@ -0,0 +1,21 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Class: <your class>
+ * ---------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			List Types
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * The declaration of a common list specific type declarations.
+ * ----------------------------------------------------------
+ */
+
+#ifndef ___LIST_TYPES__H
+#define ___LIST_TYPES__H
+
+#include <stdbool.h>
+
+/** The type of the integer list. */
+typedef struct IntListData* IntList; 
+
+#endif

mainpage.h

@@ -0,0 +1,162 @@
+/**
+* @mainpage
+* @section intro Introduction
+*
+* The implementation and evaluation of a collection of Sorting and Searching Algorithms.
+* 
+* @section objective Assignment Objective
+*
+* The target collection those algorithms are operation on, is an 'Array Backed List'. 
+* This list shares (almost) the same interface (`list.h`) as the linked list from previous assignments
+* but is implemented based on an array.
+* Different sorting and searching algorithms are to be implemented using that list.
+* A stopwatch shall be implemented that is used to measure the time a certain algorithm requires to sort or search.
+* Eventually the measured times for defined number of list items and algorithms are compared.
+* 
+* **Configuration**
+*
+* The capacity of the backing array of the list is defined in `config.h` as `#define CAPACITY_INCREMENT`. 
+* This value defines also the number of items for enlarging the backing array. This means, the array grows
+* always in steps of `CAPACITY_INCREMENT` items.
+*
+* @section assignment Assignment
+*
+* In this assignment various sorting and search algorithms shall be implemented in multiple steps.
+*
+* **Step 1:**
+*
+* Implemenation of an 'Array Backed List' by implementing files `array_backed_list.h`. 
+* This file implements `list.h` using an array as underlying collection instead of a linked list. 
+* In contrast to earlier assignments, the function `list_append(…)` was removed and `list_swap(…)` was added.
+* The array shall have a certain capacity and need to be increased (with all consequences, such as of copying items) 
+* if another item is added to a 'full' list.
+* As a benefit, random access to items is fast, which is required by (most) sorting and searching algorithms.
+* For implementation details read and follow the instructions in file `array_backed_list.c`.
+*
+* **Step 2:**
+* 
+* - Implementation of the infrastructure for selecting and using sorting and searching algorithms as well as
+* for measuring the time a certain algorithm takes for completing its operation.
+* - Implemenation of bubble sort algorithm
+* - Implementation of insertion algorithm
+* - Implementation of sorting criteria that can be applied as paramter to the algorithm (function pointer)
+* 
+*
+*
+* **Step 3:**
+*
+* Implemenation of the following sorting algorithms:
+* - - TO BE DEFINED --
+*
+* @section instructions Working Instructions
+*
+* The library 'allocator' is provided for memory allocation functionality that integrates with unit testing. Behind the facade,
+* allocats memory dynamically similar to `malloc`. Allocated memory must be freed when it is not used anymore. The 'allocator'
+* library must be used for memory alloction operations, otherwise unit tests will fail.
+* 
+* **Step 1:**
+*
+* -# Implement 'array_backed_list.c' against interface indirectly declared in 'list.h':
+*    Make the program and tests compile: Implement all functions in all relevant files declared in the headers 
+*    EMTPY (return nothing, 0, false, ... as required).
+*   - All unit tests shall run but FAIL after this step
+*   - **--COMMIT--**
+* -# Implement the empty functions one by one to make the unit tests.
+*   - Because most unit tests depends on `list_obtain(…)`, `list_release(…)`, `list_is_valid(…)`, 
+*     `list_is_empty(…)`, `list_insert(…)`, and `list_get_size(…)` it makes sense to implement those
+*     functions in one step.
+*   - The purpose of a function is specified as API documentation within the header files.
+*   - Obey comments in source files. Run the unit tests frequently and fix failures.
+*   - **--COMMIT-- after each implemented function.**
+*
+* **Step 2:**
+* -# Based on 'array_backed_list' from step 1. If you don't own an implementation of that list (for good reasons), then:
+*    -# Implement the sorting algorithms based on a large, simple array (length: >= 2^16, see below).
+*    -# Comment the `#define LIST_VARIANT` in `config.h` to enable the functions using arrays and disable those for the list.
+*    -# **Note** Only one variant need to be implemented.
+*    
+* -# Implement all functions defined by the file below empty to make the program compile.
+*    **--COMMIT--**
+* -# `stopwatch.[h|c]` Implement the `stopwatch`. The stopwatch is required to measure the runtime of algorithms
+*    or execution steps. Details about the implementation of the stopwatch can be found in `stopwatch.c`.
+*    Run the unit tests targeting stop watch functionality and make them green.
+*    **--COMMIT--**
+* -# `sorting_criteria.[h|c]`: Implement the sorting criteria function and the define the function pointer type for those functions.
+*    Run the unit tests targeting the sorting criteria functions and make them green.
+*    **--COMMIT--**
+* -# `bubble_sort.[h|c]`: Implement the bubble sort algorithm.
+*    Run the unit tests targeting the bubble sort algorithm and make them green.
+*    **--COMMIT--**
+* -# `insertion_sort.[h|c]`: Implement the insertion sort algorithm.
+*    Run the unit tests targeting the insertion sort algorithm and make them green.
+*    **--COMMIT--**
+* -# `sorting.[h|c]`: Implement the support functions for the sorting application. These functions include initialization,
+*    printing (optional), and selection of the desired sorting algorithm. It also declares an enumeration of all supported
+*    sorting algorithms. Details regarding the implementation of those functions are mentioned in the top section of `sorting.c`.
+*    Run the unit tests targeting the sorting support function  and make them green.
+*    **--COMMIT--**
+* -# `timed_sorting_main_driver.c`: Implement the body of the measurement application. Organize the main application file as wanted.
+*     The application shall measure the time for sorting data of different size with all supported algorithms for the average, the best, 
+*     and the worst case. In addition, it shall measure the time required for setting up and tearing down the data structure.
+*
+*     For each supported sorting algorithm defined in `sorting.h`, starting with an item count of 1:
+*         -# Obtain the data structure (list or array) and initialize it randomly using the according function of `sorting.h`.
+*            Measure the time for this step as 'Init' time.
+*         -# Sort the data using the selected algorithm and measure the time for this step as 'Sort Avg' time.
+*         -# Sort the data using the selected algorithm again (in the same direction) and measure the time for this step as 'Sort Best' time.
+*         -# Sort the data using the selected algorithm in reverse direction and measure the time for this step as 'Sort Worst' time.
+*         -# Release the data structure (if applicable) and measure the time for this step as 'Release' time.
+*         -# Print the measured times as described below.
+*         -# Double the number of items to sort and repeat at step a) as long the item counter is less than 20k or 50k item (depending on your system).
+*
+*    **--COMMIT--**
+*
+*    The print outs as described above shall produce a table as shown below. 
+*    The format pattern for the item count should be `%7d` and `%10.1f` for time values. Pipes `|` herein are not part of the format, 
+*    they are just reqired for markdown. Such a data table can be examined further in a spreadsheet application such as MS Excel.
+*    Describe your observations, verify the runtime complexity based on your time measurements.
+*    
+*    **Note:**: You can take time measurements using different value for `CAPACITY_INCREMENT`. Only `Init` time should differ significantly.
+*
+* | Algorithm;     |   Items;|   Sort_Avg;|  Sort_Best;| Sort Worst;|       Init;|    Release|
+* |:---------------|--------:|-----------:|-----------:|-----------:|-----------:|----------:|
+* | Bubble Sort;   |       1;|        1.0;|        1.0;|        1.0;|        5.0;|        1.0|
+* | Bubble Sort;   |       2;|        0.0;|        0.0;|        1.0;|        3.0;|        0.0|
+* | Bubble Sort;   |       4;|        1.0;|        0.0;|        1.0;|        3.0;|        1.0|
+* | Bubble Sort;   |       8;|        1.0;|        0.0;|        1.0;|        3.0;|        0.0|
+* | Bubble Sort;   |      16;|        2.0;|        0.0;|        3.0;|        3.0;|        1.0|
+* | Bubble Sort;   |      32;|       10.0;|        1.0;|       10.0;|       17.0;|        1.0|
+* | Bubble Sort;   |      64;|       36.0;|        1.0;|       40.0;|        4.0;|        1.0|
+* | Bubble Sort;   |     128;|      143.0;|        2.0;|      156.0;|        5.0;|        1.0|
+* | Bubble Sort;   |     256;|      622.0;|        3.0;|     1676.0;|        7.0;|        1.0|
+* | Bubble Sort;   |     512;|     2697.0;|        7.0;|     2855.0;|       14.0;|        1.0|
+* | Bubble Sort;   |    1024;|    12267.0;|       12.0;|    11984.0;|       23.0;|        2.0|
+* | Bubble Sort;   |    2048;|    43619.0;|       25.0;|    44301.0;|       42.0;|        2.0|
+* | Bubble Sort;   |    4096;|   169480.0;|       49.0;|   181360.0;|       78.0;|        2.0|
+* | Bubble Sort;   |    8192;|   667259.0;|       98.0;|   714083.0;|      157.0;|        1.0|
+* | Bubble Sort;   |   16384;|  2683571.0;|      350.0;|  2837608.0;|      408.0;|       33.0|
+* | Bubble Sort;   |   32768;| 10263822.0;|      571.0;| 11325744.0;|     1879.0;|       31.0|
+* | Insertion Sort;|       1;|        1.0;|        1.0;|        0.0;|      218.0;|        0.0|
+* | Insertion Sort;|       2;|        0.0;|        0.0;|        1.0;|        2.0;|        1.0|
+* | Insertion Sort;|       4;|        0.0;|        0.0;|        1.0;|        2.0;|        1.0|
+* | Insertion Sort;|       8;|        1.0;|        0.0;|        1.0;|        2.0;|        1.0|
+* | Insertion Sort;|      16;|        2.0;|        1.0;|        2.0;|        2.0;|        0.0|
+* | Insertion Sort;|      32;|        5.0;|        1.0;|        7.0;|        2.0;|        0.0|
+* | Insertion Sort;|      64;|       15.0;|        2.0;|       29.0;|        2.0;|        0.0|
+* | Insertion Sort;|     128;|       60.0;|        3.0;|      114.0;|        4.0;|        1.0|
+* | Insertion Sort;|     256;|      219.0;|        5.0;|      583.0;|        6.0;|        1.0|
+* | Insertion Sort;|     512;|     1010.0;|       12.0;|     2026.0;|       11.0;|        1.0|
+* | Insertion Sort;|    1024;|     4066.0;|       28.0;|     8800.0;|       32.0;|        2.0|
+* | Insertion Sort;|    2048;|    16718.0;|       80.0;|    33491.0;|       35.0;|        2.0|
+* | Insertion Sort;|    4096;|    64592.0;|      205.0;|   129536.0;|       69.0;|        2.0|
+* | Insertion Sort;|    8192;|   259646.0;|      670.0;|   524065.0;|      142.0;|        2.0|
+* | Insertion Sort;|   16384;|  1094843.0;|     2327.0;|  2075412.0;|      360.0;|       24.0|
+* | Insertion Sort;|   32768;|  4188706.0;|    10525.0;|  8367830.0;|     1677.0;|       34.0|
+*
+* @section notes Notes
+* -# make cleantest: This new make target for clearing the console, building, and running unit test is available.
+* -# Sometimes changes are not properly detected by incremental builds. If something very strange 
+*    happens during compilation, try to run `make clean` followed by `make` to start a clean build.
+*    This approach is also recommended after everthing is done, because some compiler warning appears
+*    only in clean builds. 
+*/

makefile

@@ -0,0 +1,99 @@
+CC              = gcc
+CCLINK          = g++
+LIBS            =
+CCOPTIONS       = -Wall -pedantic -std=gnu11 -g
+LDOPTIONS       =
+
+BUILD_DIR       = build
+
+TEST    = test_timed_sorting
+PROGRAM = timed_sorting
+
+COMMON_HDRS      = config.h general.h list.h list_types.h
+LIBRARY_FILES    = shortcut allocator
+ASSIGNMENT_HDRS  = 
+ASSIGNMENT_FILES = array_backed_list stopwatch sorting sorting_criteria bubble_sort insertion_sort
+TEST_FILES       = test_list test_stopwatch test_sorting_criteria test_sorting test_bubble_sort test_insertion_sort
+MAIN_DRIVER      = timed_sorting_main_driver
+TEST_DRIVER      = timed_sorting_test_driver
+
+LIBRARY_H        = $(addsuffix .h, $(LIBRARY_FILES))
+ASSIGNMENT_H     = $(addsuffix .h, $(ASSIGNMENT_FILES)) $(ASSIGNMENT_HDRS)
+ASSIGNMENT_C     = $(addsuffix .c, $(ASSIGNMENT_FILES)) $(MAIN_DRIVER).c
+
+HDRS			 = $(ASSIGNEMT_H) $(SHARED_HDRS) $(COMMON_HDRS) $(LIBRARY_H)
+TESTOBJECT       = $(addprefix $(BUILD_DIR)/, $(TEST_DRIVER).o)
+MAINOBJECT       = $(addprefix $(BUILD_DIR)/, $(MAIN_DRIVER).o)
+LIBRARY_OBJS     = $(addprefix $(BUILD_DIR)/, $(addsuffix .o, $(LIBRARY_FILES)))
+TEST_OBJS        = $(addprefix $(BUILD_DIR)/, $(addsuffix .o, $(TEST_FILES)))
+MAIN_OBJ         = $(addprefix $(BUILD_DIR)/, $(addsuffix .o, $(ASSIGNMENT_FILES)))
+OBJS             = $(LIBRARY_OBJS) $(MAIN_OBJ) $(TEST_OBJS)
+
+DOXY             = doxygen
+
+all: $(PROGRAM)
+	./$(PROGRAM)
+
+$(TEST): $(BUILD_DIR) $(OBJS) $(TESTOBJECT)
+	$(CCLINK) -o $@ $(LDOPTIONS) $(OBJS) $(TESTOBJECT)
+
+$(PROGRAM): $(BUILD_DIR) $(OBJS) $(MAINOBJECT)
+	$(CCLINK) -o $@ $(LDOPTIONS) $(OBJS) $(MAINOBJECT)
+
+.PHONY: clean cleanall doxy test setsample setassignment definesample defineassignment assignmentfolder
+
+clean:
+	rm -f $(PROGRAM) $(TEST) $(TESTOBJECT) $(MAINOBJECT) $(OBJS)
+	rm -rf $(BUILD_DIR)
+	rm -f *.o
+
+cleanall: clean
+	rm -f index.html
+	rm -rf html
+
+
+doxy:
+	$(DOXY)
+	rm -f index.html
+	ln -s html/index.html index.html
+
+test: $(TEST)
+	./$(TEST)
+
+cleantest: clean
+	clear
+	make test
+
+$(BUILD_DIR): 
+	mkdir -p $(BUILD_DIR)
+
+$(BUILD_DIR)/%.o: %.c
+	$(CC) $(CCOPTIONS) -c -o $@ $<
+
+#sets project as sample solution
+setsample:
+	$(foreach name, $(ASSIGNMENT_H) $(ASSIGNMENT_C), cp $(name).sample $(name);)
+
+#sets project as assignment
+setassignment:
+	$(foreach name, $(ASSIGNMENT_H) $(ASSIGNMENT_C), cp $(name).assignment $(name);)
+
+# defines current state of project as sample solution
+definesample:
+	$(foreach name, $(ASSIGNMENT_H) $(ASSIGNMENT_C), cp $(name) $(name).sample;)
+
+# defines current sate of project as assignment
+defineassignment :
+	$(foreach name, $(ASSIGNMENT_H) $(ASSIGNMENT_C), cp $(name) $(name).assignment;)
+
+# creates a folder which can serve as a publishable assignment
+assignmentfolder:
+	make setassignment
+	make doxy
+	rm -rf ../assignment
+	mkdir ../assignment
+	cp -R * ../assignment
+	cp .gitignore ../assignment
+	rm ../assignment/*.sample
+	rm ../assignment/*.assignment
+	make cleanall

shortcut.c

@@ -0,0 +1,151 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Title:			shortcut.c
+ * Author:			P. Bauer
+ * Date:			November 08, 2010
+ * ----------------------------------------------------------
+ * Description:
+ * Test driver.
+ * ----------------------------------------------------------
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "shortcut.h"
+
+#define MAX_TEST_FUNCTIONS 256
+
+static char assert_msg_buffer[1024];
+static int tc_count = 0;
+static int tc_fail_count = 0;
+
+static struct TestCase test_cases[MAX_TEST_FUNCTIONS];
+
+const char* version()
+{
+	return "ShortCut v. 1.3.0";
+}
+
+char* format_msg(char* format, ...) {
+	va_list args;
+	va_start (args, format);
+	vsprintf(assert_msg_buffer, format, args);
+	return assert_msg_buffer;
+}
+
+void assert_true(bool bool_expr, struct TestCase *tc, const char *msg,
+									const char* file, int line)
+{
+	if (!bool_expr) {
+		if (tc->success) {
+			tc->success = false;
+			tc_fail_count++;
+		}
+		printf("\n\tFailure (file: %s, line %d): %s: %s", file, line, tc->name, msg);
+	}
+}
+
+void assert_false(bool bool_expr, struct TestCase *tc, const char *msg,
+									const char* file, int line)
+{
+	assert_true(!bool_expr, tc, msg, file, line);
+}
+
+static void assert_string_failure(const char *expected, char *actual, struct TestCase *tc,
+																	const char *msg, const char* file, int line);
+
+void assert_equals_str(const char *expected, char *actual, struct TestCase *tc,
+										const char *msg, const char* file, int line)
+{
+	if (expected == actual) {
+		return;
+	}
+
+	if (expected == 0 || actual == 0) {
+		assert_string_failure(expected, actual, tc, msg, file, line);
+		return;
+	}
+
+	if (strcmp(actual, expected) != 0) {
+		assert_string_failure(expected, actual, tc, msg, file, line);
+		return;
+	}
+}
+
+#define MAX_MSG_LEN 128
+static void assert_string_failure(const char *expected, char *actual, struct TestCase *tc,
+																	const char *msg, const char* file, int line)
+{
+  char new_msg[MAX_MSG_LEN];
+
+	sprintf(new_msg, "Expected \"%s\", actual \"%s\". %s", expected, actual, msg);
+	assert_true(false, tc, new_msg, file, line);
+}
+
+void assert_equals(int expected, int actual, struct TestCase *tc,
+										const char *msg, const char* file, int line)
+{
+	char new_msg[MAX_MSG_LEN];
+	sprintf(new_msg, "Expected %d, actual %d. %s", expected, actual, msg);
+	assert_true(expected == actual, tc, new_msg, file, line);
+}
+
+void assert_equals_f(double expected, double actual, double tolerance, struct TestCase* tc,
+										const char* msg, const char* file, int line)
+{
+	char new_msg[MAX_MSG_LEN];
+	sprintf(new_msg, "Expected %f, actual %f. %s", expected, actual, msg);
+	double min_val = expected - tolerance;
+	double max_val = expected + tolerance;
+	assert_true(min_val <= actual && actual <= max_val, tc, new_msg, file, line);
+}
+
+int get_test_count()
+{
+	return tc_count;
+}
+
+bool add_test(void (*test_function)(struct TestCase *tc), const char *test_name)
+{
+	if (tc_count == MAX_TEST_FUNCTIONS) {
+		return false;
+	}
+	else {
+		test_cases[tc_count].success = true;
+		test_cases[tc_count].name = test_name;
+		test_cases[tc_count].test_function = test_function;
+		tc_count++;
+
+		return true;
+	}
+}
+
+void run_tests()
+{
+	int i;
+
+	printf("\n%s: Running tests\n", version());
+
+	for (i = 0; i < get_test_count(); i++) {
+		printf("Running test %s ...", test_cases[i].name);
+		test_cases[i].test_function(&test_cases[i]);
+		if (test_cases[i].success) {
+			printf("\033[32m OK\033[m");
+		}
+		else {
+			printf("\033[31m ... FAIL\033[m");
+		}
+		printf("\n");
+	}
+
+	printf("\nTotal tests run: %d\n", tc_count);
+	if (tc_fail_count > 0) {
+		printf("\033[31mTests failed: %d\033[m\n", tc_fail_count);
+	}
+	else {
+		printf("\033[32mAll tests run successfully\033[m\n");
+	}
+}

shortcut.h

@@ -0,0 +1,112 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Title:			shortcut
+ * Author:			P. Bauer
+ * Date:			November 03, 2010
+ * ----------------------------------------------------------
+ * Description:
+ * A simple unit testing frame work for C.
+ * ----------------------------------------------------------
+ */
+#ifndef ___SHORTCUT_H
+#define ___SHORTCUT_H
+
+#include <stdbool.h>
+
+/** TestCase is the struct to define one test case. A test case can
+*** be added to a test. If the test is run all added test cases are
+*** run and the result of the run of each test case is checked automatically.
+*/
+struct TestCase {
+	const char *name;
+	/** true if the test passed, false otherwise. */
+	bool success;
+
+	/** The test function which is executed by the test framework. */
+	void (*test_function)(struct TestCase *tc);
+};
+
+/**
+*** @return Version of shortcut as string
+***/
+const char* version();
+
+/**
+*** @return The fromated string as generated using sprintf(format, ...)
+***/
+char* format_msg(char* format, ...);
+
+/** assert_true checks, whether a boolean expression passed is true or false.
+*** in case it is false the test case stating the assertion is marked
+*** as failed and msg is printed.
+*** @param bool_expr Expression which is evaluated.
+*** @param tc Pointer to the test case which states this assertion.
+*** @param msg Message to be printed if assertion evaluates to false.
+*** @param file File in which the assert is given.
+*** @param line Line in which the assert is given.
+*/
+void assert_true(bool bool_expr, struct TestCase *tc, const char *msg,
+									const char* file, int line);
+
+/** assert_false does the same as assert() but the boolean expression
+*** has to evaluate to false. If it evaluates to true the assertion
+*** fails.
+*** @see assert
+*/
+void assert_false(bool bool_expr, struct TestCase* tc, const char* msg,
+									const char* file, int line);
+
+/** assert_equals checks whether two values are equal. Currently the following
+*** data formats are supported:
+*** - strings
+*** - integer
+*** @param expected The expected string value
+*** @param actual The actual string value
+*** @param tc Pointer to the test case which states this assertion.
+*** @param msg Message to be printed if assertion evaluates to false.
+*** @param file File in which the assert is given.
+*** @param line Line in which the assert is given.
+*** @see assert
+*/
+void assert_equals(int expected, int actual, struct TestCase* tc,
+										const char* msg, const char* file, int line);
+void assert_equals_str(const char* expected, char* actual, struct TestCase* tc,
+										const char* msg, const char* file, int line);
+void assert_equals_f(double expected, double actual, double tolerance, struct TestCase* tc,
+										const char* msg, const char* file, int line);
+
+/** @return The total number of test cases added to the test.
+*/
+int get_test_count();
+
+/** add_test creates a new test case and adds the a test function to
+*** this test case.
+*** @param test_function Pointer to the test function to be added
+*** to the newly created test case.
+*** @param test_case_name Name which should be assigned to the newly
+*** created test case.
+*/
+bool add_test(void (*test_function)(struct TestCase *tc), const char *test_case_name);
+
+void run_tests();
+
+#define TEST(testname) void testname(struct TestCase *tc)
+
+#define MSG(format, ...) format_msg(format, ##__VA_ARGS__)
+
+#define ASSERT_TRUE(condition, msg) assert_true(condition, tc, msg, __FILE__, __LINE__)
+
+#define ASSERT_FALSE(condition, msg) assert_false(condition, tc, msg, __FILE__, __LINE__)
+
+#define ASSERT_EQUALS(expected, actual) assert_equals(expected, actual, tc, "", __FILE__, __LINE__)
+
+#define ASSERT_EQUALS_STR(expected, actual, msg) assert_equals_str(expected, actual, tc, msg, __FILE__, __LINE__)
+
+#define ASSERT_EQUALS_TOLERANCE(expected, actual, tolerance) assert_equals_f(expected, actual, tolerance, tc, "", __FILE__, __LINE__)
+
+#define ASSERT_EQUALS_TOLERANCE_STR(expected, actual, tolerance, msg) assert_equals_f(expected, actual, tolerance, tc, msg, __FILE__, __LINE__)
+
+#define ADD_TEST(testfunction) add_test(testfunction, #testfunction)
+
+#endif

sorting.c

@@ -0,0 +1,36 @@
+/*-----------------------------------------------------------------------------
+ *				HTBLA-Leonding / Class: <your class name here>
+ *-----------------------------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Sorting support functions
+ * Author:			*/<your name>;/*
+ *-----------------------------------------------------------------------------
+ * Description:
+ * Basic support functions for sorting
+ *-----------------------------------------------------------------------------
+*/
+#include "sorting.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "bubble_sort.h"
+#include "insertion_sort.h"
+
+/**
+ * This file provides some basic functions for sorting and value initialization.
+ * 
+ * Implementation hints:
+ *   Either list variant OR array variant of functions is required!
+ * 
+ * init_random:
+ *   Randomizer functions are provided by `stdlib.h`
+ * 
+ *   The randomizer must be initialized via `srandom(time(NULL));` once before it is used
+ *   Generate random values via function `random()`
+ *   Limit random value to `MAX_VALUE` as defined in `config.h`
+ */
+
+
+

sorting.h

@@ -0,0 +1,100 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Sorting support functions
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Interface for sorting algorithms
+ * ----------------------------------------------------------
+ */
+#ifndef ___SORTING_H
+#define ___SORTING_H
+
+#include "config.h"
+#include "sorting_criteria.h"
+#include "list.h"
+
+/* NOTE: Either list variant OR array variant of functions is required! */
+
+/**
+ * Enumeration of supported sorting algorithms.
+ */
+
+typedef enum {
+    BUBBLE_SORT,
+    FIRST_ALGORITHM = BUBBLE_SORT,
+    INSERTION_SORT,
+    ALGORITHM_ENUM_END
+} SortingAlgorithm;
+
+/**
+ * Provides the name of the given sorting algorithm.
+ * 
+ * @param algorithm The sorting algorithm
+ * @return The name of the algorithm.
+ */
+<type> get_algorithm_name(<params>);
+
+
+#ifdef LIST_VARIANT
+
+/**
+ * Initializes the given list with random elements.
+ * 
+ * @param list The list to initialize.
+ * @param item_count The number of items to insert.
+ */
+void init_list_random(<params>);
+
+/**
+ * Prints the values stored in the given list.
+ * 
+ * @param prefix The optional text to print before values are printed.
+ * @param list The list to dump.
+ */
+void print_list(char* prefix, IntList list);
+
+/**
+ * Sorts the given list using the given sorting algorithm.
+ * 
+ * @param array The array to sort.
+ * @param algorithm The sorting algorithm to use.
+ * @param criterion The pointer to the function that implements the sorting criterion.
+ * That function accepts two integer parameters and returns a boolean value.
+ */
+void sort_list(<params>);
+
+#else /* ARRAY_VARIANT */
+
+/**
+ * Initializes the given array with random elements.
+ * 
+ * @param array The array to initialize.
+ * @param length The length of the array.
+ */
+void init_array_random(<params>);
+
+/**
+ * Prints the values stored in the given array.
+ * 
+ * @param array The array to dump.
+ * @param length The number of array elements.
+ */
+void print_array(char* prefix, int array[], unsigned long length);
+
+/**
+ * Sorts the given array of the given length using the given sorting algorithm.
+ * 
+ * @param array The array to sort.
+ * @param length The number of array elements.
+ * @param algorithm The sorting algorithm to use.
+ * @param criterion The pointer to the function that implements the sorting criterion.
+ * That function accepts two integer parameters and returns a boolean value.
+ */
+void sort_array(<params>);
+
+#endif /* ARRAY_VARIANT */
+
+#endif

sorting_criteria.c

@@ -0,0 +1,13 @@
+/*-----------------------------------------------------------------------------
+ *				HTBLA-Leonding / Class: <your class name here>
+ *-----------------------------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Sorting criteria
+ * Author:			*/<your name>;/*
+ *-----------------------------------------------------------------------------
+ * Description:
+ * Implementation of sorting criteria
+ *-----------------------------------------------------------------------------
+*/
+
+#include "sorting_criteria.h"

sorting_criteria.h

@@ -0,0 +1,49 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Sorting criteria
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Interface for sorting algorithms
+ * ----------------------------------------------------------
+ */
+
+
+#ifndef ___SORTING_CRITERIA_H
+#define ___SORTING_CRITERIA_H
+
+#include <stdbool.h>
+
+/** 
+ * Declaration of function pointer for comparison function. 
+ * A criterion function determines whether or not the given 
+ * values are in the order that is defined by the criterion.
+ * 
+ * @param int The value that is supposed being ordered before `snd`.
+ * @param int The value that is supposed being ordered after `fst`.
+ * @return True if `fst` IS actually ordered before `snd` 
+ * (the values are in order), false otherwise.
+ */
+/* Note: Name the pointer type 'criterion_fn' */
+
+/**
+ * Determines whether or not `fst` is smaller than or equal to `snd` (ascending order).
+ * 
+ * @param fst The value that is supposed being smaller than `snd`.
+ * @param snd The value to compare.
+ * @return True if the criterion is satisfied, false otherwise.
+ */
+<type> is_in_asc_order(<params>);
+
+/**
+ * Determines whether or not `fst` is larger than or equal to `snd` (descending order).
+ * 
+ * @param fst The value that is supposed being smaller than `snd`.
+ * @param snd The value to compare.
+ * @return True if the criterion is satisfied, false otherwise.
+ */
+<type> is_in_desc_order(i<params>);
+
+#endif

stopwatch.c

@@ -0,0 +1,27 @@
+/*-----------------------------------------------------------------------------
+ *				HTBLA-Leonding / Class: <your class name here>
+ *-----------------------------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Stopwatch
+ * Author:			*/<your name>;/*
+ *-----------------------------------------------------------------------------
+ * Description:
+ * Implementation of a simple stopwatch
+ *-----------------------------------------------------------------------------
+*/
+#include <time.h>
+#include <stdbool.h>
+
+#include "stopwatch.h"
+
+/**
+ * Implementation hints:
+ * 
+ * time functions:
+ *   are provided by `time.h`
+ *   use function `clock()` to get the current `ticks`
+ *   `ticks` are of type `clock_t`
+ *   use `CLOCKS_PER_SEC` to calculate the time in seconds from ticks
+ *     -> seconds = ticks / CLOCK_PER_SEC
+ *   microseconds are s * 10^-6
+ */

stopwatch.h

@@ -0,0 +1,70 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S05
+ * Title:			Stopwatch
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * A stop watch to measure CPU time
+ * ----------------------------------------------------------
+ */
+#ifndef ___STOPWATCH_H
+#define ___STOPWATCH_H
+
+/**
+ * Functions to measure the processor time needed for a section of code. Usage
+ * <pre>
+ * <code>
+ * stopwatch_start();
+ * ...
+ * // some code to be measured
+ * stopwatch_stop();
+ * double elapsed1 = stopwatch_get_elapsed_time(); // given in seconds
+ * ...
+ * stopwatch_resume();
+ * // some more code to be measured
+ * double elapsed2 = stopwatch_get_elapsed_time(); // elapsed2 is time in seconds from start_stopwatch() on
+ * ...
+ * // some more code to be measured
+ * stop_stopwatch();
+ * double elapsed3 = stopwatch_get_elapsed_time(); // time between start_stopwatch() and stop_stopwatch();
+ * </code>
+ * </pre>
+ *
+ * Care must be taken that we measure CPU time! Check out the function clock() and the constant
+ * CLOCKS_PER_SEC from time.h in order to implement the functions correctly.
+ */
+
+/**
+ * Starts taking the time. This function always starts at 0.
+ */
+void stopwatch_start();
+
+/**
+ * Stops or pauses taking the time. Time measurement can be resumed 
+ * via `stopwatch_resume`.
+ */
+void stopwatch_stop();
+
+/**
+ * Resumes taking the time. The previously measured time value is
+ * used as start value.
+ */
+void stopwatch_resume();
+
+/**
+ * Determines whether or not the stopwatch takes the time.
+ * @return True if the stopwatch is measuring, false otherwise.
+ */
+bool stopwatch_is_active();
+
+/**
+ * The measured time in microseconds.
+ * 
+ * @return Either the processor time elapsed since start_stopwatch() has been called or
+ * the processor time elapsed between the calls of start_stopwatch() and stop_stopwatch().
+ */
+double stopwatch_get_elapsed_time();
+
+#endif

test_bubble_sort.c

@@ -0,0 +1,74 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Implementation of UTs for bubble sort
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for bubble sort.
+ * ----------------------------------------------------------
+ */
+
+#include "test_bubble_sort.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "shortcut.h"
+#include "config.h"
+#include "sorting.h"
+
+#include "bubble_sort.h"
+
+
+/* ------------------------------------------------------------------- */
+
+#ifdef LIST_VARIANT
+
+TEST(test_bubble_sort_list_ascending) {
+    IntList list = list_obtain();
+    if (list != 0) {
+        init_list_random(list, 16);
+        bubble_sort_list(list, &is_in_asc_order);
+        int i = 1;
+        for (; i < list_get_size(list) && list_get_at(list, i-1) <= list_get_at(list, i); i++);
+        ASSERT_TRUE(i == list_get_size(list), MSG("Expected that all elements are in ascending order"));
+        list_release(&list);
+    }
+}
+
+TEST(test_bubble_sort_list_decending) {
+    IntList list = list_obtain();
+    if (list != 0) {
+        init_list_random(list, 16);
+        bubble_sort_list(list, &is_in_desc_order);
+        int i = 1;
+        for (; i < list_get_size(list) && list_get_at(list, i-1) >= list_get_at(list, i); i++);
+        ASSERT_TRUE(i == list_get_size(list), MSG("Expected that all elements are in descending order"));
+        list_release(&list);
+    }
+}
+
+#else
+
+TEST(test_bubble_sort_array_ascending) {
+    int array[16];
+    int cnt = 16;
+    init_array_random(array, cnt);
+    bubble_sort_array(array, cnt, &is_in_asc_order);
+    int i = 1;
+    for (; i < cnt && array[i-1] <= array[i]; i++);
+    ASSERT_TRUE(i == cnt, MSG("Expected that all elements are in ascending order"));
+}
+
+TEST(test_bubble_sort_array_descending) {
+    int array[16];
+    int cnt = 16;
+    init_array_random(array, cnt);
+    bubble_sort_array(array, cnt, &is_in_desc_order);
+    int i = 1;
+    for (; i < cnt && array[i-1] >= array[i]; i++);
+    ASSERT_TRUE(i == cnt, MSG("Expected that all elements are in descending order"));
+}
+
+#endif

test_bubble_sort.h

@@ -0,0 +1,25 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for bubble sort
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for bubble sort.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_BUBBLE_SORT_H
+#define ___TEST_BUBBLE_SORT_H
+
+#include "shortcut.h"
+#include "config.h"
+
+#ifdef LIST_VARIANT
+TEST(test_bubble_sort_list_ascending);
+TEST(test_bubble_sort_list_decending);
+#else 
+TEST(test_bubble_sort_array_ascending);
+TEST(test_bubble_sort_array_descending);
+#endif
+
+#endif

test_insertion_sort.c

@@ -0,0 +1,74 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Implementation of UTs for insertion sort
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for insertion sort.
+ * ----------------------------------------------------------
+ */
+
+#include "test_insertion_sort.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "shortcut.h"
+#include "config.h"
+#include "sorting.h"
+
+#include "insertion_sort.h"
+
+
+/* ------------------------------------------------------------------- */
+
+#ifdef LIST_VARIANT
+
+TEST(test_insertion_sort_list_ascending) {
+    IntList list = list_obtain();
+    if (list != 0) {
+        init_list_random(list, 16);
+        insertion_sort_list(list, &is_in_asc_order);
+        int i = 1;
+        for (; i < list_get_size(list) && list_get_at(list, i-1) <= list_get_at(list, i); i++);
+        ASSERT_TRUE(i == list_get_size(list), MSG("Expected that all elements are in ascending order"));
+        list_release(&list);
+    }
+}
+
+TEST(test_insertion_sort_list_decending) {
+    IntList list = list_obtain();
+    if (list != 0) {
+        init_list_random(list, 16);
+        insertion_sort_list(list, &is_in_desc_order);
+        int i = 1;
+        for (; i < list_get_size(list) && list_get_at(list, i-1) >= list_get_at(list, i); i++);
+        ASSERT_TRUE(i == list_get_size(list), MSG("Expected that all elements are in descending order"));
+        list_release(&list);
+    }
+}
+
+#else
+
+TEST(test_insertion_sort_array_ascending) {
+    int array[16];
+    int cnt = 16;
+    init_array_random(array, cnt);
+    insertion_sort_array(array, cnt, &is_in_asc_order);
+    int i = 1;
+    for (; i < cnt && array[i-1] <= array[i]; i++);
+    ASSERT_TRUE(i == cnt, MSG("Expected that all elements are in ascending order"));
+}
+
+TEST(test_insertion_sort_array_descending) {
+    int array[16];
+    int cnt = 16;
+    init_array_random(array, cnt);
+    insertion_sort_array(array, cnt, &is_in_desc_order);
+    int i = 1;
+    for (; i < cnt && array[i-1] >= array[i]; i++);
+    ASSERT_TRUE(i == cnt, MSG("Expected that all elements are in descending order"));
+}
+
+#endif

test_insertion_sort.h

@@ -0,0 +1,25 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for insertion sort
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for insertion sort.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_INSERTION_SORT_H
+#define ___TEST_INSERTION_SORT_H
+
+#include "shortcut.h"
+#include "config.h"
+
+#ifdef LIST_VARIANT
+TEST(test_insertion_sort_list_ascending);
+TEST(test_insertion_sort_list_decending);
+#else 
+TEST(test_insertion_sort_array_ascending);
+TEST(test_insertion_sort_array_descending);
+#endif
+
+#endif

test_list.c

@@ -0,0 +1,818 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Implementation of UTs for lists
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions of a list.
+ * ----------------------------------------------------------
+ */
+
+#include "test_list.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "shortcut.h"
+#include "config.h"
+
+#include "list.h"
+#include "allocator.h"
+
+#define ASSERT_NEW_VALID_LIST() _assert_new_valid_list(tc)
+IntList _assert_new_valid_list(struct TestCase* tc) {
+    int exp_alloc_cnt = mem_get_alloc_call_cnt() + 1;
+    IntList list = list_obtain();
+    ASSERT_TRUE(list != 0, MSG("Expected non-null list"));
+    ASSERT_TRUE(list_is_valid(list), MSG("Expected a valid list"));
+    ASSERT_TRUE(list_is_empty(list), MSG("Expected an empty list"));
+    ASSERT_TRUE(mem_get_alloc_call_cnt() == exp_alloc_cnt, MSG("Expected mem_alloc being called exactly once, but was called %d time(s)", mem_get_alloc_call_cnt() - exp_alloc_cnt - 1));
+    ASSERT_TRUE(mem_is_allocated(list), MSG("Expected obtained list1 is allocated using mem_alloc"));
+    return list;
+}
+
+#define ASSERT_RESET_AND_NEW_VALID_LIST() _assert_reset_and_new_valid_list(tc)
+IntList _assert_reset_and_new_valid_list(struct TestCase* tc) {
+    mem_reset_stat();
+    return _assert_new_valid_list(tc);
+}
+
+
+#define ASSERT_FREE_VALID_LIST(p_list) _assert_free_valid_list(tc, p_list, 2)
+#define ASSERT_FREE_VALID_LIST_EXT(p_list, free_calls) _assert_free_valid_list(tc, p_list, free_calls)
+void _assert_free_valid_list(struct TestCase* tc, IntList* p_list, int exp_free_cnt) {
+    ASSERT_TRUE(p_list != 0 && list_is_valid(*p_list), MSG("Expected a valid list"));
+    int exp_alloc_cnt = mem_get_alloc_call_cnt();
+    ASSERT_TRUE(mem_is_allocated(*p_list), MSG("Expected that list to release was allocated using mem_alloc"));
+    list_release(p_list);
+    ASSERT_TRUE(p_list != 0 && *p_list == 0, MSG("Expected that list was set to 0"));
+    ASSERT_TRUE(mem_get_alloc_call_cnt() == exp_alloc_cnt, MSG("Expected mem_alloc being NOT called, but was called %d time(s)", mem_get_alloc_call_cnt() - exp_alloc_cnt));
+    ASSERT_TRUE(mem_get_free_call_cnt() <= exp_free_cnt, MSG("Expected mem_free being called less than %d time(s), but was called %d time(s)", exp_free_cnt, mem_get_free_call_cnt()));
+    ASSERT_FALSE(mem_is_allocated(*p_list), MSG("Expected that released list is not allocated anymore after release"));
+}
+
+#define ASSERT_MEM_STATUS_EXT(exp_alloc_call_cnt, exp_free_call_cnt, exp_block_cnt) _assert_mem_status_ext(tc, exp_alloc_call_cnt, exp_free_call_cnt, exp_block_cnt)
+void _assert_mem_status_ext(struct TestCase* tc, int exp_alloc_call_cnt, int exp_free_call_cnt, int exp_block_cnt) {
+    ASSERT_TRUE(mem_get_allocated_block_cnt() == exp_block_cnt, MSG("Expected %d allocated memory block(s), but is %d", exp_block_cnt, mem_get_allocated_block_cnt()));
+    ASSERT_TRUE(mem_get_alloc_call_cnt() == exp_alloc_call_cnt, MSG("Expected %d mem_alloc() call(s), but is %d", exp_alloc_call_cnt, mem_get_alloc_call_cnt()));
+    ASSERT_TRUE(mem_get_free_call_cnt() == exp_free_call_cnt, MSG("Expected %d mem_free() call(s), but is %d", exp_free_call_cnt, mem_get_free_call_cnt()));
+}
+
+#define ASSERT_MEM_STATUS(exp_alloc_call_cnt, exp_free_call_cnt) _assert_mem_status_ext(tc, exp_alloc_call_cnt, exp_free_call_cnt, (exp_alloc_call_cnt - exp_free_call_cnt))
+/* ------------------------------------------------------------------- */
+
+TEST(test_list_obtain__shall_allocate_a_list) {
+    int exp_alloc_cnt = 1;
+    mem_reset_stat();
+    IntList list = list_obtain();
+    ASSERT_TRUE(list != 0, MSG("Expected non-null list"));
+    ASSERT_TRUE(mem_get_alloc_call_cnt() == exp_alloc_cnt, MSG("Expected mem_alloc being called exactly %d time(s)", exp_alloc_cnt));
+    ASSERT_TRUE(mem_is_allocated(list), MSG("Expected obtained list is allocated using mem_alloc"));
+    if (list != 0) {
+        free(list);
+    }
+}
+
+TEST(test_list_obtain__shall_allocate_a_fresh_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    if (list != 0) {
+        free(list);
+    }
+}
+
+TEST(test_list_obtain__shall_allocate_a_different_list) {
+    IntList list1 = ASSERT_RESET_AND_NEW_VALID_LIST();
+    IntList list2 = ASSERT_NEW_VALID_LIST();
+    ASSERT_TRUE(list1 != list2, MSG("Expected different lists"));
+    if (list1 != 0) {
+        free(list1);
+    }
+    if (list2 != 0) {
+        free(list2);
+    }
+}
+
+TEST(test_list_obtain_failed__shall_not_allocate_a_list) {
+    IntList list1 = ASSERT_RESET_AND_NEW_VALID_LIST();
+    int exp_alloc_cnt = 1;
+    mem_reset_calls();
+    mem_block_allocs(true);
+    IntList list = list_obtain();
+    ASSERT_TRUE(list == 0, MSG("Expected null list"));
+    ASSERT_TRUE(mem_get_alloc_call_cnt() == exp_alloc_cnt, MSG("Expected mem_alloc being called exactly %d time(s)", exp_alloc_cnt));
+    if (list != 0) {
+        free(list);
+    }
+    free(list1);
+}
+
+
+
+TEST(test_list_release__shall_release_a_valid_empty_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    ASSERT_FREE_VALID_LIST(&list);
+    ASSERT_TRUE(list == 0, MSG("Expected that list is set to 0"));
+}
+
+TEST(test_list_release__shall_release_a_valid_filled_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_insert(list, 12);
+    ASSERT_FREE_VALID_LIST(&list);
+    ASSERT_TRUE(list == 0, MSG("Expected that list is set to 0"));
+}
+
+TEST(test_list_release__shall_ignore_release_of_an_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    int block_cnt = mem_get_allocated_block_cnt();
+    IntList* p_list = 0;
+    list_release(p_list);
+    ASSERT_TRUE(mem_get_allocated_block_cnt() == block_cnt, MSG("Expected unchanged memory allocation"));
+    ASSERT_TRUE(mem_get_free_call_cnt() == 0, MSG("Expected NO mem_free() call, but was called %d time(s)", mem_get_free_call_cnt()));
+
+    IntList list = 0;
+    p_list = &list;
+    list_release(p_list);
+    ASSERT_TRUE(mem_get_allocated_block_cnt() == block_cnt, MSG("Expected unchanged memory allocation"));
+    ASSERT_TRUE(mem_get_free_call_cnt() == 0, MSG("Expected NO mem_free() call, but was called %d time(s)", mem_get_free_call_cnt()));
+
+    list_release(&tmp);
+}
+
+
+
+TEST(test_list_is_valid__shall_be_true_for_valid_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    ASSERT_TRUE(list_is_valid(list), MSG("Expected list to be valid"));
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_is_valid__shall_be_false_for_invalid_list) {
+    ASSERT_FALSE(list_is_valid(0), MSG("Expected list to be invalid"));
+}
+
+
+
+TEST(test_list_insert__shall_add_one_value_to_empty_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_insert__shall_add_multiple_values) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    ASSERT_MEM_STATUS(2, 0);
+    list_insert(list, 12);
+    ASSERT_MEM_STATUS(2, 0);
+    list_insert(list, 13);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_insert__shall_add_many_values) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    for (int i = 0; i < 3 * CAPACITY_INCREMENT; i++) {
+        list_insert(list, 10*i+1);
+    }
+    bool inserted_all = true;
+    for (int i = 0; i < 3 * CAPACITY_INCREMENT; i++) {
+        inserted_all = inserted_all && (list_get_at(list, i) == 10*i+1);
+    }
+    ASSERT_TRUE(inserted_all, MSG("Values are missing or in wrong order when inserting more values than CAPACITY_INCREMENT"));
+    ASSERT_MEM_STATUS(4, 2);
+    ASSERT_FREE_VALID_LIST_EXT(&list, 4);
+}
+
+TEST(test_list_insert__shall_ignore_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(0, 11);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}
+
+
+
+TEST(test_list_remove__shall_not_remove_from_empty_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_remove(list, 11);
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove__shall_remove_only_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_remove(list, 11);
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove__shall_remove_one_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_insert(list, 12);
+    list_insert(list, 11);
+    list_insert(list, 11);
+    list_remove(list, 11);
+    ASSERT_TRUE(list_get_at(list, 0) == 12, MSG("Expected that the fist occurrance was removed"));
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove__shall_remove_first_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_insert(list, 12);
+    list_insert(list, 13);
+    list_remove(list, 11);
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove__shall_remove_value_in_the_middle) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_insert(list, 12);
+    list_insert(list, 13);
+    list_remove(list, 12);
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove__shall_remove_value_at_the_end) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_insert(list, 12);
+    list_insert(list, 13);
+    list_remove(list, 13);
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove__shall_not_remove_missing_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_insert(list, 12);
+    list_insert(list, 13);
+    list_remove(list, 14);
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove__shall_ignore_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_remove(0, 11);
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}
+
+
+
+TEST(test_list_remove_all__shall_not_remove_from_empty_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_remove_all(list, 21);
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_all__shall_remove_only_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 21);
+    list_remove_all(list, 21);
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_all__shall_remove_all_values) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 21);
+    list_insert(list, 21);
+    list_insert(list, 21);
+    list_remove_all(list, 21);
+    ASSERT_TRUE(list_is_empty(list), MSG("Expected list is empty after removal of all nodes"));
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_all__shall_remove_one_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 21);
+    list_insert(list, 22);
+    list_insert(list, 21);
+    list_remove_all(list, 22);
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_all__shall_remove_all_values_in_a_row) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 21);
+    list_insert(list, 22);
+    list_insert(list, 22);
+    list_insert(list, 22);
+    list_insert(list, 23);
+    list_remove_all(list, 22);
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_all__shall_remove_all_distributed_values) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 22);
+    list_insert(list, 23);
+    list_insert(list, 22);
+    list_insert(list, 24);
+    list_insert(list, 22);
+    list_remove_all(list, 22);
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_all__shall_not_remove_missing_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 22);
+    list_insert(list, 23);
+    list_insert(list, 22);
+    list_insert(list, 24);
+    list_insert(list, 22);
+    list_remove_all(list, 21);
+    ASSERT_MEM_STATUS(2, 0); // list and node alloc, node free
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_all__shall_ignore_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_remove_all(0, 21);
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}
+
+
+
+TEST(test_list_insert_at__shall_insert_single_value_in_empty_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert_at(list, 0, 31);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_insert_at__shall_insert_value_at_the_beginning) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_insert(list, 12);
+    list_insert(list, 13);
+    list_insert_at(list, 0, 31);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_TRUE(list_get_at(list, 0) == 31, MSG("Expected value was inserted at the beginning of the list"));
+    ASSERT_TRUE(list_get_at(list, 1) == 11, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 1, 11, list_get_at(list, 1)));
+    ASSERT_TRUE(list_get_at(list, 2) == 12, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 2, 12, list_get_at(list, 2)));
+    ASSERT_TRUE(list_get_at(list, 3) == 13, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 3, 13, list_get_at(list, 3)));
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_insert_at__shall_insert_value_in_the_middle) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_insert(list, 12);
+    list_insert(list, 13);
+    list_insert_at(list, 1, 31);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_TRUE(list_get_at(list, 0) == 11, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 0, 11, list_get_at(list, 0)));
+    ASSERT_TRUE(list_get_at(list, 1) == 31, MSG("Expected value was inserted in the middle of the list"));
+    ASSERT_TRUE(list_get_at(list, 2) == 12, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 2, 12, list_get_at(list, 2)));
+    ASSERT_TRUE(list_get_at(list, 3) == 13, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 3, 13, list_get_at(list, 3)));
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_insert_at__shall_insert_value_at_the_end) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_insert(list, 12);
+    list_insert(list, 13);
+    list_insert_at(list, 3, 31);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_TRUE(list_get_at(list, 0) == 11, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 0, 11, list_get_at(list, 0)));
+    ASSERT_TRUE(list_get_at(list, 1) == 12, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 1, 12, list_get_at(list, 1)));
+    ASSERT_TRUE(list_get_at(list, 2) == 13, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 2, 13, list_get_at(list, 2)));
+    ASSERT_TRUE(list_get_at(list, 3) == 31, MSG("Expected value was inserted before at the end of the list"));
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_insert_at__shall_insert_value_after_the_end) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 11);
+    list_insert(list, 12);
+    list_insert(list, 13);
+    list_insert_at(list, 99, 31);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_TRUE(list_get_at(list, 0) == 11, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 0, 11, list_get_at(list, 0)));
+    ASSERT_TRUE(list_get_at(list, 1) == 12, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 1, 12, list_get_at(list, 1)));
+    ASSERT_TRUE(list_get_at(list, 2) == 13, MSG("Original order of list items is disturbed: #%d: exp.: %d, act. %d", 2, 13, list_get_at(list, 2)));
+    ASSERT_TRUE(list_get_at(list, 3) == 31, MSG("Expected value was inserted before at the end of the list"));
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_insert_at__shall_ignore_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert_at(0, 2, 31);
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}
+
+
+
+TEST(test_list_remove_at__shall_not_remove_from_empty_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_remove_at(list, 0);
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_at__shall_remove_value_at_the_beginning) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 41);
+    list_insert(list, 42);
+    list_insert(list, 43);
+    int val = list_remove_at(list, 0);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_TRUE(list_get_at(list, 0) == 42, MSG("Expected value was removed form the beginning of the list"));
+    ASSERT_TRUE(val == 41, MSG("Expected value %d was removed, but got %d", 41, val));
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_at__shall_remove_value_in_the_middle) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 41);
+    list_insert(list, 42);
+    list_insert(list, 43);
+    int val = list_remove_at(list, 1);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_TRUE(list_get_at(list, 1) == 43, MSG("Expected value was removed form the middle of the list"));
+    ASSERT_TRUE(val == 42, MSG("Expected value %d was removed, but got %d", 42, val));
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_at__shall_remove_value_at_the_end) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 41);
+    list_insert(list, 42);
+    list_insert(list, 43);
+    int val = list_remove_at(list, 2);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_TRUE(list_get_at(list, 1) == 42, MSG("Expected value was removed form the end of the list"));
+    ASSERT_TRUE(val == 43, MSG("Expected value %d was removed, but got %d", 43, val));
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_at__shall_not_remove_value_after_the_end) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 41);
+    list_insert(list, 42);
+    list_insert(list, 43);
+    int val = list_remove_at(list, 3);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_TRUE(val == 0, MSG("Expected that no value (0) was removed, but got %d", val));
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_remove_at__shall_ignore_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    int val = list_remove_at(0, 0);
+    ASSERT_TRUE(val == 0, MSG("Expected that no value (0) was removed, but got %d", val));
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}
+
+
+
+TEST(test_list_clear__shall_clear_empty_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_clear(list);
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_clear__shall_clear_list_with_one_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 51);
+    list_clear(list);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_clear__shall_clear_list_with_multiple_values) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 51);
+    list_insert(list, 52);
+    list_insert(list, 53);
+    list_clear(list);
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_clear__shall_ingore_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_clear(0);
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}
+
+
+
+TEST(test_list_is_empty__shall_be_true__for_newly_obtained_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    ASSERT_TRUE(list_is_empty(0), MSG("Expected that new list IS empty"));
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_is_empty__shall_be_false__after_adding_values) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 61);
+    ASSERT_FALSE(list_is_empty(list), MSG("Expected that list with values IS NOT empty"));
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_is_empty__shall_be_true__after_clear) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 51);
+    list_insert(list, 52);
+    list_insert(list, 53);
+    list_clear(list);
+    ASSERT_FALSE(list_is_empty(0), MSG("Expected that list IS empty after list_clear"));
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_is_empty__shall_be_true_for_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    ASSERT_TRUE(list_is_empty(0), MSG("Expected that invalid list IS empty"));
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}
+
+
+
+TEST(test_list_get_size__shall_be_0_for_newly_obtained_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    ASSERT_TRUE(list_get_size(list) == 0, MSG("Expected that size of new list is 0"));
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_get_size__shall_reflect_number_of_values_after_adding_values) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 71);
+    ASSERT_TRUE(list_get_size(list) == 1, MSG("Expected that size of list is 1 after adding first value"));
+    list_insert(list, 72);
+    ASSERT_TRUE(list_get_size(list) == 2, MSG("Expected that size of list is 2 after adding second value"));
+    list_insert(list, 73);
+    ASSERT_TRUE(list_get_size(list) == 3, MSG("Expected that size of list is 3 after adding third value"));
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_get_size__shall_reflect_number_of_values_after_removing_values) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 81);
+    list_insert(list, 82);
+    list_insert(list, 83);
+    list_remove_at(list, 0);
+    ASSERT_TRUE(list_get_size(list) == 2, MSG("Expected that size of list is 2 after removing first value"));
+    list_remove_at(list, 1);
+    ASSERT_TRUE(list_get_size(list) == 1, MSG("Expected that size of list is 1 after removing second value"));
+    list_remove_at(list, 0);
+    ASSERT_TRUE(list_get_size(list) == 0, MSG("Expected that size of list is 0 after removing third value"));
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_get_size__shall_be_0_after_clear) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 81);
+    list_insert(list, 82);
+    list_insert(list, 83);
+    list_clear(list);
+    ASSERT_TRUE(list_get_size(list) == 0, MSG("Expected that size of list is 0 after clearing the list"));
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_get_size__shall_be_0_for_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    ASSERT_TRUE(list_get_size(0) == 0, MSG("Expected that size of invalid list is 0"));
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}
+
+
+
+TEST(test_list_contains__shall_be_false_for_empty_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    ASSERT_FALSE(list_contains(list, 91), MSG("Expected that empty list does not contain any value"));
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_contains__shall_be_true_for_one_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 91);
+    ASSERT_TRUE(list_contains(list, 91), MSG("Expected that list does contain the value"));
+    list_insert(list, 92);
+    ASSERT_TRUE(list_contains(list, 91), MSG("Expected that list does contain the value"));
+    ASSERT_TRUE(list_contains(list, 92), MSG("Expected that list does contain the value"));
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_contains__shall_be_true_for_multiple_values) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 91);
+    ASSERT_TRUE(list_contains(list, 91), MSG("Expected that list does contain the value"));
+    list_insert(list, 91);
+    ASSERT_TRUE(list_contains(list, 91), MSG("Expected that list does contain the value"));
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_contains__shall_be_false_form_missing_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 91);
+    ASSERT_FALSE(list_contains(list, 94), MSG("Expected that list does NOT contain the value"));
+    list_insert(list, 92);
+    ASSERT_FALSE(list_contains(list, 94), MSG("Expected that list does NOT contain the value"));
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_contains__shall_be_false_for_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    ASSERT_FALSE(list_contains(0, 0), MSG("Expected that invalid list does not contain any value"));
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}
+
+
+
+TEST(test_list_swap__shall_swap_same_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    int values[]    = {51, 52, 53, 54};
+    int exp_vals[]  = {51, 52, 53, 54};
+    int len = sizeof(values)/sizeof(values[0]);
+    for (int i = 0; i < len; i++) {
+        list_insert(list, values[i]);
+    }
+    ASSERT_MEM_STATUS(2, 0);
+    list_swap(list, 2, 2);
+    for (int i = 0; i < len; i++) {
+        int act_val = list_get_at(list, i);
+        ASSERT_TRUE(act_val == exp_vals[i], MSG("Order of list items is wrong: #%d: exp.: %d, act. %d", i, exp_vals[i], act_val));
+    }
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_swap__shall_swap_two_neighbor_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    int values[]    = {51, 52, 53, 54};
+    int exp_vals[]  = {51, 53, 52, 54};
+    int len = sizeof(values)/sizeof(values[0]);
+    for (int i = 0; i < len; i++) {
+        list_insert(list, values[i]);
+    }
+    ASSERT_MEM_STATUS(2, 0);
+    list_swap(list, 2, 1);
+    for (int i = 0; i < len; i++) {
+        int act_val = list_get_at(list, i);
+        ASSERT_TRUE(act_val == exp_vals[i], MSG("Order of list items is wrong: #%d: exp.: %d, act. %d", i, exp_vals[i], act_val));
+    }
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_swap__shall_swap_the_first_and_the_last_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    int values[]    = {51, 52, 53};
+    int exp_vals[]  = {53, 52, 51};
+    int len = sizeof(values)/sizeof(values[0]);
+    for (int i = 0; i < len; i++) {
+        list_insert(list, values[i]);
+    }
+    ASSERT_MEM_STATUS(2, 0);
+    list_swap(list, 0, 2);
+    for (int i = 0; i < len; i++) {
+        int act_val = list_get_at(list, i);
+        ASSERT_TRUE(act_val == exp_vals[i], MSG("Order of list items is wrong: #%d: exp.: %d, act. %d", i, exp_vals[i], act_val));
+    }
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_swap__shall_ignore_swap_of_index_out_of_bounds_1) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    int values[]    = {51, 52, 53};
+    int exp_vals[]  = {51, 52, 53};
+    int len = sizeof(values)/sizeof(values[0]);
+    for (int i = 0; i < len; i++) {
+        list_insert(list, values[i]);
+    }
+    ASSERT_MEM_STATUS(2, 0);
+    list_swap(list, 3, 2);
+    for (int i = 0; i < len; i++) {
+        int act_val = list_get_at(list, i);
+        ASSERT_TRUE(act_val == exp_vals[i], MSG("Order of list items is wrong: #%d: exp.: %d, act. %d", i, exp_vals[i], act_val));
+    }
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_swap__shall_ignore_swap_of_index_out_of_bounds_2) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    int values[]    = {51, 52, 53};
+    int exp_vals[]  = {51, 52, 53};
+    int len = sizeof(values)/sizeof(values[0]);
+    for (int i = 0; i < len; i++) {
+        list_insert(list, values[i]);
+    }
+    ASSERT_MEM_STATUS(2, 0);
+    list_swap(list, 1, 3);
+    for (int i = 0; i < len; i++) {
+        int act_val = list_get_at(list, i);
+        ASSERT_TRUE(act_val == exp_vals[i], MSG("Order of list items is wrong: #%d: exp.: %d, act. %d", i, exp_vals[i], act_val));
+    }
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_swap__shall_ignore_swap_of_index_out_of_bounds_3) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    int values[]    = {51, 52, 53};
+    int exp_vals[]  = {51, 52, 53};
+    int len = sizeof(values)/sizeof(values[0]);
+    for (int i = 0; i < len; i++) {
+        list_insert(list, values[i]);
+    }
+    ASSERT_MEM_STATUS(2, 0);
+    list_swap(list, 3, 4);
+    for (int i = 0; i < len; i++) {
+        int act_val = list_get_at(list, i);
+        ASSERT_TRUE(act_val == exp_vals[i], MSG("Order of list items is wrong: #%d: exp.: %d, act. %d", i, exp_vals[i], act_val));
+    }
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_swap__shall_ignore_invalid_lists) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_swap(0, 3, 5);
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}
+
+
+
+TEST(test_list_get_at__shall_return_0_for_empty_list) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    ASSERT_TRUE(list_get_at(list, 0) == 0, MSG("Expected that empty list provides always 0"));
+    ASSERT_TRUE(list_get_at(list, 1) == 0, MSG("Expected that empty list provides always 0"));
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_get_at__shall_return_single_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 101);
+    ASSERT_TRUE(list_get_at(list, 0) == 101, MSG("Expected that list provides the value"));
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_get_at__shall_return_first_value) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 101);
+    list_insert(list, 102);
+    list_insert(list, 103);
+    ASSERT_TRUE(list_get_at(list, 0) == 101, MSG("Expected that list provides the value"));
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_get_at__shall_return_values_in_added_order) {
+    IntList list = ASSERT_RESET_AND_NEW_VALID_LIST();
+    list_insert(list, 101);
+    list_insert(list, 102);
+    list_insert(list, 103);
+    ASSERT_TRUE(list_get_at(list, 0) == 101, MSG("Expected that list provides the first value"));
+    ASSERT_TRUE(list_get_at(list, 1) == 102, MSG("Expected that list provides the second value"));
+    ASSERT_TRUE(list_get_at(list, 2) == 103, MSG("Expected that list provides the third value"));
+    list_insert_at(list, 1, 104);
+    ASSERT_TRUE(list_get_at(list, 0) == 101, MSG("Expected that list provides the first value"));
+    ASSERT_TRUE(list_get_at(list, 1) == 104, MSG("Expected that list provides the new second value"));
+    ASSERT_TRUE(list_get_at(list, 2) == 102, MSG("Expected that list provides the new third value"));
+    ASSERT_TRUE(list_get_at(list, 3) == 103, MSG("Expected that list provides the new forth value"));
+    ASSERT_MEM_STATUS(2, 0);
+    ASSERT_FREE_VALID_LIST(&list);
+}
+
+TEST(test_list_get_at__shall_return_0_for_invalid_list) {
+    IntList tmp = ASSERT_RESET_AND_NEW_VALID_LIST();
+    ASSERT_TRUE(list_get_at(0, 0) == 0, MSG("Expected that invalid list provides always 0"));
+    ASSERT_MEM_STATUS(1, 0);
+    ASSERT_FREE_VALID_LIST(&tmp);
+}

test_list.h

@@ -0,0 +1,100 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for a List implementation
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions of a list.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_LIST_H
+#define ___TEST_LIST_H
+
+#include "shortcut.h"
+
+TEST(test_list_obtain__shall_allocate_a_list);
+TEST(test_list_obtain__shall_allocate_a_fresh_list);
+TEST(test_list_obtain__shall_allocate_a_different_list);
+TEST(test_list_obtain_failed__shall_not_allocate_a_list);
+
+TEST(test_list_release__shall_release_a_valid_empty_list);
+TEST(test_list_release__shall_release_a_valid_filled_list);
+TEST(test_list_release__shall_ignore_release_of_an_invalid_list);
+
+TEST(test_list_is_valid__shall_be_true_for_valid_list);
+TEST(test_list_is_valid__shall_be_false_for_invalid_list);
+
+TEST(test_list_insert__shall_add_one_value_to_empty_list);
+TEST(test_list_insert__shall_add_multiple_values);
+TEST(test_list_insert__shall_add_many_values);
+TEST(test_list_insert__shall_ignore_invalid_list);
+
+TEST(test_list_remove__shall_not_remove_from_empty_list);
+TEST(test_list_remove__shall_remove_only_value);
+TEST(test_list_remove__shall_remove_one_value);
+TEST(test_list_remove__shall_remove_first_value);
+TEST(test_list_remove__shall_remove_value_in_the_middle);
+TEST(test_list_remove__shall_remove_value_at_the_end);
+TEST(test_list_remove__shall_not_remove_missing_value);
+
+TEST(test_list_remove_all__shall_not_remove_from_empty_list);
+TEST(test_list_remove_all__shall_remove_only_value);
+TEST(test_list_remove_all__shall_remove_all_values);
+TEST(test_list_remove_all__shall_remove_one_value);
+TEST(test_list_remove_all__shall_remove_all_values_in_a_row);
+TEST(test_list_remove_all__shall_remove_all_distributed_values);
+TEST(test_list_remove_all__shall_not_remove_missing_value);
+TEST(test_list_remove_all__shall_ignore_invalid_list);
+
+TEST(test_list_insert_at__shall_insert_single_value_in_empty_list);
+TEST(test_list_insert_at__shall_insert_value_at_the_beginning);
+TEST(test_list_insert_at__shall_insert_value_in_the_middle);
+TEST(test_list_insert_at__shall_insert_value_at_the_end);
+TEST(test_list_insert_at__shall_insert_value_after_the_end);
+TEST(test_list_insert_at__shall_ignore_invalid_list);
+
+TEST(test_list_remove_at__shall_not_remove_from_empty_list);
+TEST(test_list_remove_at__shall_remove_value_at_the_beginning);
+TEST(test_list_remove_at__shall_remove_value_in_the_middle);
+TEST(test_list_remove_at__shall_not_remove_from_empty_list);
+TEST(test_list_remove_at__shall_remove_value_at_the_end);
+TEST(test_list_remove_at__shall_not_remove_value_after_the_end);
+TEST(test_list_remove_at__shall_ignore_invalid_list);
+
+TEST(test_list_clear__shall_clear_empty_list);
+TEST(test_list_clear__shall_clear_list_with_one_value);
+TEST(test_list_clear__shall_clear_list_with_multiple_values);
+TEST(test_list_clear__shall_ingore_invalid_list);
+
+TEST(test_list_is_empty__shall_be_true__for_newly_obtained_list);
+TEST(test_list_is_empty__shall_be_false__after_adding_values);
+TEST(test_list_is_empty__shall_be_true_for_invalid_list);
+
+TEST(test_list_get_size__shall_be_0_for_newly_obtained_list);
+TEST(test_list_get_size__shall_reflect_number_of_values_after_adding_values);
+TEST(test_list_get_size__shall_reflect_number_of_values_after_removing_values);
+TEST(test_list_get_size__shall_be_0_after_clear);
+TEST(test_list_get_size__shall_be_0_for_invalid_list);
+
+TEST(test_list_contains__shall_be_false_for_empty_list);
+TEST(test_list_contains__shall_be_true_for_one_value);
+TEST(test_list_contains__shall_be_true_for_multiple_values);
+TEST(test_list_contains__shall_be_false_form_missing_value);
+TEST(test_list_contains__shall_be_false_for_invalid_list);
+
+TEST(test_list_swap__shall_swap_same_value);
+TEST(test_list_swap__shall_swap_two_neighbor_value);
+TEST(test_list_swap__shall_swap_the_first_and_the_last_value);
+TEST(test_list_swap__shall_ignore_swap_of_index_out_of_bounds_1);
+TEST(test_list_swap__shall_ignore_swap_of_index_out_of_bounds_2);
+TEST(test_list_swap__shall_ignore_swap_of_index_out_of_bounds_3);
+TEST(test_list_swap__shall_ignore_invalid_lists);
+
+TEST(test_list_get_at__shall_return_0_for_empty_list);
+TEST(test_list_get_at__shall_return_single_value);
+TEST(test_list_get_at__shall_return_first_value);
+TEST(test_list_get_at__shall_return_values_in_added_order);
+TEST(test_list_get_at__shall_return_0_for_invalid_list);
+
+#endif

test_sorting.c

@@ -0,0 +1,89 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Implementation of UTs for support functions
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for support functions.
+ * ----------------------------------------------------------
+ */
+
+#include "test_sorting.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "shortcut.h"
+#include "config.h"
+
+#include "sorting.h"
+
+
+/* ------------------------------------------------------------------- */
+
+TEST(test_sorting_get_algorithm_name__shall_provide_name) {
+    char* name = get_algorithm_name(BUBBLE_SORT);
+    ASSERT_TRUE(name != 0 && strlen(name) > 0, MSG("Expected name for bubble sort algorithm"));
+    name = get_algorithm_name(INSERTION_SORT);
+    ASSERT_TRUE(name != 0 && strlen(name) > 0, MSG("Expected name for insertion sort algorithm"));
+}
+
+#ifdef LIST_VARIANT
+
+TEST(test_sorting_init_list_random__shall_initialize_the_list) {
+    IntList list = list_obtain();
+    if (list != 0) {
+        init_list_random(list, 16);
+        ASSERT_TRUE(list_get_size(list) == 16, MSG("Expected that the list was initialized with a number of values"));
+        list_release(&list);
+    }
+}
+
+TEST(test_sorting_sort_list__shall_sort_the_list_ascending) {
+    IntList list = list_obtain();
+    if (list != 0) {
+        init_list_random(list, 16);
+        sort_list(list, BUBBLE_SORT, &is_in_asc_order);
+        int i = 1;
+        for (; i < list_get_size(list) && list_get_at(list, i-1) <= list_get_at(list, i); i++);
+        ASSERT_TRUE(i == list_get_size(list), MSG("Expected that all elements are in ascending order"));
+        list_release(&list);
+    }
+}
+
+TEST(test_sorting_sort_list__shall_sort_the_list_descending) {
+    IntList list = list_obtain();
+    if (list != 0) {
+        init_list_random(list, 16);
+        sort_list(list, INSERTION_SORT, &is_in_desc_order);
+        int i = 1;
+        for (; i < list_get_size(list) && list_get_at(list, i-1) >= list_get_at(list, i); i++);
+        ASSERT_TRUE(i == list_get_size(list), MSG("Expected that all elements are in descending order"));
+        list_release(&list);
+    }
+}
+
+#else
+
+TEST(test_sorting_sort_array__shall_sort_the_array_ascending) {
+    int array[16];
+    int cnt = 16;
+    init_array_random(array, cnt);
+    sort_array(array, cnt, BUBBLE_SORT, &is_in_asc_order);
+    int i = 1;
+    for (; i < cnt && array[i-1] <= array[i]; i++);
+    ASSERT_TRUE(i == cnt, MSG("Expected that all elements are in ascending order"));
+}
+
+TEST(test_sorting_sort_list__shall_sort_the_array_descending) {
+    int array[16];
+    int cnt = 16;
+    init_array_random(array, cnt);
+    sort_array(array, cnt, INSERTION_SORT, &is_in_desc_order);
+    int i = 1;
+    for (; i < cnt && array[i-1] >= array[i]; i++);
+    ASSERT_TRUE(i == cnt, MSG("Expected that all elements are in descending order"));
+}
+
+#endif

test_sorting.h

@@ -0,0 +1,27 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for support functions
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for support functions.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_SORTING_H
+#define ___TEST_SORTING_H
+
+#include "shortcut.h"
+#include "config.h"
+
+TEST(test_sorting_get_algorithm_name__shall_provide_name);
+#ifdef LIST_VARIANT
+TEST(test_sorting_init_list_random__shall_initialize_the_list);
+TEST(test_sorting_sort_list__shall_sort_the_list_ascending);
+TEST(test_sorting_sort_list__shall_sort_the_list_descending);
+#else 
+TEST(test_sorting_sort_array__shall_sort_the_array_ascending);
+TEST(test_sorting_sort_list__shall_sort_the_array_descending);
+#endif
+
+#endif

test_sorting_criteria.c

@@ -0,0 +1,40 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for sorting criteria implementation
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for sorting criteria.
+ * ----------------------------------------------------------
+ */
+
+#include "test_sorting_criteria.h"
+
+#include <stdio.h>
+
+#include "shortcut.h"
+#include "config.h"
+
+#include "sorting_criteria.h"
+
+/* ------------------------------------------------------------------- */
+
+TEST(test_is_in_asc_order__shall_be_true_for_ascending_params) {
+    ASSERT_TRUE(is_in_asc_order(1, 2), MSG("Expected true for ascending values"));
+}
+TEST(test_is_in_asc_order__shall_be_true_for_equal_params) {
+    ASSERT_TRUE(is_in_asc_order(3, 3), MSG("Expected true for equal values"));
+}
+TEST(test_is_in_asc_order__shall_be_false_for_descending_params) {
+    ASSERT_FALSE(is_in_asc_order(5, 4), MSG("Expected false for descending values"));
+}
+TEST(test_is_in_desc_order__shall_be_false_for_ascending_params) {
+    ASSERT_FALSE(is_in_desc_order(11, 12), MSG("Expected false for ascending values"));
+}
+TEST(test_is_in_desc_order__shall_be_true_for_equal_params) {
+    ASSERT_TRUE(is_in_desc_order(13, 13), MSG("Expected true for ascending values"));
+}
+TEST(test_is_in_desc_order__shall_be_true_for_descending_params) {
+    ASSERT_TRUE(is_in_desc_order(15, 14), MSG("Expected true for descending values"));
+}

test_sorting_criteria.h

@@ -0,0 +1,23 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for sorting criteria implementation
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for sorting criteria.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_SORTING_CRITERIA_H
+#define ___TEST_SORTING_CRITERIA_H
+
+#include "shortcut.h"
+
+TEST(test_is_in_asc_order__shall_be_true_for_ascending_params);
+TEST(test_is_in_asc_order__shall_be_true_for_equal_params);
+TEST(test_is_in_asc_order__shall_be_false_for_descending_params);
+TEST(test_is_in_desc_order__shall_be_false_for_ascending_params);
+TEST(test_is_in_desc_order__shall_be_true_for_equal_params);
+TEST(test_is_in_desc_order__shall_be_true_for_descending_params);
+
+#endif

test_stopwatch.c

@@ -0,0 +1,96 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Implementation of UTs for the stopwatch
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions of the stopwatch.
+ * ----------------------------------------------------------
+ */
+
+#include "test_stopwatch.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+
+#include "shortcut.h"
+#include "config.h"
+
+#include "stopwatch.h"
+
+static double measure_test_load() {
+    clock_t start = clock();
+    for(int i = 1; i < 500000; i++) {
+        sqrt(i * 2.0);
+    }
+    return ((double)(clock() - start) / CLOCKS_PER_SEC) * 1000.0;
+}
+
+/* ------------------------------------------------------------------- */
+
+TEST(test_stopwatch_is_active__shall_provide_running_state) {
+    ASSERT_FALSE(stopwatch_is_active(), MSG("Expected initially inactive stopwatch"));
+    stopwatch_stop();
+    ASSERT_FALSE(stopwatch_is_active(), MSG("Expected still inactive stopwatch"));
+    stopwatch_start();
+    ASSERT_TRUE(stopwatch_is_active(), MSG("Expected active stopwatch"));
+    stopwatch_stop();
+    ASSERT_FALSE(stopwatch_is_active(), MSG("Expected inactive stopwatch"));
+    stopwatch_start();
+    ASSERT_TRUE(stopwatch_is_active(), MSG("Expected again active stopwatch"));
+    stopwatch_resume();
+    ASSERT_TRUE(stopwatch_is_active(), MSG("Expected still active stopwatch"));
+    stopwatch_stop();
+    ASSERT_FALSE(stopwatch_is_active(), MSG("Expected inactive stopwatch for the 2nd time"));
+    stopwatch_resume();
+    ASSERT_TRUE(stopwatch_is_active(), MSG("Expected active resumed stopwatch"));
+    stopwatch_stop();
+    ASSERT_FALSE(stopwatch_is_active(), MSG("Expected finally inactive stopwatch"));
+}
+
+TEST(test_stopwatch_start__shall_provide_elapsed_time) {
+    stopwatch_start();
+    double load_time_1 = measure_test_load();
+    double el_time_1 = stopwatch_get_elapsed_time() / 1000.0;
+    double load_time_2 = measure_test_load();
+    double el_time_2 = stopwatch_get_elapsed_time() / 1000.0;
+    stopwatch_stop();
+
+    ASSERT_TRUE(el_time_1 > 0.0, MSG("Expected that time proceeded for 1st measurement"));
+    ASSERT_EQUALS_TOLERANCE_STR(load_time_1, el_time_1, 0.04, MSG("Expected that time proceeded to %.3f, but is %.3f", load_time_1, el_time_1));
+    ASSERT_TRUE(el_time_2 > el_time_1, MSG("Expected that time proceeded for 2nd measurement"));
+    ASSERT_EQUALS_TOLERANCE_STR(load_time_1 + load_time_2, el_time_2, 0.08, MSG("Expected that time proceeded to %.3f, but is %.3f", load_time_1 + load_time_2, el_time_2));
+}
+
+TEST(test_stopwatch_start_stop__shall_provide_elapsed_time) {
+    stopwatch_start();
+    double load_time_1 = measure_test_load();
+    stopwatch_stop();
+    double el_time_1 = stopwatch_get_elapsed_time() / 1000.0;
+    measure_test_load();
+    double el_time_2 = stopwatch_get_elapsed_time() / 1000.0;
+    ASSERT_TRUE(el_time_1 > 0.0, MSG("Expected that time proceeded"));
+    ASSERT_EQUALS_TOLERANCE_STR(load_time_1, el_time_1, 0.04, MSG("Expected that time proceeded to %.3f, but is %.3f", load_time_1, el_time_1));
+    ASSERT_EQUALS_TOLERANCE_STR(el_time_1, el_time_2, 0.001, MSG("Expected that time is kept as %.3f, but is %.3f", el_time_1, el_time_2));
+}
+
+TEST(test_stopwatch_start_stop_resume__shall_provide_elapsed_time) {
+    stopwatch_start();
+    double load_time_1 = measure_test_load();
+    stopwatch_stop();
+    double el_time_1 = stopwatch_get_elapsed_time() / 1000.0;
+    measure_test_load();
+    double el_time_2 = stopwatch_get_elapsed_time() / 1000.0;
+    stopwatch_resume();
+    double load_time_2 = measure_test_load();
+    stopwatch_stop();
+    double el_time_3 = stopwatch_get_elapsed_time() / 1000.0;
+
+    ASSERT_TRUE(el_time_1 > 0.0, MSG("Expected that time proceeded"));
+    ASSERT_EQUALS_TOLERANCE_STR(load_time_1, el_time_1, 0.04, MSG("Expected that time proceeded to %.3f, but is %.3f", load_time_1, el_time_1));
+    ASSERT_EQUALS_TOLERANCE_STR(el_time_1, el_time_2, 0.001, MSG("Expected that time is kept as %.3f, but is %.3f", el_time_1, el_time_2));
+    ASSERT_EQUALS_TOLERANCE_STR(load_time_1 + load_time_2, el_time_3, 0.04, MSG("Expected that time proceeded to %.3f, but is %.3f", load_time_1 + load_time_2, el_time_3));
+}

test_stopwatch.h

@@ -0,0 +1,21 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for the stopwatch implementation
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions of the stopwatch.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_STOPWATCH_H
+#define ___TEST_STOPWATCH_H
+
+#include "shortcut.h"
+
+TEST(test_stopwatch_is_active__shall_provide_running_state);
+TEST(test_stopwatch_start__shall_provide_elapsed_time);
+TEST(test_stopwatch_start_stop__shall_provide_elapsed_time);
+TEST(test_stopwatch_start_stop_resume__shall_provide_elapsed_time);
+
+#endif

timed_sorting_main_driver.c

@@ -0,0 +1,17 @@
+/*-----------------------------------------------------------------------------
+ *				HTBLA-Leonding / Class: <your class name here>
+ *-----------------------------------------------------------------------------
+ * Exercise Number: S02
+ *-----------------------------------------------------------------------------
+ * Description:
+ * The assignment does not require to implement an application.
+ * Run 'make test' to build and execute all required unit tests.
+ *-----------------------------------------------------------------------------
+*/
+
+#include <stdio.h>
+
+int main(int argc, char *argv[]) {
+    printf("The assignment does not require to implement an application.\n");
+    printf("Run 'make test' to build and execute all required unit tests.\n");
+}

timed_sorting_test_driver.c

@@ -0,0 +1,162 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Title:			Tests implementation of a Liked List.
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Unit tests for a linked list implemenation.
+ * ----------------------------------------------------------
+ */
+#include <stdio.h>
+#include <string.h>
+
+#include "config.h"
+
+#include "shortcut.h"
+#include "test_list.h"
+#include "test_stopwatch.h"
+#include "test_sorting_criteria.h"
+#include "test_bubble_sort.h"
+#include "test_insertion_sort.h"
+#include "test_sorting.h"
+
+int main(int argc, char *argv[])
+{
+	/* LIST */
+	#ifdef LIST_VARIANT 
+	ADD_TEST(test_list_obtain__shall_allocate_a_list);
+	ADD_TEST(test_list_obtain__shall_allocate_a_fresh_list);
+	ADD_TEST(test_list_obtain__shall_allocate_a_different_list);
+	ADD_TEST(test_list_obtain_failed__shall_not_allocate_a_list);
+	
+	ADD_TEST(test_list_get_size__shall_be_0_for_newly_obtained_list);
+	ADD_TEST(test_list_get_size__shall_reflect_number_of_values_after_adding_values);
+	ADD_TEST(test_list_get_size__shall_reflect_number_of_values_after_removing_values);
+	ADD_TEST(test_list_get_size__shall_be_0_after_clear);
+	ADD_TEST(test_list_get_size__shall_be_0_for_invalid_list);
+
+	ADD_TEST(test_list_release__shall_release_a_valid_empty_list);
+	ADD_TEST(test_list_release__shall_release_a_valid_filled_list);
+	ADD_TEST(test_list_release__shall_ignore_release_of_an_invalid_list);
+	
+	ADD_TEST(test_list_is_valid__shall_be_true_for_valid_list);
+	ADD_TEST(test_list_is_valid__shall_be_false_for_invalid_list);
+	
+	ADD_TEST(test_list_is_empty__shall_be_true__for_newly_obtained_list);
+	ADD_TEST(test_list_is_empty__shall_be_false__after_adding_values);
+	ADD_TEST(test_list_is_empty__shall_be_true_for_invalid_list);
+	
+	ADD_TEST(test_list_insert__shall_add_one_value_to_empty_list);
+	ADD_TEST(test_list_insert__shall_add_multiple_values);
+	ADD_TEST(test_list_insert__shall_add_many_values);
+	ADD_TEST(test_list_insert__shall_ignore_invalid_list);
+	
+	ADD_TEST(test_list_remove__shall_not_remove_from_empty_list);
+	ADD_TEST(test_list_remove__shall_remove_only_value);
+	ADD_TEST(test_list_remove__shall_remove_one_value);
+	ADD_TEST(test_list_remove__shall_remove_first_value);
+	ADD_TEST(test_list_remove__shall_remove_value_in_the_middle);
+	ADD_TEST(test_list_remove__shall_remove_value_at_the_end);
+	ADD_TEST(test_list_remove__shall_not_remove_missing_value);
+	
+	ADD_TEST(test_list_remove_all__shall_not_remove_from_empty_list);
+	ADD_TEST(test_list_remove_all__shall_remove_only_value);
+	ADD_TEST(test_list_remove_all__shall_remove_all_values);
+	ADD_TEST(test_list_remove_all__shall_remove_one_value);
+	ADD_TEST(test_list_remove_all__shall_remove_all_values_in_a_row);
+	ADD_TEST(test_list_remove_all__shall_remove_all_distributed_values);
+	ADD_TEST(test_list_remove_all__shall_not_remove_missing_value);
+	ADD_TEST(test_list_remove_all__shall_ignore_invalid_list);
+	
+	ADD_TEST(test_list_insert_at__shall_insert_single_value_in_empty_list);
+	ADD_TEST(test_list_insert_at__shall_insert_value_at_the_beginning);
+	ADD_TEST(test_list_insert_at__shall_insert_value_in_the_middle);
+	ADD_TEST(test_list_insert_at__shall_insert_value_at_the_end);
+	ADD_TEST(test_list_insert_at__shall_insert_value_after_the_end);
+	ADD_TEST(test_list_insert_at__shall_ignore_invalid_list);
+	
+	ADD_TEST(test_list_remove_at__shall_not_remove_from_empty_list);
+	ADD_TEST(test_list_remove_at__shall_remove_value_at_the_beginning);
+	ADD_TEST(test_list_remove_at__shall_remove_value_in_the_middle);
+	ADD_TEST(test_list_remove_at__shall_not_remove_from_empty_list);
+	ADD_TEST(test_list_remove_at__shall_remove_value_at_the_end);
+	ADD_TEST(test_list_remove_at__shall_not_remove_value_after_the_end);
+	ADD_TEST(test_list_remove_at__shall_ignore_invalid_list);
+	
+	ADD_TEST(test_list_clear__shall_clear_empty_list);
+	ADD_TEST(test_list_clear__shall_clear_list_with_one_value);
+	ADD_TEST(test_list_clear__shall_clear_list_with_multiple_values);
+	ADD_TEST(test_list_clear__shall_ingore_invalid_list);
+	
+	ADD_TEST(test_list_contains__shall_be_false_for_empty_list);
+	ADD_TEST(test_list_contains__shall_be_true_for_one_value);
+	ADD_TEST(test_list_contains__shall_be_true_for_multiple_values);
+	ADD_TEST(test_list_contains__shall_be_false_form_missing_value);
+	ADD_TEST(test_list_contains__shall_be_false_for_invalid_list);
+	
+	ADD_TEST(test_list_swap__shall_swap_same_value);
+	ADD_TEST(test_list_swap__shall_swap_two_neighbor_value);
+	ADD_TEST(test_list_swap__shall_swap_the_first_and_the_last_value);
+	ADD_TEST(test_list_swap__shall_ignore_swap_of_index_out_of_bounds_1);
+	ADD_TEST(test_list_swap__shall_ignore_swap_of_index_out_of_bounds_2);
+	ADD_TEST(test_list_swap__shall_ignore_swap_of_index_out_of_bounds_3);
+	ADD_TEST(test_list_swap__shall_ignore_invalid_lists);
+
+	ADD_TEST(test_list_get_at__shall_return_0_for_empty_list);
+	ADD_TEST(test_list_get_at__shall_return_single_value);
+	ADD_TEST(test_list_get_at__shall_return_first_value);
+	ADD_TEST(test_list_get_at__shall_return_values_in_added_order);
+	ADD_TEST(test_list_get_at__shall_return_0_for_invalid_list);
+
+	#else /* ARRAY VARIANT */
+	#endif /* ARRAY VARIANT */
+
+	/* --- STOPWATCH --- */
+	ADD_TEST(test_stopwatch_is_active__shall_provide_running_state);
+	ADD_TEST(test_stopwatch_start__shall_provide_elapsed_time);
+	ADD_TEST(test_stopwatch_start_stop__shall_provide_elapsed_time);
+	ADD_TEST(test_stopwatch_start_stop_resume__shall_provide_elapsed_time);
+
+	/* --- SORT CRITERIA --- */
+	ADD_TEST(test_is_in_asc_order__shall_be_true_for_ascending_params);
+	ADD_TEST(test_is_in_asc_order__shall_be_true_for_equal_params);
+	ADD_TEST(test_is_in_asc_order__shall_be_false_for_descending_params);
+	ADD_TEST(test_is_in_desc_order__shall_be_false_for_ascending_params);
+	ADD_TEST(test_is_in_desc_order__shall_be_true_for_equal_params);
+	ADD_TEST(test_is_in_desc_order__shall_be_true_for_descending_params);
+
+	/* --- BUBBLE SORT --- */
+	#ifdef LIST_VARIANT
+	ADD_TEST(test_bubble_sort_list_ascending);
+	ADD_TEST(test_bubble_sort_list_decending);
+	#else 
+	ADD_TEST(test_bubble_sort_array_ascending);
+	ADD_TEST(test_bubble_sort_array_descending);
+	#endif
+
+	/* --- INSERTION SORT --- */
+	#ifdef LIST_VARIANT
+	ADD_TEST(test_insertion_sort_list_ascending);
+	ADD_TEST(test_insertion_sort_list_decending);
+	#else 
+	ADD_TEST(test_insertion_sort_array_ascending);
+	ADD_TEST(test_insertion_sort_array_descending);
+	#endif
+
+	/* --- SORTING --- */
+	ADD_TEST(test_sorting_get_algorithm_name__shall_provide_name);
+	#ifdef LIST_VARIANT
+	ADD_TEST(test_sorting_init_list_random__shall_initialize_the_list);
+	ADD_TEST(test_sorting_sort_list__shall_sort_the_list_ascending);
+	ADD_TEST(test_sorting_sort_list__shall_sort_the_list_descending);
+	#else 
+	ADD_TEST(test_sorting_sort_array__shall_sort_the_array_ascending);
+	ADD_TEST(test_sorting_sort_list__shall_sort_the_array_descending);
+	#endif
+
+
+
+	run_tests();
+	return 0;
+}