#include <zebra.h>
#include <vector.h>

/* Vector torture tests
 *
 */

/* prototypes */
void assert_true(int result, const char * message);
int main(int argc, char **argv);
void test_vector_init(void);
void test_vector_set_index(void);
void test_vector_lookup(void);
void test_vector_lookup_ensure(void);
void test_vector_unset(void);
void test_vector_set_index_null(void);
void test_vector_copy(void);
void test_vector_set(void);
void test_vector_growth(void);

/* GMCH interface */
void test_vector_init_new(void);
void test_vector_set_item(void);
void test_vector_insert_item(void);
void test_vector_insert_item_here(void);
void test_vector_delete_item(void);
void do_test_insert(const int rider);
int sort_cmp(const void* const* a, const void* const* b);
void test_vector_sort(void);
void test_vector_bsearch(void);
void test_vector_move_item_here(void);
void do_test_move_item_here(const int rider);
void test_vector_part_reverse(void);
void test_vector_copy_here(void);
void test_vector_move_here(void);
void test_vector_copy_append(void);
void test_vector_move_append(void);
void test_vector_insert(void);
void test_vector_delete(void);
void test_vector_discard(void);
void test_vector_sak(void);

struct thread_master *master;

/* objects to put in the vectors */
static char s0[5];
static char s1000[5];
static char s2000[5];

void
assert_true(int result, const char * message)
{
  if (!result)
    {
      printf("Assert failed: %s\n", message);
    }
}

int
main(int argc, char **argv)
{
  strcpy(s0, "0");
  strcpy(s1000, "1000");
  strcpy(s2000, "2000");

  test_vector_init();
  test_vector_set_index();
  test_vector_lookup();
  test_vector_lookup_ensure();
  test_vector_unset();
  test_vector_set_index_null();
  test_vector_copy();
  test_vector_set();
  test_vector_growth();

  /* GMCH interface */
  test_vector_init_new();
  test_vector_set_item();
  test_vector_insert_item();
  test_vector_insert_item_here();
  test_vector_delete_item();
  test_vector_sort();
  test_vector_bsearch();
  test_vector_move_item_here();
  test_vector_part_reverse();
  test_vector_copy_here();
  test_vector_move_here();
  test_vector_copy_append();
  test_vector_move_append();
  test_vector_insert();
  test_vector_delete();
  test_vector_discard();
  test_vector_sak();

  return 0;
}

void
test_vector_init(void)
{
  vector v = NULL;

  printf("test_vector_init\n");
  v = vector_init(10);

  assert_true(v != NULL,
      "v == NULL");
  assert_true(vector_count(v) == 0,
      "vector_count != 0");
  assert_true(vector_active(v) == 0,
      "vector_active != 0");

  vector_free(v);
}

void
test_vector_set_index(void)
{
  vector v = NULL;

  printf("test_vector_set_index\n");
  v = vector_init(0);

  vector_set_index(v, 1000, s1000);
  assert_true(vector_count(v) == 1,
      "vector_count != 1");
  assert_true(vector_active(v) == 1001,
      "vector_active != 1001");
  assert_true(vector_slot(v,1000) == s1000,
      "vector_slot != 1000");

  vector_free(v);
}

void
test_vector_lookup(void)
{
  vector v = NULL;

  printf("test_vector_lookup\n");
  v = vector_init(0);

  vector_set_index(v, 1000, s1000);

  assert_true(vector_lookup(v,1000) == s1000,
      "vector_lookup != 1000");
  assert_true(vector_lookup(v,1001) == NULL,
      "vector_lookup != NULL");

  vector_free(v);
}

void
test_vector_lookup_ensure(void)
{
  vector v = NULL;

  printf("test_vector_lookup_ensure\n");
  v = vector_init(0);

  vector_set_index(v, 1000, s1000);

  assert_true(vector_lookup_ensure(v,1000) == s1000,
      "vector_lookup_ensure != 1000");
  assert_true(vector_lookup_ensure(v,1001) == NULL,
      "vector_lookup_ensure != NULL");

  vector_free(v);
}

