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 1024
+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: S07
+ * 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: S07
+ * 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

binary_search.c

@@ -0,0 +1,13 @@
+/*-----------------------------------------------------------------------------
+ *				HTBLA-Leonding
+ *-----------------------------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Binary search implementation
+ * Author:			*/<your name>;/*
+ *-----------------------------------------------------------------------------
+ * Description:
+ * Implements the binary search algorithm
+ *-----------------------------------------------------------------------------
+*/
+
+#include "binary_search.h"

binary_search.h

@@ -0,0 +1,67 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Binary search implementation
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Implements the binary search algorithm
+ * ----------------------------------------------------------
+ */
+#ifndef ___BINARY_SEARCH_H
+#define ___BINARY_SEARCH_H
+
+#include "list.h"
+#include "sorting_criteria.h"
+
+/* NOTE: Either list or array variant is required! */
+
+/**
+ * Searches the given needle within the given haystack using binary search approach.
+ * 
+ * Implementation hint: delegate the invocation to function `binary_search_list_limited(…)`.
+ * 
+ * @param haystack The sorted list in which the `needle` is searched.
+ * @param criterion The pointer to the function that implements the sorting criterion of the list.
+ * That function accepts two integer parameters and returns a boolean value.
+ * @param needle The value to find within the haystack.
+ * @return The index of the `needle` within the list if it was found or the position where the needle need to
+ * be inserted into the sorted list if it is not included in the list. The insertion position is 
+ * expressed as index with negative sign, so that the value can be inserted at index (-1 * result).
+ */
+int binary_search_list(<params>);
+
+/**
+ * Searches the given needle within the given haystack up the given length using binary search approach.
+ * 
+ * @param haystack The sorted list in which the `needle` is searched.
+ * @param length The number of items to consider starting from the beginning of the haystack.
+ * If the haystack contains more items, the remaining items are omitted from the search. If it contains
+ * less items, the number of items are clipped to the size of the haystack.
+ * @param criterion The pointer to the function that implements the sorting criterion of the list.
+ * That function accepts two integer parameters and returns a boolean value.
+ * @param needle The value to find within the haystack.
+ * @return The index of the `needle` within the list if it was found or the position where the needle need to
+ * be inserted into the sorted list if it is not included in the list. The insertion position is 
+ * expressed as index with negative sign, so that the value can be inserted at index (-1 * result).
+ */
+<type> binary_search_list_limited(<params>);
+
+/* ARRAY VARIANT */
+
+/**
+ * Searches the given needle within the given haystack using binary search approach.
+ *  
+ * @param haystack The sorted list in which the `needle` is searched.
+ * @param length The length of the haystack array.
+ * @param criterion The pointer to the function that implements the sorting criterion of the list.
+ * That function accepts two integer parameters and returns a boolean value.
+ * @param needle The value to find within the haystack.
+ * @return The index of the `needle` within the list if it was found or the position where the needle need to
+ * be inserted into the sorted list if it is not included in the list. The insertion position is 
+ * expressed as index with negative sign, so that the value can be inserted at index (-1 * result).
+ */
+<type> binary_search_array(<params>);
+
+#endif

bubble_sort.c

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

bubble_sort.h

@@ -0,0 +1,39 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Bubble sort
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Implements the bubble sort algorithm
+ * ----------------------------------------------------------
+ */
+#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 algorithm.
+ * 
+ * @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 algorithm.
+ * 
+ * @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 64
+
+/** 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,22 @@
+/*----------------------------------------------------------
+ *				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 to get maximum of two numbers */
+#define MAX(x, y) ((x) > (y) ? (x) : (y))
+/** Convenience macro to get maximum of two numbers */
+#define MIN(x, y) ((x) < (y) ? (x) : (y))
+/** Convenience macro to get the absolute value of a number */
+#define ABS(x) (x < 0 ? (-1*x) : (x))
+
+#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 Wed Apr 14 2021 12:09:56 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,300 @@
+<!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>
+<ul>
+<li>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>.</li>
+</ul>
+<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>Implementation 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>
+<ul>
+<li>Implementation of merge sort algorithm</li>
+<li>Extension of list as required</li>
+</ul>
+<p><b>Step 4:</b></p>
+<ul>
+<li>Implementation of quick sort algorithm</li>
+<li>Implementation of linear search algorithm</li>
+<li>Implementation of binary search algorithm</li>
+<li>Implementation of insertion sort algorithm using binary search</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 (list OR array) need to be implemented.</li>
+</ol>
+</li>
+<li>Implement all functions defined by the files 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_Random; </th><th class="markdownTableHeadRight">Sort_Sorted; </th><th class="markdownTableHeadRight">Sort_Reverse; </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>
+<p><b>Step 3:</b></p><ol type="1">
+<li>Copy all header and source files that need to be implemented in this assignment but have been already developed in earlier steps (esp. step 2) from YOUR solution to this assignment. Do not copy unit tests! <b>&ndash;COMMIT&ndash;</b></li>
+<li>Based on 'array_backed_list' from step 2. 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 (list OR array) 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>array_backed_list.c</code>: (list variant only)<ol type="a">
+<li>Implement the additional functions as defined in <code>list.h</code><ul>
+<li><code>list_append</code></li>
+<li><code>list_split</code></li>
+<li><code>list_transfer_head</code> <b>&ndash;COMMIT&ndash;</b></li>
+</ul>
+</li>
+</ol>
+</li>
+<li><code>merge_sort.[h|c]</code>: Implement the merge sort algorithm. Run the unit tests targeting the merge sort algorithm and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><code>sorting.[h|c]</code>: Extend the functions that delegates to different sorting algorithms to support MERGE_SORT. Run the unit tests targeting the sorting support function and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li>Run the application. The output shown above for step 2 should be extended for Merge Sort.</li>
+</ol>
+<p><b>Step 4:</b></p><ol type="1">
+<li>Copy all header and source files that need to be implemented in this assignment but have been already developed in earlier steps (esp. step 3) from YOUR solution to this assignment. Do not copy unit tests! <b>&ndash;COMMIT&ndash;</b></li>
+<li>Based on 'array_backed_list' from step 3. 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 (list OR array) 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>quick_sort.[h|c]</code>: Implement the quick sort algorithm. Run the unit tests targeting the quick sort algorithm and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><code>insertion_sort_binary_search.[h|c]</code>: Implement the insertion sort algorithm that uses binary search for finding the insert position. The insertion sort algorithm implemented in step 2 can be reused and modified. Run the unit tests targeting the insertion sort with binary search algorithm and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><code>sorting.[h|c]</code>: Extend the functions that delegates to different sorting algorithms to support QUICK_SORT and INSERTION_SORT_BINARY_SEARCH. Run the unit tests targeting the sorting support function and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><code>linear_search.[h|c]</code>: Implement the linear search algorithm. Run the unit tests targeting the linear search algorithm and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><code>binary_search.[h|c]</code>: Implement the binary search algorithm. Run the unit tests targeting the binary search algorithm and make them green. <b>&ndash;COMMIT&ndash;</b></li>
+<li><p class="startli"><code>timed_sorting_main_driver.c</code>: Extend the application with measurement for search algorithms. Organize the main application file as wanted. In addition the application shall measure the time for searching a value using linear search and binary search within a long (&gt; 16k items) list or array. The time for searching every Xth item that is contained in the list or array shall be measured for each search algorithm, X may be ~100.</p>
+<p class="startli"><b>Note:</b> Especially for binary search, measuring one search execution may result in values beyond measurable range. Therefore the time measurement of a single item shall invoke the search function Y times (Y &gt;= 10). The accumulated measured result need them be divided by Y (time = measured_time/Y).</p>
+<p class="startli">The print-out for these measurements may look like: </p><table class="markdownTable">
+<tr class="markdownTableHead">
+<th class="markdownTableHeadLeft">Algorithm; </th><th class="markdownTableHeadRight">Index; </th><th class="markdownTableHeadRight">Time;  </th></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Bubble Sort; </td><td class="markdownTableBodyRight">1; </td><td class="markdownTableBodyRight">1.0;  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Linear Search; </td><td class="markdownTableBodyRight">0; </td><td class="markdownTableBodyRight">0.1;  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Binary Search; </td><td class="markdownTableBodyRight">0; </td><td class="markdownTableBodyRight">0.1;  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Linear Search; </td><td class="markdownTableBodyRight">128; </td><td class="markdownTableBodyRight">0.5;  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Binary Search; </td><td class="markdownTableBodyRight">128; </td><td class="markdownTableBodyRight">0.2;  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Linear Search; </td><td class="markdownTableBodyRight">256; </td><td class="markdownTableBodyRight">0.7;  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Binary Search; </td><td class="markdownTableBodyRight">256; </td><td class="markdownTableBodyRight">0.1;  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Linear Search; </td><td class="markdownTableBodyRight">384; </td><td class="markdownTableBodyRight">1.0;  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Binary Search; </td><td class="markdownTableBodyRight">384; </td><td class="markdownTableBodyRight">0.2;  </td></tr>
+<tr class="markdownTableRowEven">
+<td class="markdownTableBodyLeft">Linear Search; </td><td class="markdownTableBodyRight">512; </td><td class="markdownTableBodyRight">1.2;  </td></tr>
+<tr class="markdownTableRowOdd">
+<td class="markdownTableBodyLeft">Binary Search; </td><td class="markdownTableBodyRight">512; </td><td class="markdownTableBodyRight">0.1;  </td></tr>
+</table>
+</li>
+<li>Run the application. The output shown above for step 2 should be extended for Quick Sort and Insertion Sort with Binary Search as well as with the measurements for search algorithms as shown above.</li>
+</ol>
+<h1><a class="anchor" id="notes"></a>
+Notes</h1>
+<ol type="1">
+<li><code>general.h</code> contains macros for finding the minimum, maximum, and absolute value</li>
+<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 Wed Apr 14 2021 12:09:56 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 Wed Apr 14 2021 12:09:56 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 Wed Apr 14 2021 12:09:56 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: S07
+ * Title:			Insertion sort implementation
+ * Author:			*/<your name>;/*
+ *-----------------------------------------------------------------------------
+ * Description:
+ * Implements the insertion sort algorithm
+ *-----------------------------------------------------------------------------
+*/
+
+#include "insertion_sort.h"

