/*
 * Copyright (c) 2017, George Oikonomou - http://www.spd.gr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holder nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */
/*---------------------------------------------------------------------------*/
#include "contiki.h"
#include "lib/list.h"
#include "lib/stack.h"
#include "lib/queue.h"
#include "lib/circular-list.h"
#include "lib/dbl-list.h"
#include "lib/dbl-circ-list.h"
#include "lib/random.h"
#include "services/unit-test/unit-test.h"

#include <string.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
/*---------------------------------------------------------------------------*/
PROCESS(data_structure_test_process, "Data structure process");
AUTOSTART_PROCESSES(&data_structure_test_process);
/*---------------------------------------------------------------------------*/
typedef struct demo_struct_s {
  struct demo_struct_s *next;
  struct demo_struct_s *previous;
} demo_struct_t;
/*---------------------------------------------------------------------------*/
#define ELEMENT_COUNT 10
static demo_struct_t elements[ELEMENT_COUNT];
/*---------------------------------------------------------------------------*/
void
print_test_report(const unit_test_t *utp)
{
  printf("=check-me= ");
  if(utp->result == unit_test_failure) {
    printf("FAILED   - %s: exit at L%u\n", utp->descr, utp->exit_line);
  } else {
    printf("SUCCEEDED - %s\n", utp->descr);
  }
}
/*---------------------------------------------------------------------------*/
UNIT_TEST_REGISTER(test_list, "Singly-linked list");
UNIT_TEST(test_list)
{
  demo_struct_t *head, *tail;

  LIST(lst);

  UNIT_TEST_BEGIN();

  memset(elements, 0, sizeof(elements));
  list_init(lst);

  /* Starts from empty */
  UNIT_TEST_ASSERT(list_head(lst) == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 0);

  /*
   * Add an item. Should be head and tail
   * 0 --> NULL
   */
  list_add(lst, &elements[0]);
  UNIT_TEST_ASSERT(list_head(lst) == &elements[0]);
  UNIT_TEST_ASSERT(list_tail(lst) == &elements[0]);
  UNIT_TEST_ASSERT(elements[0].next == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 1);

  /*
   * Add an item. Should become the new tail
   * 0 --> 1 --> NULL
   */
  list_add(lst, &elements[1]);
  head = list_head(lst);
  tail = list_tail(lst);
  UNIT_TEST_ASSERT(list_head(lst) == &elements[0]);
  UNIT_TEST_ASSERT(list_tail(lst) == &elements[1]);
  UNIT_TEST_ASSERT(head->next == tail);
  UNIT_TEST_ASSERT(tail->next == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 2);

  /*
   * Add after existing head
   * 0 --> 2 --> 1 --> NULL
   */
  head = list_head(lst);
  list_insert(lst, head, &elements[2]);
  head = list_head(lst);
  tail = list_tail(lst);
  UNIT_TEST_ASSERT(list_head(lst) == &elements[0]);
  UNIT_TEST_ASSERT(list_tail(lst) == &elements[1]);
  UNIT_TEST_ASSERT(head->next == &elements[2]);
  UNIT_TEST_ASSERT(elements[2].next == tail);
  UNIT_TEST_ASSERT(tail->next == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 3);

  /*
   * Add after existing head
   * 0 --> 2 --> 1 --> 3 --> NULL
   */
  tail = list_tail(lst);
  list_insert(lst, tail, &elements[3]);
  tail = list_tail(lst);
  UNIT_TEST_ASSERT(list_head(lst) == &elements[0]);
  UNIT_TEST_ASSERT(list_tail(lst) == &elements[3]);
  UNIT_TEST_ASSERT(tail->next == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 4);

  /*
   * Re-add item 2 using list_add
   * 0 --> 1 --> 3 --> 2 --> NULL
   */
  list_add(lst, &elements[2]);
  tail = list_tail(lst);
  UNIT_TEST_ASSERT(list_head(lst) == &elements[0]);
  UNIT_TEST_ASSERT(list_tail(lst) == &elements[2]);
  UNIT_TEST_ASSERT(tail->next == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 4);

  /*
   * Re-add item 3 using list_insert
   * 0 --> 1 --> 2 --> 3 --> NULL
   */
  tail = list_tail(lst);
  list_insert(lst, tail, &elements[3]);
  tail = list_tail(lst);
  UNIT_TEST_ASSERT(list_head(lst) == &elements[0]);
  UNIT_TEST_ASSERT(list_tail(lst) == &elements[3]);
  UNIT_TEST_ASSERT(elements[2].next == tail);
  UNIT_TEST_ASSERT(tail->next == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 4);

  /*
   * Check that list contains elements 0, 1, 2, 3
   * and not others
   * 0 --> 1 --> 2 --> 3 --> NULL
   */
  UNIT_TEST_ASSERT(list_contains(lst, &elements[0]));
  UNIT_TEST_ASSERT(list_contains(lst, &elements[1]));
  UNIT_TEST_ASSERT(list_contains(lst, &elements[2]));
  UNIT_TEST_ASSERT(list_contains(lst, &elements[3]));
  int i;
  for(i=4; i<ELEMENT_COUNT; i++) {
    UNIT_TEST_ASSERT(!list_contains(lst, &elements[i]));
  }
  /*
   * Remove the tail
   * 0 --> 1 --> 2 --> NULL
   */
  tail = list_tail(lst);
  UNIT_TEST_ASSERT(list_chop(lst) == tail);
  head = list_head(lst);
  tail = list_tail(lst);
  UNIT_TEST_ASSERT(tail == &elements[2]);
  UNIT_TEST_ASSERT(tail->next == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 3);

  /*
   * Remove an item in the middle
   * 0 --> 2 --> NULL
   */
  head = list_head(lst);
  list_remove(lst, head->next);
  head = list_head(lst);
  tail = list_tail(lst);
  UNIT_TEST_ASSERT(head->next == tail);
  UNIT_TEST_ASSERT(list_head(lst) == &elements[0]);
  UNIT_TEST_ASSERT(list_tail(lst) == &elements[2]);
  UNIT_TEST_ASSERT(tail->next == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 2);

  /*
   * Remove the head
   * 2 --> NULL
   */
  list_remove(lst, list_head(lst));
  tail = list_tail(lst);
  UNIT_TEST_ASSERT(list_head(lst) == &elements[2]);
  UNIT_TEST_ASSERT(list_tail(lst) == &elements[2]);
  UNIT_TEST_ASSERT(tail->next == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 1);

  /* Ends empty */
  list_remove(lst, list_tail(lst));
  UNIT_TEST_ASSERT(list_head(lst) == NULL);
  UNIT_TEST_ASSERT(list_length(lst) == 0);

  UNIT_TEST_END();
}
/*---------------------------------------------------------------------------*/
UNIT_TEST_REGISTER(test_stack, "Stack Push/Pop");
UNIT_TEST(test_stack)
{
  STACK(stack);

  UNIT_TEST_BEGIN();

  memset(elements, 0, sizeof(elements));
  stack_init(stack);

  /* Starts from empty */
  UNIT_TEST_ASSERT(stack_is_empty(stack) == true);
  UNIT_TEST_ASSERT(stack_peek(stack) == NULL);
  UNIT_TEST_ASSERT(stack_pop(stack) == NULL);

  /*
   * Push two elements. Peek and pop should be the last one. Stack should be
   * non-empty after the pop
   */
  stack_push(stack, &elements[0]);
  stack_push(stack, &elements[1]);

  UNIT_TEST_ASSERT(stack_peek(stack) == &elements[1]);
  UNIT_TEST_ASSERT(stack_pop(stack) == &elements[1]);
  UNIT_TEST_ASSERT(stack_peek(stack) == &elements[0]);
  UNIT_TEST_ASSERT(stack_is_empty(stack) == false);
  UNIT_TEST_ASSERT(stack_pop(stack) == &elements[0]);

  /* Ends empty */
  UNIT_TEST_ASSERT(stack_is_empty(stack) == true);
  UNIT_TEST_ASSERT(stack_peek(stack) == NULL);
  UNIT_TEST_ASSERT(stack_pop(stack) == NULL);

  UNIT_TEST_END();
}
/*---------------------------------------------------------------------------*/
UNIT_TEST_REGISTER(test_queue, "Queue Enqueue/Dequeue");
UNIT_TEST(test_queue)
{
  QUEUE(queue);

  UNIT_TEST_BEGIN();

  memset(elements, 0, sizeof(elements));
  queue_init(queue);

  /* Starts from empty */
  UNIT_TEST_ASSERT(queue_is_empty(queue) == true);
  UNIT_TEST_ASSERT(queue_peek(queue) == NULL);
  UNIT_TEST_ASSERT(queue_dequeue(queue) == NULL);

  /* Enqueue three elements. They should come out in the same order */
  queue_enqueue(queue, &elements[0]);
  queue_enqueue(queue, &elements[1]);
  queue_enqueue(queue, &elements[2]);

  UNIT_TEST_ASSERT(queue_dequeue(queue) == &elements[0]);
  UNIT_TEST_ASSERT(queue_dequeue(queue) == &elements[1]);
  UNIT_TEST_ASSERT(queue_dequeue(queue) == &elements[2]);

  /* Should be empty */
  UNIT_TEST_ASSERT(queue_is_empty(queue) == true);
  UNIT_TEST_ASSERT(queue_peek(queue) == NULL);
  UNIT_TEST_ASSERT(queue_dequeue(queue) == NULL);

  UNIT_TEST_END();
}
/*---------------------------------------------------------------------------*/
UNIT_TEST_REGISTER(test_csll, "Circular, singly-linked list");
UNIT_TEST(test_csll)
{
  demo_struct_t *head, *tail;

  CIRCULAR_LIST(csll);

  UNIT_TEST_BEGIN();

  memset(elements, 0, sizeof(elements));
  circular_list_init(csll);

  /* Starts from empty */
  UNIT_TEST_ASSERT(circular_list_is_empty(csll) == true);
  UNIT_TEST_ASSERT(circular_list_length(csll) == 0);
  UNIT_TEST_ASSERT(circular_list_head(csll) == NULL);
  UNIT_TEST_ASSERT(circular_list_tail(csll) == NULL);

  /* Add one element. Should point to itself and act as head and tail */
  circular_list_add(csll, &elements[0]);

  UNIT_TEST_ASSERT(circular_list_is_empty(csll) == false);
  UNIT_TEST_ASSERT(circular_list_length(csll) == 1);
  UNIT_TEST_ASSERT(circular_list_head(csll) == &elements[0]);
  UNIT_TEST_ASSERT(circular_list_tail(csll) == &elements[0]);
  UNIT_TEST_ASSERT(elements[0].next == &elements[0]);

  /* Add a second element. The two should point to each-other */
  circular_list_add(csll, &elements[1]);
  UNIT_TEST_ASSERT(elements[0].next == &elements[1]);
  UNIT_TEST_ASSERT(elements[1].next == &elements[0]);

  /*
   * Add a third element and check that head->next->next points to tail.
   * Check that tail->next points to the head
   */
  circular_list_add(csll, &elements[2]);
  head = circular_list_head(csll);
  tail = circular_list_tail(csll);

  UNIT_TEST_ASSERT(head->next->next == circular_list_tail(csll));
  UNIT_TEST_ASSERT(tail->next == circular_list_head(csll));

  /* Re-add an existing element. Check the list's integrity */
  circular_list_add(csll, &elements[1]);
  head = circular_list_head(csll);
  tail = circular_list_tail(csll);

  UNIT_TEST_ASSERT(circular_list_is_empty(csll) == false);
  UNIT_TEST_ASSERT(circular_list_length(csll) == 3);
  UNIT_TEST_ASSERT(head->next->next->next == circular_list_head(csll));
  UNIT_TEST_ASSERT(head->next->next == circular_list_tail(csll));
  UNIT_TEST_ASSERT(tail->next == circular_list_head(csll));

  /* Add another two elements, then start testing removal */
  circular_list_add(csll, &elements[3]);
  circular_list_add(csll, &elements[4]);

  /* Remove an item in the middle and test list integrity */
  head = circular_list_head(csll);
  circular_list_remove(csll, head->next->next);
  head = circular_list_head(csll);
  tail = circular_list_tail(csll);

  UNIT_TEST_ASSERT(circular_list_length(csll) == 4);
  UNIT_TEST_ASSERT(head->next->next->next->next == circular_list_head(csll));
  UNIT_TEST_ASSERT(head->next->next->next == circular_list_tail(csll));
  UNIT_TEST_ASSERT(tail->next == circular_list_head(csll));

  /* Remove the head and test list integrity */
  circular_list_remove(csll, circular_list_head(csll));
  head = circular_list_head(csll);
  tail = circular_list_tail(csll);

  UNIT_TEST_ASSERT(circular_list_length(csll) == 3);
  UNIT_TEST_ASSERT(head->next->next->next == circular_list_head(csll));
  UNIT_TEST_ASSERT(head->next->next == circular_list_tail(csll));
  UNIT_TEST_ASSERT(tail->next == circular_list_head(csll));

  /* Remove the tail and test list integrity */
  circular_list_remove(csll, circular_list_tail(csll));
  head = circular_list_head(csll);
  tail = circular_list_tail(csll);

  UNIT_TEST_ASSERT(circular_list_length(csll) == 2);
  UNIT_TEST_ASSERT(head->next->next == circular_list_head(csll));
  UNIT_TEST_ASSERT(head->next == circular_list_tail(csll));
  UNIT_TEST_ASSERT(tail->next == circular_list_head(csll));

  /*
   * Remove the tail
   * Only one item left: Make sure the head and tail are the same and point to
   * each other
   */
  circular_list_remove(csll, circular_list_tail(csll));
  head = circular_list_head(csll);
  tail = circular_list_tail(csll);

  UNIT_TEST_ASSERT(circular_list_length(csll) == 1);
  UNIT_TEST_ASSERT(head == tail);
  UNIT_TEST_ASSERT(head->next->next == circular_list_head(csll));
  UNIT_TEST_ASSERT(head->next == circular_list_head(csll));
  UNIT_TEST_ASSERT(head->next == circular_list_tail(csll));
  UNIT_TEST_ASSERT(tail->next == circular_list_head(csll));
  UNIT_TEST_ASSERT(tail->next == circular_list_tail(csll));

  /* Remove the last element by removing the head */
  circular_list_remove(csll, circular_list_head(csll));
  UNIT_TEST_ASSERT(circular_list_is_empty(csll) == true);
  UNIT_TEST_ASSERT(circular_list_length(csll) == 0);
  UNIT_TEST_ASSERT(circular_list_head(csll) == NULL);
  UNIT_TEST_ASSERT(circular_list_tail(csll) == NULL);

  /* Remove the last element by removing the tail */
  circular_list_add(csll, &elements[0]);
  circular_list_remove(csll, circular_list_tail(csll));
  UNIT_TEST_ASSERT(circular_list_is_empty(csll) == true);
  UNIT_TEST_ASSERT(circular_list_length(csll) == 0);
  UNIT_TEST_ASSERT(circular_list_head(csll) == NULL);
  UNIT_TEST_ASSERT(circular_list_tail(csll) == NULL);

  UNIT_TEST_END();
}
/*---------------------------------------------------------------------------*/
UNIT_TEST_REGISTER(test_dll, "Doubly-linked list");
UNIT_TEST(test_dll)
{
  demo_struct_t *head, *tail;

  CIRCULAR_LIST(dll);

  UNIT_TEST_BEGIN();

  memset(elements, 0, sizeof(elements));

  /* Starts from empty */
  dbl_list_init(dll);
  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == true);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 0);
  UNIT_TEST_ASSERT(dbl_list_head(dll) == NULL);
  UNIT_TEST_ASSERT(dbl_list_tail(dll) == NULL);

  /*
   * Add an item by adding to the head.
   * Head and tail should point to NULL in both directions
   */
  dbl_list_add_head(dll, &elements[0]);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 1);
  UNIT_TEST_ASSERT(head == &elements[0]);
  UNIT_TEST_ASSERT(tail == &elements[0]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == NULL);
  UNIT_TEST_ASSERT(tail->previous == NULL);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Add an item by adding to the tail.
   * Head and tail should point to NULL in both directions
   */
  dbl_list_remove(dll, dbl_list_head(dll));
  dbl_list_add_tail(dll, &elements[1]);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 1);
  UNIT_TEST_ASSERT(head == &elements[1]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == NULL);
  UNIT_TEST_ASSERT(tail->previous == NULL);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Add a second item to head. Head points forward to tail.
   * Tail points backwards to head.
   */
  dbl_list_add_head(dll, &elements[2]);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 2);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == tail);
  UNIT_TEST_ASSERT(tail->previous == head);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Add before head.
   * NULL <-- 3 --> 2 --> 1 --> NULL
   */
  dbl_list_add_before(dll, dbl_list_head(dll), &elements[3]);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 3);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == &elements[2]);
  UNIT_TEST_ASSERT(head->next->next == tail);
  UNIT_TEST_ASSERT(head->next->next->next == NULL);
  UNIT_TEST_ASSERT(tail->previous == &elements[2]);
  UNIT_TEST_ASSERT(tail->previous->previous == &elements[3]);
  UNIT_TEST_ASSERT(tail->previous->previous->previous == NULL);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Add after head.
   * NULL <-- 3 --> 4 --> 2 --> 1 --> NULL
   */
  dbl_list_add_after(dll, dbl_list_head(dll), &elements[4]);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 4);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == &elements[4]);
  UNIT_TEST_ASSERT(head->next->next == &elements[2]);
  UNIT_TEST_ASSERT(head->next->next->next == tail);
  UNIT_TEST_ASSERT(head->next->next->next->next == NULL);
  UNIT_TEST_ASSERT(tail->previous == &elements[2]);
  UNIT_TEST_ASSERT(tail->previous->previous == &elements[4]);
  UNIT_TEST_ASSERT(tail->previous->previous->previous == &elements[3]);
  UNIT_TEST_ASSERT(tail->previous->previous->previous->previous == NULL);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Add at 3rd position by adding after 2nd
   * NULL <-- 3 --> 4 --> 5 --> 2 --> 1 --> NULL
   */
  dbl_list_add_after(dll, &elements[4], &elements[5]);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 5);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == &elements[4]);
  UNIT_TEST_ASSERT(head->next->next == &elements[5]);
  UNIT_TEST_ASSERT(tail->previous->previous == &elements[5]);
  UNIT_TEST_ASSERT(tail->previous == &elements[2]);
  UNIT_TEST_ASSERT(elements[5].next == &elements[2]);
  UNIT_TEST_ASSERT(elements[5].previous == &elements[4]);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Add at 3rd position by adding before 3rd
   * NULL <-- 3 --> 4 --> 6 --> 5 --> 2 --> 1 --> NULL
   */
  dbl_list_add_before(dll, &elements[5], &elements[6]);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 6);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == &elements[4]);
  UNIT_TEST_ASSERT(head->next->next == &elements[6]);
  UNIT_TEST_ASSERT(tail->previous->previous == &elements[5]);
  UNIT_TEST_ASSERT(elements[6].next == &elements[5]);
  UNIT_TEST_ASSERT(elements[6].previous == &elements[4]);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Add before tail
   * NULL <-- 3 --> 4 --> 6 --> 5 --> 2 --> 7 --> 1 --> NULL
   */
  dbl_list_add_before(dll, dbl_list_tail(dll), &elements[7]);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 7);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(tail->previous == &elements[7]);
  UNIT_TEST_ASSERT(elements[7].next == &elements[1]);
  UNIT_TEST_ASSERT(elements[7].previous == &elements[2]);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Add after tail
   * NULL <-- 3 --> 4 --> 6 --> 5 --> 2 --> 7 --> 1 --> 8 --> NULL
   */
  dbl_list_add_after(dll, dbl_list_tail(dll), &elements[8]);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 8);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[8]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(tail->previous == &elements[1]);
  UNIT_TEST_ASSERT(elements[8].next == NULL);
  UNIT_TEST_ASSERT(elements[8].previous == &elements[1]);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Find and remove element 5
   * NULL <-- 3 --> 4 --> 6 --> 2 --> 7 --> 1 --> 8 --> NULL
   */
  dbl_list_remove(dll, &elements[5]);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 7);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[8]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(elements[6].next == &elements[2]);
  UNIT_TEST_ASSERT(elements[2].previous == &elements[6]);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Remove before tail
   * NULL <-- 3 --> 4 --> 6 --> 2 --> 7 --> 8 --> NULL
   */
  dbl_list_remove(dll, ((demo_struct_t *)dbl_list_tail(dll))->previous);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 6);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[8]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(elements[7].next == tail);
  UNIT_TEST_ASSERT(tail->previous == &elements[7]);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Remove after head
   * NULL <-- 3 --> 6 --> 2 --> 7 --> 8 --> NULL
   */
  dbl_list_remove(dll, ((demo_struct_t *)dbl_list_head(dll))->next);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 5);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[8]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == &elements[6]);
  UNIT_TEST_ASSERT(elements[6].previous == head);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Find element 2 and remove whatever is after it
   * NULL <-- 3 --> 6 --> 2 --> 8 --> NULL
   */
  dbl_list_remove(dll, elements[2].next);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 4);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[8]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(elements[2].next == tail);
  UNIT_TEST_ASSERT(tail->previous == &elements[2]);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Find element 2 and remove whatever is before it
   * NULL <-- 3 --> 2 --> 8 --> NULL
   */
  dbl_list_remove(dll, elements[2].previous);
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 3);
  UNIT_TEST_ASSERT(head == &elements[3]);
  UNIT_TEST_ASSERT(tail == &elements[8]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == &elements[2]);
  UNIT_TEST_ASSERT(elements[2].previous == head);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Remove head
   * NULL <-- 2 --> 8 --> NULL
   */
  dbl_list_remove(dll, dbl_list_head(dll));
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 2);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[8]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == tail);
  UNIT_TEST_ASSERT(tail->previous == head);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /*
   * Remove tail
   * NULL <-- 8 --> NULL
   */
  dbl_list_remove(dll, dbl_list_head(dll));
  head = dbl_list_head(dll);
  tail = dbl_list_tail(dll);

  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == false);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 1);
  UNIT_TEST_ASSERT(head == &elements[8]);
  UNIT_TEST_ASSERT(tail == &elements[8]);
  UNIT_TEST_ASSERT(head->previous == NULL);
  UNIT_TEST_ASSERT(head->next == NULL);
  UNIT_TEST_ASSERT(tail->previous == NULL);
  UNIT_TEST_ASSERT(tail->next == NULL);

  /* Remove the last element */
  dbl_list_remove(dll, dbl_list_head(dll));
  UNIT_TEST_ASSERT(dbl_list_is_empty(dll) == true);
  UNIT_TEST_ASSERT(dbl_list_length(dll) == 0);
  UNIT_TEST_ASSERT(dbl_list_head(dll) == NULL);
  UNIT_TEST_ASSERT(dbl_list_tail(dll) == NULL);

  UNIT_TEST_END();
}
/*---------------------------------------------------------------------------*/
UNIT_TEST_REGISTER(test_cdll, "Circular, doubly-linked list");
UNIT_TEST(test_cdll)
{
  demo_struct_t *head, *tail;

  CIRCULAR_LIST(cdll);

  UNIT_TEST_BEGIN();

  memset(elements, 0, sizeof(elements));

  /* Starts from empty */
  dbl_circ_list_init(cdll);
  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == true);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 0);
  UNIT_TEST_ASSERT(dbl_circ_list_head(cdll) == NULL);
  UNIT_TEST_ASSERT(dbl_circ_list_tail(cdll) == NULL);

  /*
   * Add an item by adding to the head.
   * Head and tail should be the same element and should point to itself in
   * both directions
   */
  dbl_circ_list_add_head(cdll, &elements[0]);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 1);
  UNIT_TEST_ASSERT(head == &elements[0]);
  UNIT_TEST_ASSERT(tail == &elements[0]);
  UNIT_TEST_ASSERT(head->previous == head);
  UNIT_TEST_ASSERT(head->next == head);
  UNIT_TEST_ASSERT(tail->previous == tail);
  UNIT_TEST_ASSERT(tail->next == tail);

  /*
   * Add an item by adding to the tail.
   * (tail) <--> 0 <--> 1 <--> (head)
   * Head should point to tail in both directions
   */
  dbl_circ_list_add_tail(cdll, &elements[1]);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 2);
  UNIT_TEST_ASSERT(head == &elements[0]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->next == tail);
  UNIT_TEST_ASSERT(tail->previous == head);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);

  /*
   * Add before head.
   * (tail) <--> 2 <--> 0 <--> 1 <--> (head)
   */
  dbl_circ_list_add_before(cdll, dbl_circ_list_head(cdll), &elements[2]);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 3);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[2].previous == tail);
  UNIT_TEST_ASSERT(elements[2].next == &elements[0]);
  UNIT_TEST_ASSERT(elements[0].previous == head);

  /*
   * Add after head.
   * (tail) <--> 2 <--> 3 <--> 0 <--> 1 <--> (head)
   */
  dbl_circ_list_add_after(cdll, dbl_circ_list_head(cdll), &elements[3]);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 4);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[3].previous == head);
  UNIT_TEST_ASSERT(elements[3].next == &elements[0]);
  UNIT_TEST_ASSERT(elements[0].previous == &elements[3]);

  /*
   * Add at 3rd position by adding after 2nd
   * (tail) <--> 2 <--> 3 <--> 4 <--> 0 <--> 1 <--> (head)
   */
  dbl_circ_list_add_after(cdll, &elements[3], &elements[4]);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 5);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[3].next == &elements[4]);
  UNIT_TEST_ASSERT(elements[4].previous == &elements[3]);
  UNIT_TEST_ASSERT(elements[4].next == &elements[0]);
  UNIT_TEST_ASSERT(elements[0].previous == &elements[4]);

  /*
   * Add at 3rd position by adding before 3rd
   * (tail) <--> 2 <--> 3 <--> 5 <--> 4 <--> 0 <--> 1 <--> (head)
   */
  dbl_circ_list_add_before(cdll, &elements[4], &elements[5]);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 6);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[3].next == &elements[5]);
  UNIT_TEST_ASSERT(elements[5].previous == &elements[3]);
  UNIT_TEST_ASSERT(elements[5].next == &elements[4]);
  UNIT_TEST_ASSERT(elements[4].previous == &elements[5]);

  /*
   * Add before tail
   * (tail) <--> 2 <--> 3 <--> 5 <--> 4 <--> 0 <--> 6 <--> 1 <--> (head)
   */
  dbl_circ_list_add_before(cdll, dbl_circ_list_tail(cdll), &elements[6]);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 7);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[1]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[0].next == &elements[6]);
  UNIT_TEST_ASSERT(elements[6].previous == &elements[0]);
  UNIT_TEST_ASSERT(elements[6].next == &elements[1]);
  UNIT_TEST_ASSERT(elements[1].previous == &elements[6]);

  /*
   * Add after tail
   * (tail) <--> 2 <--> 3 <--> 5 <--> 4 <--> 0 <--> 6 <--> 1 <--> 7 <--> (head)
   */
  dbl_circ_list_add_after(cdll, dbl_circ_list_tail(cdll), &elements[7]);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 8);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[7]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[1].next == &elements[7]);
  UNIT_TEST_ASSERT(elements[7].previous == &elements[1]);
  UNIT_TEST_ASSERT(elements[7].next == &elements[2]);
  UNIT_TEST_ASSERT(elements[2].previous == &elements[7]);

  /*
   * Find and remove element 5
   * (tail) <--> 2 <--> 3 <--> 4 <--> 0 <--> 6 <--> 1 <--> 7 <--> (head)
   */
  dbl_circ_list_remove(cdll, &elements[5]);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 7);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[7]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[3].next == &elements[4]);
  UNIT_TEST_ASSERT(elements[4].previous == &elements[3]);

  /*
   * Find element 4 and remove what's after it
   * (tail) <--> 2 <--> 3 <--> 4 <--> 6 <--> 1 <--> 7 <--> (head)
   */
  dbl_circ_list_remove(cdll, elements[4].next);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 6);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[7]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[4].next == &elements[6]);
  UNIT_TEST_ASSERT(elements[6].previous == &elements[4]);

  /*
   * Find element 4 and remove what's before it
   * (tail) <--> 2 <--> 4 <--> 6 <--> 1 <--> 7 <--> (head)
   */
  dbl_circ_list_remove(cdll, elements[4].previous);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 5);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[7]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[2].next == &elements[4]);
  UNIT_TEST_ASSERT(elements[4].previous == &elements[2]);

  /*
   * Remove before tail
   * (tail) <--> 2 <--> 4 <--> 6 <--> 7 <--> (head)
   */
  dbl_circ_list_remove(cdll,
                       ((demo_struct_t *)dbl_circ_list_tail(cdll))->previous);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 4);
  UNIT_TEST_ASSERT(head == &elements[2]);
  UNIT_TEST_ASSERT(tail == &elements[7]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[6].next == &elements[7]);
  UNIT_TEST_ASSERT(elements[7].previous == &elements[6]);

  /*
   * Remove after tail
   * (tail) <--> 4 <--> 6 <--> 7 <--> (head)
   */
  dbl_circ_list_remove(cdll,
                       ((demo_struct_t *)dbl_circ_list_tail(cdll))->next);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 3);
  UNIT_TEST_ASSERT(head == &elements[4]);
  UNIT_TEST_ASSERT(tail == &elements[7]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(tail->next == head);
  UNIT_TEST_ASSERT(elements[7].next == &elements[4]);
  UNIT_TEST_ASSERT(elements[4].previous == &elements[7]);

  /*
   * Remove after head
   * (tail) <--> 4 <--> 7 <--> (head)
   */
  dbl_circ_list_remove(cdll,
                       ((demo_struct_t *)dbl_circ_list_head(cdll))->next);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 2);
  UNIT_TEST_ASSERT(head == &elements[4]);
  UNIT_TEST_ASSERT(tail == &elements[7]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(head->next == tail);
  UNIT_TEST_ASSERT(tail->previous == head);
  UNIT_TEST_ASSERT(tail->next == head);

  /*
   * Remove before head
   * (tail) <--> 4 <--> (head)
   */
  dbl_circ_list_remove(cdll,
                       ((demo_struct_t *)dbl_circ_list_head(cdll))->previous);
  head = dbl_circ_list_head(cdll);
  tail = dbl_circ_list_tail(cdll);

  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == false);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 1);
  UNIT_TEST_ASSERT(head == &elements[4]);
  UNIT_TEST_ASSERT(tail == &elements[4]);
  UNIT_TEST_ASSERT(head->previous == tail);
  UNIT_TEST_ASSERT(head->next == tail);

  /* Remove head */
  dbl_circ_list_remove(cdll, dbl_circ_list_head(cdll));
  dbl_circ_list_remove(cdll, dbl_circ_list_head(cdll));
  UNIT_TEST_ASSERT(dbl_circ_list_is_empty(cdll) == true);
  UNIT_TEST_ASSERT(dbl_circ_list_length(cdll) == 0);
  UNIT_TEST_ASSERT(dbl_circ_list_head(cdll) == NULL);
  UNIT_TEST_ASSERT(dbl_circ_list_tail(cdll) == NULL);

  UNIT_TEST_END();
}
/*---------------------------------------------------------------------------*/
PROCESS_THREAD(data_structure_test_process, ev, data)
{
  PROCESS_BEGIN();

  printf("Run unit-test\n");
  printf("---\n");

  memset(elements, 0, sizeof(elements));

  UNIT_TEST_RUN(test_list);
  UNIT_TEST_RUN(test_stack);
  UNIT_TEST_RUN(test_queue);
  UNIT_TEST_RUN(test_csll);
  UNIT_TEST_RUN(test_dll);
  UNIT_TEST_RUN(test_cdll);

  printf("=check-me= DONE\n");

  PROCESS_END();
}
/*---------------------------------------------------------------------------*/