void
test_vector_unset(void)
{
  vector v = NULL;

  printf("test_vector_unset\n");
  v = vector_init(0);

  vector_set_index(v, 1000, s1000);
  vector_set_index(v, 2000, s2000);
  assert_true(vector_count(v) == 2,
      "vector_count != 2");
  assert_true(vector_active(v) == 2001,
      "vector_active != 2001");

  vector_unset(v, 2000);
  assert_true(vector_count(v) == 1,
      "vector_count != 1");
  assert_true(vector_active(v) == 1001,
      "vector_active != 1001");

  vector_free(v);
}

void
test_vector_set_index_null(void)
{
  vector v = NULL;

  printf("test_vector_set_index_null\n");
  v = vector_init(0);

  vector_set_index(v, 1000, s1000);
  vector_set_index(v, 2000, s2000);
  assert_true(vector_count(v) == 2,
      "vector_count != 2");
  assert_true(vector_active(v) == 2001,
      "vector_active != 2001");

  /* storing a NULL is not the same as vector_unset() */
  vector_set_index(v, 2000, NULL);
  assert_true(vector_count(v) == 1,
      "vector_count != 1");
  assert_true(vector_active(v) == 2001,
      "vector_active != 2001");

  /* GMCH change in semantics */
  vector_unset(v, 1000);
  assert_true(vector_count(v) == 0,
      "vector_count != 0");
  assert_true(vector_active(v) == 2001,
      "vector_active != 2001 ignore post GMCH");
  assert_true(vector_active(v) == 0,
      "vector_active != 0 ignore pre GMCH");

  vector_free(v);
}

void
test_vector_copy(void)
{
  vector v1 = NULL;
  vector v2 = NULL;
  int i;
  const int len = 100;
  char buf[10];

  printf("test_vector_copy\n");

  /* to help debug objects are strings of their index */
  v1 = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%d", i);
    vector_set_index(v1, i, strdup(buf));
  }

  v2 = vector_copy(v1);
  assert_true(v2 != NULL, "v2 == NULL");
  assert_true(v1 != v2, "v1 == v2");

  /* check contents are the same */
  for (i = 0; i < len; ++i)
    {
      assert_true(vector_slot(v1, i) == vector_slot(v2, i), "v1 != v2");
    }

  /* free contents */
  for (i = 0; i < len; ++i)
    {
      free(vector_slot(v1, i));
    }

  vector_free(v1);
  vector_free(v2);
}

void
test_vector_set(void)
{
  vector v = NULL;
  int i;
  const int len = 1000;
  char buf[10];

  printf("test_vector_set\n");

  /* to help debug objects are strings of their index */
  v = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%d", i);
    vector_set_index(v, i, strdup(buf));
  }

  assert_true(vector_count(v) == (unsigned)len,
      "vector_count != 1000");
  assert_true(vector_active(v) == (unsigned)len,
      "vector_active != 1000");

  vector_set(v, s1000);
  assert_true(vector_count(v) == len + 1,
      "vector_count != 1001");
  assert_true(vector_active(v) == len + 1,
      "vector_active != 1001");
  assert_true(vector_slot(v,1000) == s1000,
      "vector_slot != 1000");

  /* free contents */
  for (i = 0; i < len; ++i)
    {
      free(vector_slot(v, i));
    }

  vector_free(v);
}

void
test_vector_growth(void)
{
  vector v = NULL;
  int i;
  const int len = 150000;
  char buf[10];

  printf("test_vector_growth\n");

  /* to help debug objects are strings of their index */
  v = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%d", i);
    vector_set_index(v, i, strdup(buf));
  }

  assert_true(vector_count(v) == (unsigned)len,
      "vector_count != len");
  assert_true(vector_active(v) == (unsigned)len,
      "vector_active != len");

  /* check contents are correct */
  for (i = 0; i < len; ++i)
    {
      sprintf(buf, "%d", i);
      assert_true(strcmp(vector_slot(v, i), buf) == 0, "vector_slot(v, i) != buf");
    }

  /* free contents */
  for (i = 0; i < len; ++i)
    {
      free(vector_slot(v, i));
    }

  vector_free(v);
}