insertion_sort.h

@@ -0,0 +1,39 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Insertion sort
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Implements the insertion sort algorithm
+ * ----------------------------------------------------------
+ */
+#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 algorithm.
+ * 
+ * @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 algorithm.
+ * 
+ * @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

insertion_sort_binary_search.c

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

insertion_sort_binary_search.h

@@ -0,0 +1,39 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Insertion sort implementation
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Implements the insertion sort algorithm using binary search
+ * ----------------------------------------------------------
+ */
+#ifndef ___INSERTION_SORT_BINARY_SEARCH_H
+#define ___INSERTION_SORT_BINARY_SEARCH_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 algorithm using binary.
+ * 
+ * @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_binsearch_list(<params>);
+
+/**
+ * Sorts the given array according to the insertion sort algorithm using binary search.
+ * 
+ * @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_binsearch_array(<params>);
+
+#endif

linear_search.c

@@ -0,0 +1,14 @@
+/*-----------------------------------------------------------------------------
+ *				HTBLA-Leonding
+ *-----------------------------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Linear search implementation
+ * Author:			*/<your name>;/*
+ *-----------------------------------------------------------------------------
+ * Description:
+ * Implements the linear search algorithm
+ *-----------------------------------------------------------------------------
+*/
+
+#include "linear_search.h"
+

linear_search.h

@@ -0,0 +1,43 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Linear search implementation
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Implements the linear search algorithm
+ * ----------------------------------------------------------
+ */
+#ifndef ___LINEAR_SEARCH_H
+#define ___LINEAR_SEARCH_H
+
+#include "list.h"
+
+/* NOTE: Either list or array variant is required! */
+
+/**
+ * Searches the given needle within the given haystack using linear search approach.
+ * 
+ * @param haystack The list in which the `needle` is searched.
+ * @param needle The value to find within the haystack.
+ * @return The index of the `needle` within the list or a value less than zero 
+ * if the needle was not not found.
+ */
+<type> linear_search_list(<params>);
+
+
+/* ARRAY VARIANT */
+
+/**
+ * Searches the given needle within the given haystack using binary search approach.
+ *  
+ * @param haystack The sorted list in which the `needle` is searched.
+ * @param length The length of the haystack array.
+ * @param needle The value to find within the haystack.
+ * @return The index of the `needle` within the array or a value less than zero 
+ * if the needle was not not found.
+ */
+<type> linear_search_array(<params>);
+
+#endif

list.h

