c 语言的unite test

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define START_CAPACITY 4


/*
 * The vector_s encapsulates all the data required to manage the
 * dynamic array storage on which the vector is built.
 */
typedef struct vector_s {
  int * arr;			/* array of values (pointer to first element) */
  unsigned long len;		/* length of vector (number of actually stored values) */
  unsigned long cap;		/* current capacity (max length) */
} Vector;


/*
 * Initialization function, needs to be called once for each vector
 * instance, before it can be used.
 */
void vector_init (Vector * vec)
{
  vec->arr = NULL;
  vec->len = 0;
  vec->cap = 0;
}


/*
 * Cleanup function, has to be called after you're done with a vector
 * to give all used memory back to the operating system.
 */
void vector_destroy (Vector * vec)
{
  free (vec->arr);
  vec->arr = NULL;
  vec->len = 0;
  vec->cap = 0;
}


/*
 * Utility function to grow the capacity: it simply get doubled each
 * time you calll vector_grow. This function is called by the more
 * "user visible" functions like vector_append.
 *
 * \return zero on success.
 */
int vector_grow (Vector * vec)
{
  unsigned long newcap;
  int * newarr;
  
  if (0 == vec->cap) {
    
    vec->arr = malloc (START_CAPACITY * sizeof(*vec->arr));
    if (NULL == vec->arr)
      return -1;
    
    vec->cap = START_CAPACITY;
    
    return 0;
  }
  
  newcap = 2 * vec->cap;
  
  newarr = malloc (newcap * sizeof(*vec->arr));
  if (NULL == newarr)
    return -1;
  
  memcpy (newarr, vec->arr, vec->len * sizeof(*vec->arr));
  free (vec->arr);
  vec->arr = newarr;
  vec->cap = newcap;
  
  return 0;
}


/*
 * User function to append a value to the vector. It grows the
 * underlying array if necessary, using the vector_grow utility
 * function.
 *
 * \return zero on success.
 */
int vector_append (Vector * vec, int value)
{
  if (vec->len >= vec->cap) {
    if (0 != vector_grow (vec))
      return -1;
  }
  vec->arr[vec->len++] = value;
  return 0;
}


/*
 * Debugging function which prints the vector length and capacity,
 * followed by the values currently stored.
 */
void vector_dump (Vector * vec)
{
  unsigned long ii;
  printf ("[%2lu/%2lu]", vec->len, vec->cap);
  for (ii = 0; ii < vec->len; ++ii)
    printf (" %3d", vec->arr[ii]);
  for (/* keep ii */; ii < vec->cap; ++ii)
    printf (" xxx");
  printf ("\n");
}


/* **************************************************
 * * FILL IN THIS FUNCTION **************************
 * **************************************************
 *
 * User function to prepend a value to the beginning of a vector. In
 * other words, after prepending the value, vec->arr[0] will be that
 * value, and the previous contents will have been shifted one
 * position towards the end of the vector.
 *
 * \return zero on success.
 */
int vector_prepend (Vector * vec, int value)
{
  /*
    things to do in here:
    - if necessary, grow the vector
    - move each existing item one index towards the end
    - set the first item to the value given as argument
    - don't forget to check for errors and make appropriate return statements 
  */
  printf ("Please implement vector_prepend!\n");
  return -100;
}


/* **************************************************
 * * FILL IN THIS FUNCTION **************************
 * **************************************************
 *
 * User function to insert a value at a specified position into a
 * vector. In other words, after inserting the value at pos,
 * vec->arr[pos] will be that value, everything before pos will be
 * untouched, and everything after pos will have been shifted one
 * position towards the end of the vector.
 *
 * \return zero on success.
 */
int vector_insert (Vector * vec, unsigned long pos, int value)
{
  /*
    things to do in here:
    - check that pos is a valid index
    - if necessary, grow the vector
    - move the relevant part of existing items one index towards the end
    - set the item at the given position to the value given as argument
    - don't forget to check for errors and make appropriate return statements 
  */
  printf ("Please implement vector_insert!\n");
  return -100;
}