/* post GMCH interface */

void
test_vector_init_new(void)
{
  vector v = NULL;
  void * item = NULL;

  printf("test_vector_init_new\n");

  v = vector_init_new(v, 0);
  assert_true(v != NULL, "v == NULL");
  assert_true(vector_is_empty(v), "!vector_is_empty(v)");
  assert_true(vector_end(v) == 0, "vector_end(v) != 0");

  vector_push_item(v, s0);
  assert_true(vector_end(v) == 1, "vector_end(v) != 1");

  item = vector_pop_item(v);
  assert_true(item == s0, "item != s0");
  assert_true(vector_is_empty(v), "!vector_is_empty(v)");
  assert_true(vector_end(v) == 0, "vector_end(v) != 0");

  vector_free(v);
}

void
test_vector_set_item(void)
{
  vector v = NULL;
  void * item = NULL;

  printf("test_vector_set_item\n");

  v = vector_init_new(v, 0);
  vector_set_item(v, 0, s0);
  vector_set_item(v, 1000, s1000);
  vector_set_item(v, 2000, s2000);
  assert_true(vector_end(v) == 2001, "vector_end(v) != 2001");

  item = vector_get_item(v, 0);
  assert_true(item == s0, "item != s0");
  item = vector_get_item(v, 1000);
  assert_true(item == s1000, "item != s1000");
  item = vector_get_item(v, 2000);
  assert_true(item == s2000, "item != s2000");

  item = vector_get_first_item(v);
  assert_true(item == s0, "item != s0");

  item = vector_get_last_item(v);
  assert_true(item == s2000, "item != s2000");

  vector_free(v);
}
void
test_vector_insert_item(void)
{
    do_test_insert(2);
}

void
test_vector_insert_item_here(void)
{
  do_test_insert(-1);
  do_test_insert(0);
  do_test_insert(1);
}

void
test_vector_delete_item(void)
{
  do_test_insert(3);
}

void
do_test_insert(const int rider)
{
  vector v = NULL;
  const vector_index len = 100;
  const vector_index ins = 50;
  vector_index i;
  char buf[10];
  vector_index check_end = len + 1;
  vector_index check_ins = ins;
  int check_shift = 1;

  switch(rider)
  {
  case -1:
    printf("test_vector_insert_here before\n");
    break;
  case 0:
    printf("test_vector_insert_here at\n");
    check_shift = 0;
    check_end = len;
    break;
  case 1:
    printf("test_vector_insert_here after\n");
    check_ins++;
    break;
  case 2:
    printf("test_vector_insert\n");
    break;
  case 3:
    printf("test_vector_delete\n");
    check_shift = -1;
    check_end = len - 1;
    break;
  }

  v = vector_init_new(v, 0);

  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%d", i);
    vector_set_item(v, i, strdup(buf));
  }

  switch(rider)
    {
    case -1:
    case 0:
    case 1:
      vector_insert_item_here(v, ins, rider, strdup(s1000));
      break;
    case 2:
      vector_insert_item(v, ins, strdup(s1000));
      break;
    case 3:
      free(vector_delete_item(v, ins));
      break;
    }

  assert_true(vector_end(v) == check_end, "vector_end(v) != check_end");

  /* check contents are correct */
  for (i = 0; i < check_ins; ++i)
    {
      sprintf(buf, "%d", i);
      assert_true(strcmp(vector_get_item(v, i), buf) == 0,
          "vector_get_item(v, i) != buf");
    }

  if (rider != 3)
    {
      assert_true(strcmp(vector_get_item(v, check_ins), s1000) == 0,
          "vector_get_item(v, check_ins) != s1000");
    }

  for (i = check_ins + 1; i < check_end; ++i)
    {
      sprintf(buf, "%d", i - check_shift);
      assert_true(strcmp(vector_get_item(v, i), buf) == 0, "vector_get_item(v, i) != buf");
    }

  /* free contents */
  for (i = 0; i < vector_end(v); ++i)
    {
      free(vector_slot(v, i));
    }

  vector_free(v);
}