@@ -0,0 +1,202 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Class: <your class>
+ * ---------------------------------------------------------
+ * Exercise Number: S07
+ * 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);
+
+/**
+ * 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);
+
+/**
+ * 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`.
+ */
+void list_append(IntList list, IntList list_to_append);
+
+/**
+ * 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);
+
+/**
+ * Splits the given `list` into a `left` and `right` part at the given `split_idx`.
+ * The `left` list contains the items of `list` from head to `split_idx - 1` rendering
+ * the size of the left part equal to `split_idx`. The `right` list contains
+ * the items of `list` from originally `split_idx` to tail.
+ * 
+ * If `split_idx` is larger than the size of `list`, all items of `list` 
+ * are moved to `left`, leaving the `right` list empty.
+ * 
+ * If a target list (`left`, `right`) is not empty, the nodes that are received from
+ * `list` are appended.
+ * 
+ * If any of the given lists is invalid, the invocation is ignored.
+ * 
+ * @param list The list to split.
+ * @param left The left part of the original list.
+ * @param right The right part of the original list.
+ * @param split_idx The index of the node of `list` that becomes the head of `right` list.
+ */
+void list_split(IntList list, IntList left, IntList right, unsigned int split_idx);
+
+/**
+ * Transfers the first node (the 'head') of the given `list` as last node ('tail') 
+ * of the target list.
+ * 
+ * If any of the given lists is invalid or the source list is empty, the invocation is ignored.
+ * 
+ * @param list The list from which the `head` is transferred to `target_list`.
+ * @param target_list The list that receives the head of `list`.
+ */
+void list_transfer_head(IntList list, IntList target_list);
+
+/**
+ * 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: S07
+ * 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,253 @@
+/**
+* @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.
+* - Implementation 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:**
+*
+* - Implementation of merge sort algorithm
+* - Extension of list as required
+*
+*
+* **Step 4:**
+*
+* - Implementation of quick sort algorithm
+* - Implementation of linear search algorithm
+* - Implementation of binary search algorithm
+* - Implementation of insertion sort algorithm using binary search
+*
+* @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 (list OR array) need to be implemented.
+*    
+* -# Implement all functions defined by the files 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_Random;| Sort_Sorted;| Sort_Reverse;|       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|
+*
+* **Step 3:**
+* -# Copy all header and source files that need to be implemented in this assignment but have been already
+*    developed in earlier steps (esp. step 2) from YOUR solution to this assignment.
+*    Do not copy unit tests!
+*    **--COMMIT--**
+* -# Based on 'array_backed_list' from step 2. 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 (list OR array) need to be implemented.
+*    
+* -# Implement all functions defined by the file below empty to make the program compile.
+*    **--COMMIT--**
+* -# `array_backed_list.c`: (list variant only)
+*     -# Implement the additional functions as defined in `list.h`
+*        - `list_append`
+*        - `list_split`
+*        - `list_transfer_head`
+*    **--COMMIT--**
+* -# `merge_sort.[h|c]`: Implement the merge sort algorithm.
+*    Run the unit tests targeting the merge sort algorithm and make them green.
+*    **--COMMIT--**
+* -# `sorting.[h|c]`: Extend the functions that delegates to different sorting algorithms to support MERGE_SORT.
+*    Run the unit tests targeting the sorting support function  and make them green.
+*    **--COMMIT--**
+* -# Run the application. The output shown above for step 2 should be extended for Merge Sort.
+* 
+* **Step 4:**
+* -# Copy all header and source files that need to be implemented in this assignment but have been already
+*    developed in earlier steps (esp. step 3) from YOUR solution to this assignment.
+*    Do not copy unit tests!
+*    **--COMMIT--**
+* -# Based on 'array_backed_list' from step 3. 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 (list OR array) need to be implemented.
+*    
+* -# Implement all functions defined by the file below empty to make the program compile.
+*    **--COMMIT--**
+* -# `quick_sort.[h|c]`: Implement the quick sort algorithm.
+*    Run the unit tests targeting the quick sort algorithm and make them green.
+*    **--COMMIT--**
+* -# `insertion_sort_binary_search.[h|c]`: Implement the insertion sort algorithm that uses binary search for finding the insert position.
+*    The insertion sort algorithm implemented in step 2 can be reused and modified.
+*    Run the unit tests targeting the insertion sort with binary search algorithm and make them green.
+*    **--COMMIT--**
+* -# `sorting.[h|c]`: Extend the functions that delegates to different sorting algorithms to support QUICK_SORT and INSERTION_SORT_BINARY_SEARCH.
+*    Run the unit tests targeting the sorting support function and make them green.
+*    **--COMMIT--**
+* -# `linear_search.[h|c]`: Implement the linear search algorithm.
+*    Run the unit tests targeting the linear search algorithm and make them green.
+*    **--COMMIT--**
+* -# `binary_search.[h|c]`: Implement the binary search algorithm.
+*    Run the unit tests targeting the binary search algorithm and make them green.
+*    **--COMMIT--**
+* -# `timed_sorting_main_driver.c`: Extend the application with measurement for search algorithms. 
+*     Organize the main application file as wanted.
+*     In addition the application shall measure the time for searching a value using linear search and binary search within 
+*     a long (> 16k items) list or array. The time for searching every Xth item that is contained in the list or array shall
+*     be measured for each search algorithm, X may be ~100.
+*
+*     **Note:** Especially for binary search, measuring one search execution may result in values beyond measurable range.
+*               Therefore the time measurement of a single item shall invoke the search function Y times (Y >= 10).
+*               The accumulated measured result need them be divided by Y (time = measured_time/Y).
+*
+*     The print-out for these measurements may look like:
+* | Algorithm;     |   Index;| Time;|
+* |:---------------|--------:|-----:|
+* | Bubble Sort;   |       1;|  1.0;|
+* | Linear Search; |       0;|  0.1;|
+* | Binary Search; |       0;|  0.1;|
+* | Linear Search; |     128;|  0.5;|
+* | Binary Search; |     128;|  0.2;|
+* | Linear Search; |     256;|  0.7;|
+* | Binary Search; |     256;|  0.1;|
+* | Linear Search; |     384;|  1.0;|
+* | Binary Search; |     384;|  0.2;|
+* | Linear Search; |     512;|  1.2;|
+* | Binary Search; |     512;|  0.1;|
+*
+* -# Run the application. The output shown above for step 2 should be extended for Quick Sort and Insertion Sort with Binary Search
+*    as well as with the measurements for search algorithms as shown above.
+* 
+*
+* @section notes Notes
+* -# `general.h` contains macros for finding the minimum, maximum, and absolute value 
+* -# 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,103 @@
+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 merge_sort quick_sort insertion_sort_binary_search \
+				   linear_search binary_search
+TEST_FILES       = test_list test_stopwatch test_sorting_criteria test_sorting test_sorting_algorithms \
+                   test_bubble_sort test_insertion_sort test_merge_sort test_quick_sort test_insertion_sort_binary_search \
+				   test_linear_search test_binary_search
+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

merge_sort.c

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

merge_sort.h

@@ -0,0 +1,39 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Insertion sort implementation
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Implements the merge sort algorithm
+ * ----------------------------------------------------------
+ */
+#ifndef ___MERGE_SORT_H
+#define ___MERGE_SORT_H
+
+#include "list.h"
+#include "sorting_criteria.h"
+
+/* NOTE: Either list or array variant is required! */
+
+/**
+ * Sorts the given list according to the merge sort algorithm.
+ * 
+ * @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 merge_sort_list(<params>);
+
+/**
+ * Sorts the given array according to the merge sort algorithm.
+ * 
+ * @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 merge_sort_array(<params>);
+
+#endif

quick_sort.c

@@ -0,0 +1,13 @@
+/*-----------------------------------------------------------------------------
+ *				HTBLA-Leonding
+ *-----------------------------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Quick sort implementation
+ * Author:			*/<your name>;/*
+ *-----------------------------------------------------------------------------
+ * Description:
+ * Implements the quick sort algorithm
+ *-----------------------------------------------------------------------------
+*/
+
+#include "quick_sort.h"

quick_sort.h

@@ -0,0 +1,39 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Quick sort
+ * Author:			*/<your name>;/*
+ * ----------------------------------------------------------
+ * Description:
+ * Implements the quick sort algorithm
+ * ----------------------------------------------------------
+ */
+#ifndef ___QUICK_SORT_H
+#define ___QUICK_SORT_H
+
+#include "list.h"
+#include "sorting_criteria.h"
+
+/* NOTE: Either list or array variant is required! */
+
+/**
+ * Sorts the given list according to the quick sort algorithm.
+ * 
+ * @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 quick_sort_list(<params>);
+
+/**
+ * Sorts the given array according to the quick sort algorithm.
+ * 
+ * @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 quick_sort_array(<params>);
+
+#endif

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,27 @@
+/*-----------------------------------------------------------------------------
+ *				HTBLA-Leonding / Class: <your class name here>
+ *-----------------------------------------------------------------------------
+ * Exercise Number: S07
+ * Title:			Sorting support functions
+ * Author:			*/<your name>;/*
+ *-----------------------------------------------------------------------------
+ * Description:
+ * Basic support functions for sorting
+ *-----------------------------------------------------------------------------
+*/
+#include "sorting.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,101 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding
+ * ---------------------------------------------------------
+ * Exercise Number: S07
+ * 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,
+    MERGE_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: S07
+ * 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: S07
+ * 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: S07
+ * 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: S07
+ * 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_binary_search.c