/* **************************************************
 * * FILL IN THIS FUNCTION **************************
 * **************************************************
 *
 * User function to remove an entry from the vector. In other words,
 * after removing the entry at pos, vec->arr[pos] will either be
 * invalid (if pos was the last entry) or it will be whatever used to
 * be at pos+1. All the values after the removed one will have been
 * moveed one step towards the beginning of the vector.
 *
 * \note This function does not shrink the capacity (that would be a
 * nice feature, but don't worry about that now).
 *
 * \return zero on success.
 */
int vector_remove (Vector * vec, unsigned long pos)
{
  /*
    things to do in here:
    - check that pos is a valid index
    - move the relevant part of existing items one index towards the beginning
    - don't forget to check for errors and make appropriate return statements 
  */
  printf ("Please implement vector_remove!\n");
  return -100;
}


/*
 * Unit test for the vector_append function. Runs some example
 * operations and checks that results are as expected, writing
 * messages to the terminal so that errors can be detected and
 * pinpointed.
 *
 * \return zero on success.
 */
int test_append (void)
{
  Vector vec;
  int ii;
  
  printf ("\nrunning test_append...\n");
  
  vector_init (&vec);
  printf ("initialized: ");
  vector_dump (&vec);
  
  for (ii = -3; ii < 10; ++ii) {
    if (0 != vector_append (&vec, ii)) {
      printf ("test_append ERROR: could not append %d\n", ii);
      vector_destroy (&vec);
      return -1;
    }
    printf ("appended %2d: ", ii);
    vector_dump (&vec);
  }
  
  for (ii = -3; ii < 10; ++ii)
    if (vec.arr[ii+3] != ii) {
      printf ("test_append ERROR: arr[%d] should be %d but is %d\n", ii+3, ii, vec.arr[ii+3]);
      vector_destroy (&vec);
      return -1;
    }
  
  printf ("test_append SUCCESS\n");
  
  vector_destroy (&vec);
  return 0;
}


/*
 * Unit test for the vector_prepend function. Runs some example
 * operations and checks that results are as expected, writing
 * messages to the terminal so that errors can be detected and
 * pinpointed.
 *
 * \return zero on success.
 */
int test_prepend (void)
{
  Vector vec;
  int ii;
  
  printf ("\nrunning test_prepend...\n");
  
  vector_init (&vec);
  printf ("initialized: ");
  vector_dump (&vec);
  
  for (ii = -3; ii < 10; ++ii) {
    if (0 != vector_prepend (&vec, ii)) {
      printf ("test_prepend ERROR: could not prepend %d\n", ii);
      vector_destroy (&vec);
      return -1;
    }
    printf ("prepended %2d: ", ii);
    vector_dump (&vec);
  }
  
  for (ii = 0; ii < 13; ++ii)
    if (vec.arr[ii] != 9-ii) {
      printf ("test_prepend ERROR: arr[%d] should be %d but is %d\n", ii, 9-ii, vec.arr[ii]);
      vector_destroy (&vec);
      return -1;
    }
  
  printf ("test_prepend SUCCESS\n");
  
  vector_destroy (&vec);
  return 0;
}


/*
 * Unit test for the vector_insert function. Runs some example
 * operations and checks that results are as expected, writing
 * messages to the terminal so that errors can be detected and
 * pinpointed.
 *
 * \return zero on success.
 */