void
test_vector_sort(void)
{
  vector v = NULL;
  int i;
  const int len = 100;
  char buf[10];

  printf("test_vector_sort\n");

  v = vector_init(0);

  vector_sort(v, sort_cmp);     /* null sort */

  /* initialize backwards, using width so that lexical = numerical order */
  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%9d", i);
    vector_set_index(v, len - i - 1, strdup(buf));
  }

  vector_sort(v, sort_cmp);

  /* check contents are correct */
  for (i = 0; i < len; ++i)
    {
      sprintf(buf, "%9d", i);
      assert_true(strcmp(vector_slot(v, i), buf) == 0, "vector_slot(v, i) != buf");
    }

  /* free contents */
  for (i = 0; i < len; ++i)
    {
      free(vector_slot(v, i));
    }

  vector_free(v);
}

int
sort_cmp(const void* const* a, const void* const* b)
{
  return strcmp(*a, *b);
}

void
test_vector_bsearch(void)
{
  vector v = NULL;
  int i;
  const int len = 2000;
  char buf[20];
  char target[20];
  vector_index target_index = 0;
  int result;
  vector_index index;

  printf("test_vector_bsearch\n");

  sprintf(target, "%9u", target_index);
  v = vector_init(0);

  index = vector_bsearch(v, sort_cmp, target, &result);     /* null search */
  assert_true(index == 0, "index != 0");
  assert_true(result == -1, "result != -1");

  /* initialize, using width so that lexical = numerical order */
  for (i = 0; i < len; ++i)
    {
      sprintf(buf, "%9d", i);
      vector_set_index(v, i, strdup(buf));
    }

  for (target_index = 0; target_index < (unsigned)len; ++target_index)
    {
      sprintf(target, "%9u", target_index);
      index = vector_bsearch(v, sort_cmp, target, &result);
      assert_true(index == target_index, "index != target_index");
      assert_true(result == 0, "result != 0");
      assert_true(strcmp(vector_get_item(v, index), target) == 0,
          "strcmp(vector_get_item(v, index), target)) != 0");
    }

  /* free contents */
  for (i = 0; i < len; ++i)
    {
      free(vector_slot(v, i));
    }

  vector_free(v);
}

void
test_vector_move_item_here(void)
{
  do_test_move_item_here(-1);
  do_test_move_item_here(0);
  do_test_move_item_here(1);
}

void
do_test_move_item_here(const int rider)
{
  vector v = NULL;
  const vector_index len = 100;
  const vector_index ins = 50;
  const vector_index src = 70;
  vector_index i;
  char buf[10];
  vector_index check_dest = 0;
  vector_index check_src = 0;
  vector_index check_end = 0;
  int check_shift = 0;
  p_vector_item dest_item = NULL;


  switch(rider)
  {
  case -1:
    printf("test_vector_move_here before\n");
    check_dest = ins;
    check_src = src;
    check_end = len;
    check_shift = 1;
    break;
  case 0:
    printf("test_vector_move_here at\n");
    check_dest = ins;
    check_src = src - 1;
    check_end = len - 1;
    check_shift = 0;
    break;
  case 1:
    printf("test_vector_move_here after\n");
    check_dest = ins + 1;
    check_src = src;
    check_end = len;
    check_shift = 1;
    break;
  }

  v = vector_init_new(v, 0);

  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%u", i);
    vector_set_item(v, i, strdup(buf));
  }

  dest_item = vector_get_item(v, ins); /* item to free if rider == 0 */

  vector_move_item_here(v, ins, rider, src);
  assert_true(vector_end(v) == check_end, "vector_end(v) != check_end");

  /* check contents are correct */

  /* from start to insertion point */
  for (i = 0; i < check_dest - 1; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v, i), buf) == 0,
          "vector_get_item(v, i) != buf");
    }

  /* at insertion point */
  sprintf(buf, "%u", src);
  assert_true(strcmp(vector_get_item(v, check_dest), buf) == 0,
      "vector_get_item(v, check_dest) != buf");

  /* from insertion point to src */
  for (i = check_dest + 1; i <= check_src; ++i)
    {
      sprintf(buf, "%u", i - check_shift);
      assert_true(strcmp(vector_get_item(v, i), buf) == 0, "vector_get_item(v, i) != buf");
    }

  /* from src to end */
  for (i = check_src + 1; i < check_end; ++i)
    {
      sprintf(buf, "%u", i - (check_shift - 1));
      assert_true(strcmp(vector_get_item(v, i), buf) == 0, "vector_get_item(v, i) != buf");
    }

  /* free contents */
  for (i = 0; i < vector_end(v); ++i)
    {
      free(vector_slot(v, i));
    }

  if (rider == 0)
    {
      free(dest_item);
    }

  vector_free(v);
}