@@ -0,0 +1,240 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for binary search functions
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Teests functions for binary search.
+ * ----------------------------------------------------------
+ */
+
+#include "test_binary_search.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "shortcut.h"
+#include "config.h"
+
+#include "binary_search.h"
+
+#ifdef LIST_VARIANT
+
+#define ASSERT_FIND_IN_LIST(list_size, search_limit, search_val_idx, multiple) _assert_find_in_list(tc, list_size, search_limit, search_val_idx, multiple)
+static void _assert_find_in_list(struct TestCase* tc, int list_size, int search_limit, int search_val_idx, bool multiple) {
+    IntList list = list_obtain();
+    ASSERT_TRUE(list_is_valid(list), MSG("Expected valid list"));
+    for (int i = 1; i <= list_size; i++) {
+        list_insert(list, i * 10);
+        if (multiple) {
+            list_insert(list, i * 10);
+        }
+    }
+
+    search_limit *= (multiple ? 2 : 1);
+    search_val_idx *= (multiple ? 2 : 1);
+    int search_val = list_get_at(list, (search_val_idx < 0 ? search_val_idx * -1 : search_val_idx));
+    if (search_val_idx < 0) {
+        search_val--;
+    }
+    int res_idx = (search_limit < list_get_size(list)) 
+            ? binary_search_list(list, &is_in_asc_order, search_val) 
+            : binary_search_list_limited(list, search_limit, &is_in_asc_order, search_val);
+
+    if (multiple) {
+        if (search_val_idx < 0) {
+            ASSERT_TRUE(res_idx == search_val_idx, MSG("Expected item %d @ index %d but was %d", search_val, search_val_idx, res_idx));
+        } else {
+            ASSERT_TRUE(res_idx == search_val_idx || res_idx == search_val_idx + 1, MSG("Expected item %d @ index %d or %d but was %d", search_val, search_val_idx, search_val_idx + 1, res_idx));
+        }
+    } else {
+        ASSERT_TRUE(res_idx == search_val_idx, MSG("Expected item %d @ index %d but was %d", search_val, search_val_idx, res_idx));
+    }
+    list_release(&list);
+}
+
+#else /* ARRAY VARIANT */
+
+
+#define ASSERT_FIND_IN_ARRAY(array_size, search_val_idx, multiple) _assert_find_in_array(tc, array_size, search_val_idx, multiple)
+static void _assert_find_in_array(struct TestCase* tc, int array_size, int search_val_idx, bool multiple) {
+    int size = array_size * (multiple ? 2 : 1);
+    int array[size];
+    for (int i = 0; i < size; i++) {
+        array[i] = (i + 1) * 10;
+        if (multiple) {
+            i++;
+            array[i] = i * 10;
+        }
+    }
+
+    search_val_idx *= (multiple ? 2 : 1);
+    int search_val = array[(search_val_idx < 0 ? search_val_idx * -1 : search_val_idx)];
+    if (search_val_idx < 0) {
+        search_val--;
+    }
+    int res_idx = binary_search_array(array, size, &is_in_asc_order, search_val);
+
+    if (multiple) {
+        if (search_val_idx < 0) {
+            ASSERT_TRUE(res_idx == search_val_idx, MSG("Expected item %d @ index %d but was %d", search_val, search_val_idx, res_idx));
+        } else {
+            ASSERT_TRUE(res_idx == search_val_idx || res_idx == search_val_idx + 1, MSG("Expected item %d @ index %d or %d but was %d", search_val, search_val_idx, search_val_idx + 1, res_idx));
+        }
+    } else {
+        ASSERT_TRUE(res_idx == search_val_idx, MSG("Expected item %d @ index %d but was %d", search_val, search_val_idx, res_idx));
+    }
+}
+#endif
+
+
+#ifdef LIST_VARIANT
+
+
+TEST(test_binary_search_list__shall_find_first_item) {
+    ASSERT_FIND_IN_LIST(16, 16, 0, false);
+}
+
+TEST(test_binary_search_list__shall_find_middle_item) {
+    ASSERT_FIND_IN_LIST(16, 16, 8, false);
+}
+
+TEST(test_binary_search_list__shall_find_last_item) {
+    ASSERT_FIND_IN_LIST(16, 16, 15, false);
+}
+
+TEST(test_binary_search_list__shall_find_first_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 16, 0, true);
+}
+
+TEST(test_binary_search_list__shall_find_middle_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 16, 8, true);
+}
+
+TEST(test_binary_search_list__shall_find_last_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 16, 15, true);
+}
+
+TEST(test_binary_search_list__shall_find_slot_at_beginning){
+    ASSERT_FIND_IN_LIST(16, 16, -1, false);
+}
+
+TEST(test_binary_search_list__shall_find_slot_in_the_middle){
+    ASSERT_FIND_IN_LIST(16, 16, -7, false);
+}
+
+TEST(test_binary_search_list__shall_find_slot_at_the_end){
+    ASSERT_FIND_IN_LIST(16, 16, -15, false);
+}
+TEST(test_binary_search_list__shall_find_slot_at_beginning_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 16, -1, true);
+}
+
+TEST(test_binary_search_list__shall_find_slot_in_the_middle_in_ambiguous_values){
+    ASSERT_FIND_IN_LIST(16, 16, -8, true);
+}
+
+TEST(test_binary_search_list__shall_find_slot_at_the_end_in_ambiguous_values){
+    ASSERT_FIND_IN_LIST(16, 16, -15, true);
+}
+
+TEST(test_binary_search_list_limited__shall_find_first_item) {
+    ASSERT_FIND_IN_LIST(16, 10, 0, false);
+}
+
+TEST(test_binary_search_list_limited__shall_find_middle_item) {
+    ASSERT_FIND_IN_LIST(16, 10, 5, false);
+}
+
+TEST(test_binary_search_list_limited__shall_find_last_item) {
+    ASSERT_FIND_IN_LIST(16, 10, 9, false);
+}
+
+TEST(test_binary_search_list_limited__shall_find_first_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 10, 0, true);
+}
+
+TEST(test_binary_search_list_limited__shall_find_middle_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 10, 5, true);
+}
+
+TEST(test_binary_search_list_limited__shall_find_last_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 10, 9, true);
+}
+
+TEST(test_binary_search_list_limited__shall_find_slot_at_beginning){
+    ASSERT_FIND_IN_LIST(16, 10, -1, false);
+}
+
+TEST(test_binary_search_list_limited__shall_find_slot_in_the_middle){
+    ASSERT_FIND_IN_LIST(16, 10, -5, false);
+}
+
+TEST(test_binary_search_list_limited__shall_find_slot_at_the_end){
+    ASSERT_FIND_IN_LIST(16, 10, -9, false);
+}
+
+TEST(test_binary_search_list_limited__shall_find_slot_at_beginning_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 10, -1, true);
+}
+
+TEST(test_binary_search_list_limited__shall_find_slot_in_the_middle_in_ambiguous_values){
+    ASSERT_FIND_IN_LIST(16, 10, -5, true);
+}
+
+TEST(test_binary_search_list_limited__shall_find_slot_at_the_end_in_ambiguous_values){
+    ASSERT_FIND_IN_LIST(16, 10, -9, true);
+}
+
+#else 
+
+TEST(test_binary_search_array__shall_find_first_item) {
+    ASSERT_FIND_IN_ARRAY(16, 0, false);
+}
+
+TEST(test_binary_search_array__shall_find_middle_item) {
+    ASSERT_FIND_IN_ARRAY(16, 8, false);
+}
+
+TEST(test_binary_search_array__shall_find_last_item) {
+    ASSERT_FIND_IN_ARRAY(16, 15, false);
+}
+
+TEST(test_binary_search_array__shall_find_first_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_ARRAY(16, 0, true);
+}
+
+TEST(test_binary_search_array__shall_find_middle_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_ARRAY(16, 8, true);
+}
+
+TEST(test_binary_search_array__shall_find_last_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_ARRAY(16, 15, true);
+}
+
+TEST(test_binary_search_array__shall_find_slot_at_beginning){
+    ASSERT_FIND_IN_ARRAY(16, -1, false);
+}
+
+TEST(test_binary_search_array__shall_find_slot_in_the_middle){
+    ASSERT_FIND_IN_ARRAY(16, -7, false);
+}
+
+TEST(test_binary_search_array__shall_find_slot_at_the_end){
+    ASSERT_FIND_IN_ARRAY(16, -15, false);
+}
+
+TEST(test_binary_search_array__shall_find_slot_at_beginning_in_ambiguous_values) {
+    ASSERT_FIND_IN_ARRAY(16, -1, true);
+}
+
+TEST(test_binary_search_array__shall_find_slot_in_the_middle_in_ambiguous_values){
+    ASSERT_FIND_IN_ARRAY(16, -8, true);
+}
+
+TEST(test_binary_search_array__shall_find_slot_at_the_end_in_ambiguous_values){
+    ASSERT_FIND_IN_ARRAY(16, -15, true);
+}
+
+#endif

test_binary_search.h

@@ -0,0 +1,63 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for binary search functions
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for binary search.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_BINARY_SEARCH_H
+#define ___TEST_BINARY_SEARCH_H
+
+#include "shortcut.h"
+#include "config.h"
+
+#ifdef LIST_VARIANT
+
+TEST(test_binary_search_list__shall_find_first_item);
+TEST(test_binary_search_list__shall_find_middle_item);
+TEST(test_binary_search_list__shall_find_last_item);
+TEST(test_binary_search_list__shall_find_first_item_in_ambiguous_values);
+TEST(test_binary_search_list__shall_find_middle_item_in_ambiguous_values);
+TEST(test_binary_search_list__shall_find_last_item_in_ambiguous_values);
+TEST(test_binary_search_list__shall_find_slot_at_beginning);
+TEST(test_binary_search_list__shall_find_slot_in_the_middle);
+TEST(test_binary_search_list__shall_find_slot_at_the_end);
+TEST(test_binary_search_list__shall_find_slot_at_beginning_in_ambiguous_values);
+TEST(test_binary_search_list__shall_find_slot_in_the_middle_in_ambiguous_values);
+TEST(test_binary_search_list__shall_find_slot_at_the_end_in_ambiguous_values);
+
+TEST(test_binary_search_list_limited__shall_find_first_item);
+TEST(test_binary_search_list_limited__shall_find_middle_item);
+TEST(test_binary_search_list_limited__shall_find_last_item);
+TEST(test_binary_search_list_limited__shall_find_first_item_in_ambiguous_values);
+TEST(test_binary_search_list_limited__shall_find_middle_item_in_ambiguous_values);
+TEST(test_binary_search_list_limited__shall_find_last_item_in_ambiguous_values);
+TEST(test_binary_search_list_limited__shall_find_slot_at_beginning);
+TEST(test_binary_search_list_limited__shall_find_slot_in_the_middle);
+TEST(test_binary_search_list_limited__shall_find_slot_at_the_end);
+TEST(test_binary_search_list_limited__shall_find_slot_at_beginning_in_ambiguous_values);
+TEST(test_binary_search_list_limited__shall_find_slot_in_the_middle_in_ambiguous_values);
+TEST(test_binary_search_list_limited__shall_find_slot_at_the_end_in_ambiguous_values);
+
+#else 
+
+TEST(test_binary_search_array__shall_find_first_item);
+TEST(test_binary_search_array__shall_find_middle_item);
+TEST(test_binary_search_array__shall_find_last_item);
+TEST(test_binary_search_array__shall_find_first_item_in_ambiguous_values);
+TEST(test_binary_search_array__shall_find_middle_item_in_ambiguous_values);
+TEST(test_binary_search_array__shall_find_last_item_in_ambiguous_values);
+
+TEST(test_binary_search_array__shall_find_slot_at_beginning);
+TEST(test_binary_search_array__shall_find_slot_in_the_middle);
+TEST(test_binary_search_array__shall_find_slot_at_the_end);
+TEST(test_binary_search_array__shall_find_slot_at_beginning_in_ambiguous_values);
+TEST(test_binary_search_array__shall_find_slot_in_the_middle_in_ambiguous_values);
+TEST(test_binary_search_array__shall_find_slot_at_the_end_in_ambiguous_values);
+
+#endif
+
+#endif