int test_insert (void)
{
  static int const check[] = {
    102, 101, 209, 208, 207, 206, 205, 204, 203, 100, 99, 98, 97
  };
  static unsigned long const checklen = sizeof(check) / sizeof(*check);
  
  Vector vec;
  int ii;
  
  printf ("\nrunning test_insert...\n");
  
  vector_init (&vec);
  printf ("initialized: ");
  vector_dump (&vec);
  
  if (0 == vector_insert(&vec, 11, 42)) {
    printf ("test_insert ERROR: should not have been able to insert at invalid index\n");
    vector_destroy (&vec);
    return -1;
  }
  
  for (ii = -3; ii < 3; ++ii) {
    if (0 != vector_insert (&vec, 0, 100+ii)) {
      printf ("test_insert ERROR: could not insert %d at pos 0\n", 100+ii);
      vector_destroy (&vec);
      return -1;
    }
    printf ("inserted %3d at pos 0: ", 100+ii);
    vector_dump (&vec);
  }
  
  for (; ii < 10; ++ii) {
    if (0 != vector_insert (&vec, 2, 200+ii)) {
      printf ("test_insert ERROR: could not insert %d at pos 2\n", 200+ii);
      vector_destroy (&vec);
      return -1;
    }
    printf ("inserted %3d at pos 2: ", 200+ii);
    vector_dump (&vec);
  }
  
  if (checklen != vec.len) {
    printf ("test_insert ERROR: vector length should be %lu but is %lu\n", checklen, vec.len);
    vector_destroy (&vec);
    return -2;
  }
  
  for (ii = 0; ii < checklen; ++ii)
    if (vec.arr[ii] != check[ii]) {
      printf ("test_insert ERROR: arr[%d] should be %d but is %d\n", ii, check[ii], vec.arr[ii]);
      vector_destroy (&vec);
      return -1;
    }
  
  printf ("test_insert SUCCESS\n");
  
  vector_destroy (&vec);
  return 0;
}


/*
 * Unit test for the vector_remove function. Runs some example
 * operations and checks that results are as expected, writing
 * messages to the terminal so that errors can be detected and
 * pinpointed.
 *
 * \return zero on success.
 */
int test_remove (void)
{
  static unsigned long const remlist[] = { 9, 0, 4, 4 };
  static unsigned long const remlistlen = sizeof(remlist) / sizeof(*remlist);
  
  static int const check[] = { 101, 102, 103, 104, 107, 108 };
  static unsigned long const checklen = sizeof(check) / sizeof(*check);
  
  Vector vec;
  int ii;
  
  printf ("\nrunning test_remove...\n");
  
  vector_init (&vec);
  printf ("initialized: ");
  vector_dump (&vec);
  
  if (0 == vector_remove(&vec, 11)) {
    printf ("test_remove ERROR: should not have been able to remove at invalid index\n");
    vector_destroy (&vec);
    return -1;
  }
  
  for (ii = 0; ii < 10; ++ii) {
    if (0 != vector_append (&vec, 100+ii)) {
      printf ("test_remove ERROR: could not append %d\n", 100+ii);
      vector_destroy (&vec);
      return -1;
    }
    printf ("appended %2d: ", 100+ii);
    vector_dump (&vec);
  }
  
  for (ii = 0; ii < remlistlen; ++ii) {
    if (0 != vector_remove (&vec, remlist[ii])) {
      printf ("test_remove ERROR: could not remove pos %lu\n", remlist[ii]);
      vector_destroy (&vec);
      return -1;
    }
    printf ("removed pos %lu: ", remlist[ii]);
    vector_dump (&vec);
  }
  
  if (0 == vector_remove(&vec, vec.len)) {
    printf ("test_remove ERROR: should not have been able to remove beyond end\n");
    vector_destroy (&vec);
    return -1;
  }
  
  if (checklen != vec.len) {
    printf ("test_remove ERROR: vector length should be %lu but is %lu\n", checklen, vec.len);
    vector_destroy (&vec);
    return -2;
  }
  
  for (ii = 0; ii < checklen; ++ii)
    if (vec.arr[ii] != check[ii]) {
      printf ("test_remove ERROR: arr[%d] should be %d but is %d\n", ii, check[ii], vec.arr[ii]);
      vector_destroy (&vec);
      return -1;
    }
  
  printf ("test_remove SUCCESS\n");
  
  vector_destroy (&vec);
  return 0;
}


/*
 * The main function just calls all unit tests and prints a summary
 * message (success or failure).
 *
 * \return zero on success.
 */
int main (int argc, char ** argv)
{
  int ok = 1;
  if (0 != test_append())
    ok = 0;
  if (0 != test_prepend())
    ok = 0;
  if (0 != test_insert())
    ok = 0;
  if (0 != test_remove())
    ok = 0;
  
  if (ok) {
    printf ("\nall tests PASSED\n");
    return 0;
  }
  printf ("\none or more tests FAILED\n");
  return 1;
}