void
test_vector_part_reverse(void)
{
  vector v = NULL;
  const vector_index len = 100;
  const vector_index rstart = 50;
  const vector_index rstop = 70;
  vector_index i;
  char buf[10];

  printf("test_vector_part_reverse\n");

  v = vector_init_new(v, 0);

  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%u", i);
    vector_set_item(v, i, strdup(buf));
  }

  vector_part_reverse(v, rstart, rstop - rstart);
  assert_true(vector_end(v) == len, "vector_end(v) != len");

  /* check contents are correct */

  /* before reversed section */
  for (i = 0; i < rstart - 1; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v, i), buf) == 0,
          "before reversed vector_get_item(v, i) != buf");
    }

  /* reversed section */
  for (i = rstart; i < rstop; ++i)
    {
      sprintf(buf, "%u", rstop - (i - rstart + 1));
      assert_true(strcmp(vector_get_item(v, i), buf) == 0,
          "reversed vector_get_item(v, i) != buf");
    }

  /* after reversed section */
  for (i = rstop; i < len; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v, i), buf) == 0,
          "after reversed vector_get_item(v, i) != buf");
    }

  /* free contents */
  for (i = 0; i < vector_end(v); ++i)
    {
      free(vector_slot(v, i));
    }

  vector_free(v);
}

void
test_vector_copy_here(void)
{
  vector v1 = NULL;
  vector v2 = NULL;
  vector_index i;
  const vector_index len = 100;
  char buf[10];

  printf("test_vector_copy_here\n");

  /* to help debug objects are strings of their index */
  v1 = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%u", i);
    vector_set_index(v1, i, strdup(buf));
  }

  v2 = vector_copy_here(v2, v1);
  assert_true(v2 != NULL, "v2 == NULL");
  assert_true(v1 != v2, "v1 == v2");

  /* check contents are the same */
  for (i = 0; i < len; ++i)
    {
      assert_true(vector_get_item(v1, i) == vector_get_item(v2, i), "v1 != v2");
    }

  /* free contents */
  for (i = 0; i < len; ++i)
    {
      free(vector_get_item(v1, i));
    }

  vector_free(v1);
  vector_free(v2);
}

void
test_vector_move_here(void)
{
  vector v1 = NULL;
  vector v2 = NULL;
  vector_index i;
  const vector_index len = 100;
  char buf[10];

  printf("test_vector_move_here\n");

  /* to help debug objects are strings of their index */
  v1 = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%u", i);
    vector_set_index(v1, i, strdup(buf));
  }

  v2 = vector_move_here(v2, v1);
  assert_true(v2 != NULL, "v2 == NULL");
  assert_true(v1 != v2, "v1 == v2");
  assert_true(vector_end(v1) == 0, "vector_end(v1) != 0");

  /* check contents are the same */
  for (i = 0; i < len; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v2, i), buf) == 0,
          "vector_get_item(v2, i) != buf");
    }

  /* free contents */
  for (i = 0; i < len; ++i)
    {
      free(vector_get_item(v2, i));
    }

  vector_free(v1);
  vector_free(v2);
}