test_bubble_sort.c

@@ -0,0 +1,72 @@
+/*----------------------------------------------------------
+ *				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 "bubble_sort.h"
+#include "test_sorting_algorithms.h"
+
+
+#ifdef LIST_VARIANT
+
+TEST(test_bubble_sort_ascending) {
+    ASSERT_SORTED_LIST_ASCENDING_PLAIN(&bubble_sort_list);
+}
+
+TEST(test_bubble_sort_descending) {
+    ASSERT_SORTED_LIST_DESCENDING_PLAIN(&bubble_sort_list);
+}
+
+TEST(test_bubble_sort_ascending_multiple) {
+    ASSERT_SORTED_LIST_ASCENDING_MULTIPLE(&bubble_sort_list);
+}
+
+TEST(test_bubble_sort_descending_multiple) {
+    ASSERT_SORTED_LIST_DESCENDING_MULTIPLE(&bubble_sort_list);
+}
+
+TEST(test_bubble_sort_ascending_reverse) {
+    ASSERT_SORTED_LIST_ASCENDING_REVERSE(&bubble_sort_list);
+}
+
+TEST(test_bubble_sort_descending_reverse) {
+    ASSERT_SORTED_LIST_DESCENDING_REVERSE(&bubble_sort_list);
+}
+
+
+#else /* ARRAY VARIANT */
+
+
+TEST(test_bubble_sort_ascending) {
+    ASSERT_SORTED_ARRAY_ASCENDING_PLAIN(&bubble_sort_array);
+}
+
+TEST(test_bubble_sort_descending) {
+    ASSERT_SORTED_ARRAY_DESCENDING_PLAIN(&bubble_sort_array);
+}
+
+TEST(test_bubble_sort_ascending_multiple) {
+    ASSERT_SORTED_ARRAY_ASCENDING_MULTIPLE(&bubble_sort_array);
+}
+
+TEST(test_bubble_sort_descending_multiple) {
+    ASSERT_SORTED_ARRAY_DESCENDING_MULTIPLE(&bubble_sort_array);
+}
+
+TEST(test_bubble_sort_ascending_reverse) {
+    ASSERT_SORTED_ARRAY_ASCENDING_REVERSE(&bubble_sort_array);
+}
+
+TEST(test_bubble_sort_descending_reverse) {
+    ASSERT_SORTED_ARRAY_DESCENDING_REVERSE(&bubble_sort_array);
+}
+
+#endif

test_bubble_sort.h

@@ -0,0 +1,24 @@
+/*----------------------------------------------------------
+ *				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"
+
+TEST(test_bubble_sort_ascending);
+TEST(test_bubble_sort_descending);
+TEST(test_bubble_sort_ascending_multiple);
+TEST(test_bubble_sort_descending_multiple);
+TEST(test_bubble_sort_ascending_reverse);
+TEST(test_bubble_sort_descending_reverse); 
+
+#endif

test_insertion_sort.c

@@ -0,0 +1,72 @@
+/*----------------------------------------------------------
+ *				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 "insertion_sort.h"
+#include "test_sorting_algorithms.h"
+
+
+#ifdef LIST_VARIANT
+
+TEST(test_insertion_sort_ascending) {
+    ASSERT_SORTED_LIST_ASCENDING_PLAIN(&insertion_sort_list);
+}
+
+TEST(test_insertion_sort_descending) {
+    ASSERT_SORTED_LIST_DESCENDING_PLAIN(&insertion_sort_list);
+}
+
+TEST(test_insertion_sort_ascending_multiple) {
+    ASSERT_SORTED_LIST_ASCENDING_MULTIPLE(&insertion_sort_list);
+}
+
+TEST(test_insertion_sort_descending_multiple) {
+    ASSERT_SORTED_LIST_DESCENDING_MULTIPLE(&insertion_sort_list);
+}
+
+TEST(test_insertion_sort_ascending_reverse) {
+    ASSERT_SORTED_LIST_ASCENDING_REVERSE(&insertion_sort_list);
+}
+
+TEST(test_insertion_sort_descending_reverse) {
+    ASSERT_SORTED_LIST_DESCENDING_REVERSE(&insertion_sort_list);
+}
+
+
+#else /* ARRAY VARIANT */
+
+
+TEST(test_insertion_sort_ascending) {
+    ASSERT_SORTED_ARRAY_ASCENDING_PLAIN(&insertion_sort_array);
+}
+
+TEST(test_insertion_sort_descending) {
+    ASSERT_SORTED_ARRAY_DESCENDING_PLAIN(&insertion_sort_array);
+}
+
+TEST(test_insertion_sort_ascending_multiple) {
+    ASSERT_SORTED_ARRAY_ASCENDING_MULTIPLE(&insertion_sort_array);
+}
+
+TEST(test_insertion_sort_descending_multiple) {
+    ASSERT_SORTED_ARRAY_DESCENDING_MULTIPLE(&insertion_sort_array);
+}
+
+TEST(test_insertion_sort_ascending_reverse) {
+    ASSERT_SORTED_ARRAY_ASCENDING_REVERSE(&insertion_sort_array);
+}
+
+TEST(test_insertion_sort_descending_reverse) {
+    ASSERT_SORTED_ARRAY_DESCENDING_REVERSE(&insertion_sort_array);
+}
+
+#endif

test_insertion_sort.h

@@ -0,0 +1,24 @@
+/*----------------------------------------------------------
+ *				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"
+
+TEST(test_insertion_sort_ascending);
+TEST(test_insertion_sort_descending);
+TEST(test_insertion_sort_ascending_multiple);
+TEST(test_insertion_sort_descending_multiple);
+TEST(test_insertion_sort_ascending_reverse);
+TEST(test_insertion_sort_descending_reverse); 
+
+#endif

test_insertion_sort_binary_search.c

@@ -0,0 +1,72 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Implementation of UTs for insertion sort with binary search
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for insertion sort using binary search.
+ * ----------------------------------------------------------
+ */
+
+#include "test_insertion_sort_binary_search.h"
+
+#include "insertion_sort_binary_search.h"
+#include "test_sorting_algorithms.h"
+
+
+#ifdef LIST_VARIANT
+
+TEST(test_insertion_sort_binsearch_ascending) {
+    ASSERT_SORTED_LIST_ASCENDING_PLAIN(&insertion_sort_binsearch_list);
+}
+
+TEST(test_insertion_sort_binsearch_descending) {
+    ASSERT_SORTED_LIST_DESCENDING_PLAIN(&insertion_sort_binsearch_list);
+}
+
+TEST(test_insertion_sort_binsearch_ascending_multiple) {
+    ASSERT_SORTED_LIST_ASCENDING_MULTIPLE(&insertion_sort_binsearch_list);
+}
+
+TEST(test_insertion_sort_binsearch_descending_multiple) {
+    ASSERT_SORTED_LIST_DESCENDING_MULTIPLE(&insertion_sort_binsearch_list);
+}
+
+TEST(test_insertion_sort_binsearch_ascending_reverse) {
+    ASSERT_SORTED_LIST_ASCENDING_REVERSE(&insertion_sort_binsearch_list);
+}
+
+TEST(test_insertion_sort_binsearch_descending_reverse) {
+    ASSERT_SORTED_LIST_DESCENDING_REVERSE(&insertion_sort_binsearch_list);
+}
+
+
+#else /* ARRAY VARIANT */
+
+
+TEST(test_insertion_sort_binsearch_ascending) {
+    ASSERT_SORTED_ARRAY_ASCENDING_PLAIN(&insertion_sort_binsearch_array);
+}
+
+TEST(test_insertion_sort_binsearch_descending) {
+    ASSERT_SORTED_ARRAY_DESCENDING_PLAIN(&insertion_sort_binsearch_array);
+}
+
+TEST(test_insertion_sort_binsearch_ascending_multiple) {
+    ASSERT_SORTED_ARRAY_ASCENDING_MULTIPLE(&insertion_sort_binsearch_array);
+}
+
+TEST(test_insertion_sort_binsearch_descending_multiple) {
+    ASSERT_SORTED_ARRAY_DESCENDING_MULTIPLE(&insertion_sort_binsearch_array);
+}
+
+TEST(test_insertion_sort_binsearch_ascending_reverse) {
+    ASSERT_SORTED_ARRAY_ASCENDING_REVERSE(&insertion_sort_binsearch_array);
+}
+
+TEST(test_insertion_sort_binsearch_descending_reverse) {
+    ASSERT_SORTED_ARRAY_DESCENDING_REVERSE(&insertion_sort_binsearch_array);
+}
+
+#endif