void
test_vector_copy_append(void)
{
  vector v1 = NULL;
  vector v2 = NULL;
  vector_index i;
  const vector_index len = 100;
  char buf[10];

  printf("test_vector_copy_append\n");

  /* to help debug objects are strings of their index */
  v2 = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%u", i);
    vector_set_index(v2, i, strdup(buf));
  }

  v1 = vector_init(0);
  for (i = len; i < 2 * len; ++i)
  {
    sprintf(buf, "%u", i);
    vector_set_index(v1, i - len, strdup(buf));
  }

  v2 = vector_copy_append(v2, v1);
  assert_true(v2 != NULL, "v2 == NULL");
  assert_true(v1 != v2, "v1 == v2");
  assert_true(vector_end(v2) == 2 * len, "vector_end(v2) != 2 * len");

  /* check contents */
  for (i = 0; i < 2 * len; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v2, i), buf) == 0,
          "vector_get_item(v2, i) != buf");
    }

  /* free contents */
  for (i = 0; i < 2 * len; ++i)
    {
      free(vector_get_item(v2, i));
    }

  vector_free(v1);
  vector_free(v2);
}

void
test_vector_move_append(void)
{
  vector v1 = NULL;
  vector v2 = NULL;
  vector_index i;
  const vector_index len = 100;
  char buf[10];

  printf("test_vector_move_append\n");

  /* to help debug objects are strings of their index */
  v2 = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%u", i);
    vector_set_index(v2, i, strdup(buf));
  }

  v1 = vector_init(0);
  for (i = len; i < 2 * len; ++i)
  {
    sprintf(buf, "%u", i);
    vector_set_index(v1, i - len, strdup(buf));
  }

  v2 = vector_move_append(v2, v1);
  assert_true(v2 != NULL, "v2 == NULL");
  assert_true(v1 != v2, "v1 == v2");
  assert_true(vector_end(v2) == 2 * len, "vector_end(v2) != 2 * len");
  assert_true(vector_end(v1) == 0, "vector_end(v1) != 0");

  /* check contents */
  for (i = 0; i < 2 * len; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v2, i), buf) == 0,
          "vector_get_item(v2, i) != buf");
    }

  /* free contents */
  for (i = 0; i < 2 * len; ++i)
    {
      free(vector_get_item(v2, i));
    }

  vector_free(v1);
  vector_free(v2);
}

void
test_vector_insert(void)
{
  vector v = NULL;
  vector_index i;
  const vector_index len = 100;
  const vector_index istart = 50;
  const vector_index istop = 70;
  char buf[10];

  printf("test_vector_insert\n");

  /* to help debug objects are strings of their index */

  v = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%u", i);
    vector_set_index(v, i, strdup(buf));
  }

  vector_insert(v, istart, istop - istart);
  assert_true(vector_end(v) == len + (istop - istart),
      "vector_end(v) != len + (istop - istart)");

  /* check contents */
  for (i = 0; i < istart; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v, i), buf) == 0,
          "vector_get_item(v, i) != buf");
    }

  for (i = istart + 1; i < istop; ++i)
    {
      assert_true(vector_get_item(v, i) == NULL,
          "vector_get_item(v, i) != NULL");
    }

  for (i = istop; i < len + (istop - istart); ++i)
    {
      sprintf(buf, "%u", i - (istop - istart));
      assert_true(strcmp(vector_get_item(v, i), buf) == 0,
          "vector_get_item(v, i) != buf");
    }

  /* free contents */
  for (i = 0; i < len + (istop - istart); ++i)
    {
      free(vector_get_item(v, i));
    }

  vector_free(v);
}

void
test_vector_delete(void)
{
  vector v = NULL;
  vector_index i;
  const vector_index len = 100;
  const vector_index dstart = 50;
  const vector_index dstop = 70;
  char buf[10];

  printf("test_vector_delete\n");

  /* to help debug objects are strings of their index */

  v = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    if (i < dstart || i >= dstop)
      {
        sprintf(buf, "%u", i);
        vector_set_index(v, i, strdup(buf));
      }
    else
      {
        vector_set_index(v, i, s0);
      }
  }

  vector_delete(v, dstart, dstop - dstart);
  assert_true(vector_end(v) == len - (dstop - dstart),
      "vector_end(v) != len - (dstop - dstart)");

  /* check contents */
  for (i = 0; i < dstart; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v, i), buf) == 0,
          "vector_get_item(v, i) != buf");
    }

  for (i = dstart; i < len - (dstop - dstart); ++i)
    {
      sprintf(buf, "%u", i + (dstop - dstart));
      assert_true(strcmp(vector_get_item(v, i), buf) == 0,
          "vector_get_item(v, i) != buf");
    }

  /* free contents */
  for (i = 0; i < len - (dstop - dstart); ++i)
    {
      free(vector_get_item(v, i));
    }

  vector_free(v);
}

void
test_vector_discard(void)
{
  vector v = NULL;
  vector_index i;
  const vector_index len = 100;
  const vector_index dstart = 50;
  char buf[10];

  printf("test_vector_discard\n");

  /* to help debug objects are strings of their index */

  v = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    if (i < dstart)
      {
        sprintf(buf, "%u", i);
        vector_set_index(v, i, strdup(buf));
      }
    else
      {
        vector_set_index(v, i, s0);
      }
  }

  vector_discard(v, dstart);
  assert_true(vector_end(v) == dstart,
      "vector_end(v) != dstart");

  /* check contents */
  for (i = 0; i < dstart; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v, i), buf) == 0,
          "vector_get_item(v, i) != buf");
    }

  /* free contents */
  for (i = 0; i < dstart; ++i)
    {
      free(vector_get_item(v, i));
    }

  vector_free(v);
}

void
test_vector_sak(void)
{
  vector v1 = NULL;
  vector v2 = NULL;
  vector v3 = NULL;
  vector_index i;
  const vector_index len = 100;
  const vector_index sstart = 60;
  const vector_index sstop = 70;
  const vector_index dstart = 40;
  const vector_index dstop = 50;
  char buf[10];

  printf("test_vector_sak\n");

  /* to help debug objects are strings of their index */

  v2 = vector_init(0);
  v3 = vector_init(0);
  for (i = 0; i < len; ++i)
  {
    sprintf(buf, "%u", i);
    vector_set_index(v2, i, strdup(buf));
    vector_set_index(v3, i, strdup(buf));
  }

  v1 = vector_sak(1, v1, v2, dstart, dstop - dstart,
      v3, sstart, sstop - sstart, 0);
  assert_true(v1 != NULL, "v1 == NULL");

  assert_true(vector_end(v1) == (dstop - dstart),
      "vector_end(v1) != (dstop - dstart)");
  assert_true(vector_end(v2) == len,
      "vector_end(v2) != len");
  assert_true(vector_end(v3) == len,
      "vector_end(v3) != len");

  /* check contents v1 */
  for (i = 0; i < dstop - dstart; ++i)
    {
      sprintf(buf, "%u", i + dstart);
      assert_true(vector_get_item(v1, i) != NULL,
          "vector_get_item(v1, i) == NULL");
      assert_true(strcmp(vector_get_item(v1, i), buf) == 0,
          "vector_get_item(v1, i) != buf");
    }

  /* check contents v2 */
  for (i = 0; i < dstart; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v2, i), buf) == 0,
          "vector_get_item(v2, i) != buf");
    }
  for (i = dstart; i < dstop; ++i)
    {
      sprintf(buf, "%u", i - dstart + sstart);
      assert_true(strcmp(vector_get_item(v2, i), buf) == 0,
          "vector_get_item(v2, i) != buf");
    }
  for (i = dstop; i < len; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v2, i), buf) == 0,
          "vector_get_item(v2, i) != buf");
    }

  /* check contents v3 */
  for (i = 0; i < len; ++i)
    {
      sprintf(buf, "%u", i);
      assert_true(strcmp(vector_get_item(v3, i), buf) == 0,
          "vector_get_item(v3, i) != buf");
    }

  /* free contents */
  for (i = 0; i < len; ++i)
    {
      free(vector_get_item(v3, i));
    }

  vector_free(v1);
  vector_free(v2);
  vector_free(v3);
}
/*
 *  TODO
 *

vector_re_init
vector_reset
vector_ream
vector_sak
vector_chop
vector_decant
vector_extend_by_1

*/