test_insertion_sort_binary_search.h

@@ -0,0 +1,24 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for insertion sort with binary search
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for insertion sort with binary search.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_INSERTION_SORT_BINARY_SEARCH_H
+#define ___TEST_INSERTION_SORT_BINARY_SEARCH_H
+
+#include "shortcut.h"
+#include "config.h"
+
+TEST(test_insertion_sort_binsearch_ascending);
+TEST(test_insertion_sort_binsearch_descending);
+TEST(test_insertion_sort_binsearch_ascending_multiple);
+TEST(test_insertion_sort_binsearch_descending_multiple);
+TEST(test_insertion_sort_binsearch_ascending_reverse);
+TEST(test_insertion_sort_binsearch_descending_reverse); 
+
+#endif

test_linear_search.c

@@ -0,0 +1,162 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for linear search functions
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for linear search.
+ * ----------------------------------------------------------
+ */
+
+#include "test_linear_search.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#include "shortcut.h"
+#include "config.h"
+
+#include "linear_search.h"
+
+#ifdef LIST_VARIANT
+
+#define ASSERT_FIND_IN_LIST(list_size, search_val_idx, multiple) _assert_find_in_list(tc, list_size, search_val_idx, multiple)
+static void _assert_find_in_list(struct TestCase* tc, int list_size, int search_val_idx, bool multiple) {
+    IntList list = list_obtain();
+    ASSERT_TRUE(list_is_valid(list), MSG("Expected valid list"));
+    for (int i = 1; i <= list_size; i++) {
+        list_insert(list, i * 10);
+        if (multiple) {
+            list_insert(list, i * 10);
+        }
+    }
+
+    search_val_idx *= (multiple ? 2 : 1);
+    int search_val = list_get_at(list, (search_val_idx < 0 ? search_val_idx * -1 : search_val_idx));
+    if (search_val_idx < 0) {
+        search_val--;
+    }
+    int res_idx = linear_search_list(list, search_val);
+
+    if (search_val_idx < 0) {
+        ASSERT_TRUE(res_idx < 0, MSG("Expected item %d not found but got index %d", search_val, res_idx));
+    } else {
+        ASSERT_TRUE(res_idx == search_val_idx, MSG("Expected item %d @ index %d but was %d", search_val, search_val_idx, res_idx));
+    }
+    list_release(&list);
+}
+
+#else /* ARRAY VARIANT */
+
+#define ASSERT_FIND_IN_ARRAY(array_size, search_val_idx, multiple) _assert_find_in_array(tc, array_size, search_val_idx, multiple)
+static void _assert_find_in_array(struct TestCase* tc, int array_size, int search_val_idx, bool multiple) {
+    int size = array_size * (multiple ? 2 : 1);
+    int array[size];
+    for (int i = 0; i < size; i++) {
+        array[i] = (i + 1) * 10;
+        if (multiple) {
+            i++;
+            array[i] = i * 10;
+        }
+    }
+
+    search_val_idx *= (multiple ? 2 : 1);
+    int search_val = array[(search_val_idx < 0 ? search_val_idx * -1 : search_val_idx)];
+    if (search_val_idx < 0) {
+        search_val--;
+    }
+    int res_idx = linear_search_array(array, size, search_val);
+
+    if (search_val_idx < 0) {
+        ASSERT_TRUE(res_idx < 0, MSG("Expected item %d not found but got index %d", search_val, res_idx));
+    } else {
+        ASSERT_TRUE(res_idx == search_val_idx, MSG("Expected item %d @ index %d but was %d", search_val, search_val_idx, res_idx));
+    }
+}
+#endif
+
+#ifdef LIST_VARIANT
+
+TEST(test_linear_search_list__shall_find_first_item);
+TEST(test_linear_search_list__shall_find_middle_item);
+TEST(test_linear_search_list__shall_find_last_item);
+TEST(test_linear_search_list__shall_find_first_item_in_ambiguous_values);
+TEST(test_linear_search_list__shall_find_middle_item_in_ambiguous_values);
+TEST(test_linear_search_list__shall_find_last_item_in_ambiguous_values);
+TEST(test_linear_search_list__shall_not_find_missing_value);
+
+#else 
+
+TEST(test_linear_search_array__shall_find_first_item);
+TEST(test_linear_search_array__shall_find_middle_item);
+TEST(test_linear_search_array__shall_find_last_item);
+TEST(test_linear_search_array__shall_find_first_item_in_ambiguous_values);
+TEST(test_linear_search_array__shall_find_middle_item_in_ambiguous_values);
+TEST(test_linear_search_array__shall_find_last_item_in_ambiguous_values);
+TEST(test_linear_search_array__shall_not_find_missing_value);
+
+#endif
+
+#ifdef LIST_VARIANT
+
+
+TEST(test_linear_search_list__shall_find_first_item) {
+    ASSERT_FIND_IN_LIST(16, 0, false);
+}
+
+TEST(test_linear_search_list__shall_find_middle_item) {
+    ASSERT_FIND_IN_LIST(16, 8, false);
+}
+
+TEST(test_linear_search_list__shall_find_last_item) {
+    ASSERT_FIND_IN_LIST(16, 15, false);
+}
+
+TEST(test_linear_search_list__shall_find_first_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 0, true);
+}
+
+TEST(test_linear_search_list__shall_find_middle_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 8, true);
+}
+
+TEST(test_linear_search_list__shall_find_last_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_LIST(16, 15, true);
+}
+
+TEST(test_linear_search_list__shall_not_find_missing_value){
+    ASSERT_FIND_IN_LIST(16, -1, false);
+}
+
+#else 
+
+TEST(test_linear_search_array__shall_find_first_item) {
+    ASSERT_FIND_IN_ARRAY(16, 0, false);
+}
+
+TEST(test_linear_search_array__shall_find_middle_item) {
+    ASSERT_FIND_IN_ARRAY(16, 8, false);
+}
+
+TEST(test_linear_search_array__shall_find_last_item) {
+    ASSERT_FIND_IN_ARRAY(16, 15, false);
+}
+
+TEST(test_linear_search_array__shall_find_first_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_ARRAY(16, 0, true);
+}
+
+TEST(test_linear_search_array__shall_find_middle_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_ARRAY(16, 8, true);
+}
+
+TEST(test_linear_search_array__shall_find_last_item_in_ambiguous_values) {
+    ASSERT_FIND_IN_ARRAY(16, 15, true);
+}
+
+TEST(test_linear_search_array__shall_not_find_missing_value){
+    ASSERT_FIND_IN_ARRAY(16, -1, false);
+}
+
+#endif

test_linear_search.h

@@ -0,0 +1,39 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for linear search functions
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for linear search.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_LINEAR_SEARCH_H
+#define ___TEST_LINEAR_SEARCH_H
+
+#include "shortcut.h"
+#include "config.h"
+
+#ifdef LIST_VARIANT
+
+TEST(test_linear_search_list__shall_find_first_item);
+TEST(test_linear_search_list__shall_find_middle_item);
+TEST(test_linear_search_list__shall_find_last_item);
+TEST(test_linear_search_list__shall_find_first_item_in_ambiguous_values);
+TEST(test_linear_search_list__shall_find_middle_item_in_ambiguous_values);
+TEST(test_linear_search_list__shall_find_last_item_in_ambiguous_values);
+TEST(test_linear_search_list__shall_not_find_missing_value);
+
+#else 
+
+TEST(test_linear_search_array__shall_find_first_item);
+TEST(test_linear_search_array__shall_find_middle_item);
+TEST(test_linear_search_array__shall_find_last_item);
+TEST(test_linear_search_array__shall_find_first_item_in_ambiguous_values);
+TEST(test_linear_search_array__shall_find_middle_item_in_ambiguous_values);
+TEST(test_linear_search_array__shall_find_last_item_in_ambiguous_values);
+TEST(test_linear_search_array__shall_not_find_missing_value);
+
+#endif
+
+#endif

test_list.h

@@ -0,0 +1,119 @@
+/*----------------------------------------------------------
+ *				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);
+
+TEST(test_list_append__shall_append_empty_list_to_empty_list);
+TEST(test_list_append__shall_append_filled_list_to_empty_list);
+TEST(test_list_append__shall_append_empty_list_to_filled_list);
+TEST(test_list_append__shall_append_filled_list_to_filled_list);
+TEST(test_list_append__shall_ignore_invalid_lists);
+
+TEST(test_list_split__shall_split_empty_list);
+TEST(test_list_split__shall_split_list_with_one_item_at_left);
+TEST(test_list_split__shall_split_list_with_one_item_at_right);
+TEST(test_list_split__shall_split_list_in_the_middle);
+TEST(test_list_split__shall_split_list_at_size);
+TEST(test_list_split__shall_ignore_invalid_lists);
+
+TEST(test_list_transfer_head__shall_transfer_from_empty_list);
+TEST(test_list_transfer_head__shall_transfer_the_only_item);
+TEST(test_list_transfer_head__shall_transfer_one_item);
+TEST(test_list_transfer_head__shall_transfer_multiple_items_one_by_one);
+TEST(test_list_transfer_head__shall_ignore_invalid_lists);
+
+#endif

test_merge_sort.c

@@ -0,0 +1,72 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Implementation of UTs for merge sort
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for merge sort.
+ * ----------------------------------------------------------
+ */
+
+#include "test_merge_sort.h"
+
+#include "merge_sort.h"
+#include "test_sorting_algorithms.h"
+
+
+#ifdef LIST_VARIANT
+
+TEST(test_merge_sort_ascending) {
+    ASSERT_SORTED_LIST_ASCENDING_PLAIN(&merge_sort_list);
+}
+
+TEST(test_merge_sort_descending) {
+    ASSERT_SORTED_LIST_DESCENDING_PLAIN(&merge_sort_list);
+}
+
+TEST(test_merge_sort_ascending_multiple) {
+    ASSERT_SORTED_LIST_ASCENDING_MULTIPLE(&merge_sort_list);
+}
+
+TEST(test_merge_sort_descending_multiple) {
+    ASSERT_SORTED_LIST_DESCENDING_MULTIPLE(&merge_sort_list);
+}
+
+TEST(test_merge_sort_ascending_reverse) {
+    ASSERT_SORTED_LIST_ASCENDING_REVERSE(&merge_sort_list);
+}
+
+TEST(test_merge_sort_descending_reverse) {
+    ASSERT_SORTED_LIST_DESCENDING_REVERSE(&merge_sort_list);
+}
+
+
+#else /* ARRAY VARIANT */
+
+
+TEST(test_merge_sort_ascending) {
+    ASSERT_SORTED_ARRAY_ASCENDING_PLAIN(&merge_sort_array);
+}
+
+TEST(test_merge_sort_descending) {
+    ASSERT_SORTED_ARRAY_DESCENDING_PLAIN(&merge_sort_array);
+}
+
+TEST(test_merge_sort_ascending_multiple) {
+    ASSERT_SORTED_ARRAY_ASCENDING_MULTIPLE(&merge_sort_array);
+}
+
+TEST(test_merge_sort_descending_multiple) {
+    ASSERT_SORTED_ARRAY_DESCENDING_MULTIPLE(&merge_sort_array);
+}
+
+TEST(test_merge_sort_ascending_reverse) {
+    ASSERT_SORTED_ARRAY_ASCENDING_REVERSE(&merge_sort_array);
+}
+
+TEST(test_merge_sort_descending_reverse) {
+    ASSERT_SORTED_ARRAY_DESCENDING_REVERSE(&merge_sort_array);
+}
+
+#endif

test_merge_sort.h

@@ -0,0 +1,24 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for merge sort
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for merge sort.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_MERGE_SORT_H
+#define ___TEST_MERGE_SORT_H
+
+#include "shortcut.h"
+#include "config.h"
+
+TEST(test_merge_sort_ascending);
+TEST(test_merge_sort_descending);
+TEST(test_merge_sort_ascending_multiple);
+TEST(test_merge_sort_descending_multiple);
+TEST(test_merge_sort_ascending_reverse);
+TEST(test_merge_sort_descending_reverse); 
+
+#endif

test_quick_sort.c

@@ -0,0 +1,72 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Implementation of UTs for quick sort
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for quick sort.
+ * ----------------------------------------------------------
+ */
+
+#include "test_quick_sort.h"
+
+#include "quick_sort.h"
+#include "test_sorting_algorithms.h"
+
+
+#ifdef LIST_VARIANT
+
+TEST(test_quick_sort_ascending) {
+    ASSERT_SORTED_LIST_ASCENDING_PLAIN(&quick_sort_list);
+}
+
+TEST(test_quick_sort_descending) {
+    ASSERT_SORTED_LIST_DESCENDING_PLAIN(&quick_sort_list);
+}
+
+TEST(test_quick_sort_ascending_multiple) {
+    ASSERT_SORTED_LIST_ASCENDING_MULTIPLE(&quick_sort_list);
+}
+
+TEST(test_quick_sort_descending_multiple) {
+    ASSERT_SORTED_LIST_DESCENDING_MULTIPLE(&quick_sort_list);
+}
+
+TEST(test_quick_sort_ascending_reverse) {
+    ASSERT_SORTED_LIST_ASCENDING_REVERSE(&quick_sort_list);
+}
+
+TEST(test_quick_sort_descending_reverse) {
+    ASSERT_SORTED_LIST_DESCENDING_REVERSE(&quick_sort_list);
+}
+
+
+#else /* ARRAY VARIANT */
+
+
+TEST(test_quick_sort_ascending) {
+    ASSERT_SORTED_ARRAY_ASCENDING_PLAIN(&quick_sort_array);
+}
+
+TEST(test_quick_sort_descending) {
+    ASSERT_SORTED_ARRAY_DESCENDING_PLAIN(&quick_sort_array);
+}
+
+TEST(test_quick_sort_ascending_multiple) {
+    ASSERT_SORTED_ARRAY_ASCENDING_MULTIPLE(&quick_sort_array);
+}
+
+TEST(test_quick_sort_descending_multiple) {
+    ASSERT_SORTED_ARRAY_DESCENDING_MULTIPLE(&quick_sort_array);
+}
+
+TEST(test_quick_sort_ascending_reverse) {
+    ASSERT_SORTED_ARRAY_ASCENDING_REVERSE(&quick_sort_array);
+}
+
+TEST(test_quick_sort_descending_reverse) {
+    ASSERT_SORTED_ARRAY_DESCENDING_REVERSE(&quick_sort_array);
+}
+
+#endif

test_quick_sort.h

@@ -0,0 +1,24 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Unit Tests for quick sort
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Tests functions for quick sort.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_QUICK_SORT_H
+#define ___TEST_QUICK_SORT_H
+
+#include "shortcut.h"
+#include "config.h"
+
+TEST(test_quick_sort_ascending);
+TEST(test_quick_sort_descending);
+TEST(test_quick_sort_ascending_multiple);
+TEST(test_quick_sort_descending_multiple);
+TEST(test_quick_sort_ascending_reverse);
+TEST(test_quick_sort_descending_reverse); 
+
+#endif

test_sorting.c

@@ -0,0 +1,98 @@
+/*----------------------------------------------------------
+ *				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_init_array_random__shall_initialize_the_array) {
+    int array[16];
+    int cnt = 16;
+    init_array_random(array, cnt);
+    int i = 1;
+    for (; i < cnt && array[i] != 0; i++);
+    ASSERT_TRUE(i == 16, MSG("Expected that the array was initialized with a number of values"));
+}
+
+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_array__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,28 @@
+/*----------------------------------------------------------
+ *				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_init_array_random__shall_initialize_the_array);
+TEST(test_sorting_sort_array__shall_sort_the_array_ascending);
+TEST(test_sorting_sort_array__shall_sort_the_array_descending);
+#endif
+
+#endif

test_sorting_algorithms.c

@@ -0,0 +1,70 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Implements common Unit Test functionality for sorting algorithms.
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Provides common tests functions for sorting algorithms.
+ * ----------------------------------------------------------
+ */
+
+#include "test_sorting_algorithms.h"
+
+#include <stdio.h>
+#include <string.h>
+#include "sorting.h"
+
+
+void _assert_sorted_list(struct TestCase* tc, const char* direction_txt, list_sorting_fn* sorter, criterion_fn* criterion, criterion_fn* reverse_criterion, bool multiple) {
+#ifdef LIST_VARIANT
+    IntList list = list_obtain();
+    ASSERT_TRUE(list_is_valid(list), MSG("Expected valid list"));
+    init_list_random(list, 16);
+    if (multiple) {
+        list_insert_at(list, 0, 42);
+        list_insert_at(list, 0, 42);
+        list_insert_at(list, 10, 42);
+    }
+    if (reverse_criterion != 0) {
+        sorter(list, reverse_criterion);
+        int i = 1;
+        for (; i < list_get_size(list) && reverse_criterion(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 reverse %s order as required for preparation", direction_txt));
+    }
+    sorter(list, criterion);
+    int i = 1;
+    for (; i < list_get_size(list) && criterion(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 %s order", direction_txt));
+    list_release(&list);
+#endif
+}
+
+// #else /* ARRAY VARIANT */
+
+void _assert_sorted_array(struct TestCase* tc, const char* direction_txt, array_sorting_fn* sorter, criterion_fn* criterion, criterion_fn* reverse_criterion, bool multiple) {
+#ifndef LIST_VARIANT
+    int cnt = 16;
+    int array[cnt];
+    init_array_random(array, cnt);
+    if (multiple) {
+        array[0] = 42;
+        array[1] = 42;
+        array[11] = 42;
+    }
+    if (reverse_criterion != 0) {
+        sorter(array, cnt, reverse_criterion);
+        int i = 1;
+        for (; i < cnt && reverse_criterion(array[i-1], array[i]); i++);
+        ASSERT_TRUE(i == cnt, MSG("Expected that all elements are in reverse %s order as required for preparation", direction_txt));
+    }
+    sorter(array, cnt, criterion);
+    int i = 1;
+    for (; i < cnt && criterion(array[i-1], array[i]); i++);
+    ASSERT_TRUE(i == cnt, MSG("Expected that all elements are in %s order", direction_txt));
+#endif
+}
+
+
+
+// #endif

test_sorting_algorithms.h

@@ -0,0 +1,61 @@
+/*----------------------------------------------------------
+ *				HTBLA-Leonding / Klasse: n/a
+ * ---------------------------------------------------------
+ * Title:			Common Unit Test functionality for sorting algorithms.
+ * Author:			S. Schraml
+ * ----------------------------------------------------------
+ * Description:
+ * Provides common tests functions for sorting algorithms.
+ * ----------------------------------------------------------
+ */
+#ifndef ___TEST_SORTING_ALGORITHMS_H
+#define ___TEST_SORTING_ALGORITHMS_H
+
+#include "shortcut.h"
+#include "config.h"
+#include "list.h"
+#include "sorting_criteria.h"
+
+typedef void list_sorting_fn(IntList, criterion_fn*);
+
+#define ASSERT_SORTED_LIST_ASCENDING_PLAIN(sorter)    ASSERT_SORTED_LIST_ASCENDING(sorter, 0, false);
+#define ASSERT_SORTED_LIST_ASCENDING_MULTIPLE(sorter) ASSERT_SORTED_LIST_ASCENDING(sorter, 0, true);
+#define ASSERT_SORTED_LIST_ASCENDING_REVERSE(sorter)  ASSERT_SORTED_LIST_ASCENDING(sorter, &is_in_desc_order, false);
+#define ASSERT_SORTED_LIST_ASCENDING(sorter, reverse_criterion, multiple) ASSERT_SORTED_LIST("ascending", sorter, &is_in_asc_order, reverse_criterion, multiple);
+
+#define ASSERT_SORTED_LIST_DESCENDING_PLAIN(sorter)    ASSERT_SORTED_LIST_DESCENDING(sorter, 0, false);
+#define ASSERT_SORTED_LIST_DESCENDING_MULTIPLE(sorter) ASSERT_SORTED_LIST_DESCENDING(sorter, 0, true);
+#define ASSERT_SORTED_LIST_DESCENDING_REVERSE(sorter)  ASSERT_SORTED_LIST_DESCENDING(sorter, &is_in_asc_order, false);
+#define ASSERT_SORTED_LIST_DESCENDING(sorter, reverse_criterion, multiple) ASSERT_SORTED_LIST("descending", sorter, &is_in_desc_order, reverse_criterion, multiple);
+
+#define ASSERT_SORTED_LIST(direction_txt, sorter, criterion, reverse_criterion, multiple) _assert_sorted_list(tc, direction_txt, sorter, criterion, reverse_criterion, multiple)
+void _assert_sorted_list(struct TestCase* tc, const char* direction_txt, list_sorting_fn* sorter, criterion_fn* criterion, criterion_fn* reverse_criterion, bool multiple);
+
+
+typedef void array_sorting_fn(int[], unsigned long, criterion_fn*);
+
+#define ASSERT_SORTED_ARRAY_ASCENDING_PLAIN(sorter)    ASSERT_SORTED_ARRAY_ASCENDING(sorter, 0, false);
+#define ASSERT_SORTED_ARRAY_ASCENDING_MULTIPLE(sorter) ASSERT_SORTED_ARRAY_ASCENDING(sorter, 0, true);
+#define ASSERT_SORTED_ARRAY_ASCENDING_REVERSE(sorter)  ASSERT_SORTED_ARRAY_ASCENDING(sorter, &is_in_desc_order, false);
+#define ASSERT_SORTED_ARRAY_ASCENDING(sorter, reverse_criterion, multiple) ASSERT_SORTED_ARRAY("ascending", sorter, &is_in_asc_order, reverse_criterion, multiple);
+
+#define ASSERT_SORTED_ARRAY_DESCENDING_PLAIN(sorter)    ASSERT_SORTED_ARRAY_DESCENDING(sorter, 0, false);
+#define ASSERT_SORTED_ARRAY_DESCENDING_MULTIPLE(sorter) ASSERT_SORTED_ARRAY_DESCENDING(sorter, 0, true);
+#define ASSERT_SORTED_ARRAY_DESCENDING_REVERSE(sorter)  ASSERT_SORTED_ARRAY_DESCENDING(sorter, &is_in_asc_order, false);
+#define ASSERT_SORTED_ARRAY_DESCENDING(sorter, reverse_criterion, multiple) ASSERT_SORTED_ARRAY("descending", sorter, &is_in_desc_order, reverse_criterion, multiple);
+
+#define ASSERT_SORTED_ARRAY(direction_txt, sorter, criterion, reverse_criterion, multiple) _assert_sorted_array(tc, direction_txt, sorter, criterion, reverse_criterion, multiple)
+void _assert_sorted_array(struct TestCase* tc, const char* direction_txt, array_sorting_fn* sorter, criterion_fn* criterion, criterion_fn* reverse_criterion, bool multiple);
+
+// #ifdef LIST_VARIANT
+// TEST(test_insertion_sort_binsearch_list_ascending);
+// TEST(test_insertion_sort_binsearch_list_decending);
+// #else 
+// TEST(test_insertion_sort_binsearch_array_ascending);
+// TEST(test_insertion_sort_binsearch_array_descending);
+// TEST(test_insertion_sort_binsearch_array_ascending_multiple);
+// TEST(test_insertion_sort_binsearch_array_descending_multiple);
+// TEST(test_insertion_sort_binsearch_array_ascending_reverse);
+// TEST(test_insertion_sort_binsearch_array_descending_reverse); 
+// #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