VectorFactoriesTest.c

Go to the documentation of this file.

/*************** <lalVerbatim file="VectorFactoriesTestCV"> ****
$Id: VectorFactoriesTest.m4,v 1.8 2003/09/29 00:33:24 dwchin Exp $
**************** </lalVerbatim> *******************************/

/* <lalLaTeX>

\subsection{Program \texttt{VectorFactoriesTest.c}}
\label{ss:VectorFactoriesTest.c}

A program to test create/destroy vector routines.

\subsubsection*{Usage}
\begin{verbatim}
VectorFactoriesTest [options]
Options:
  -h         print help
  -q         quiet: run silently
  -v         verbose: print extra information
  -d level   set lalDebugLevel to level
\end{verbatim}

\subsubsection*{Description}

\subsubsection*{Exit codes}
\begin{tabular}{|c|l|}
\hline
 Code & Explanation                   \\
\hline
\tt 0 & Success, normal exit.         \\
\tt 1 & Subroutine failed.            \\
\hline
\end{tabular}

\subsubsection*{Algorithm}

\subsubsection*{Uses}
\begin{verbatim}
lalDebugLevel
TYPECODECreateVector()
TYPECODEResizeVector()
TYPECODEDestroyVector()
\end{verbatim}

\subsubsection*{Notes}

\vfill{\footnotesize\input{VectorFactoriesTestCV}}

</lalLaTeX> */

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

#include <lal/LALConfig.h>
#include <lal/PrintVector.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#ifdef HAVE_GETOPT_H
#include <getopt.h>
#endif

#include <lal/LALStdlib.h>
#include <lal/AVFactories.h>

#define CODES_(x) #x
#define CODES(x) CODES_(x)

NRCSID( MAIN, "$Id: VectorFactoriesTest.m4,v 1.8 2003/09/29 00:33:24 dwchin Exp $" );

extern char *optarg;
extern int   optind;

int lalDebugLevel = 0;
int verbose    = 0;

static void
Usage (const char *program, int exitflag);

static void
ParseOptions (int argc, char *argv[]);

static void
TestStatus (LALStatus *status, const char *expectedCodes, int exitCode);

static void
ClearStatus (LALStatus *status);


/* -*- C -*- */




















static void ZVectorFactoriesTest ( void )
{
  const  UINT4   length = 16;
  static LALStatus  status;
  static COMPLEX16Vector  *vector = ( COMPLEX16Vector * )NULL;
  static COMPLEX16Vector   vstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALZCreateVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }
  
  memset( vector->data, 0, length*sizeof( COMPLEX16 ) );

  if (verbose)
    {
      LALZPrintVector ( vector );
    }
  

  /* Resize up */
  LALZResizeVector ( &status, &vector, length*3 );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }


  memset( vector->data, 0, length*sizeof( COMPLEX16 ) );
  
  if (verbose)
    {
      LALZPrintVector ( vector );
    }

  /* Resize down */
  LALZResizeVector ( &status, &vector, length*2 );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
      LALZPrintVector ( vector );
    }

  /* Destroy */
  LALZDestroyVector ( &status, &vector );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();
  
  /* Check the resize function with create/destroy */
  LALZResizeVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }

  memset( vector->data, 0, length*sizeof( COMPLEX16 ) );

  if (verbose)
    {
      LALZPrintVector ( vector );
    }

  LALZResizeVector ( &status, &vector, 0 );
  TestStatus( &status, CODES( 0 ), 1);

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    if (verbose)
      {
        printf("VFT line %d\n", __LINE__);
        printf("  vector = %#x\n", (unsigned int)vector);
      }
    
    LALZCreateVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALZResizeVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    
    LALZDestroyVector ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALZCreateVector ( &status, NULL, length );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALZDestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    vector = &vstore;
    LALZCreateVector ( &status, &vector, length );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALZDestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
  }

#else
  vector = &vstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALZCreateVector, LALZResizeVector, and LALZDestroyVector \n" );
          
  return;
}



/* -*- C -*- */




















static void CVectorFactoriesTest ( void )
{
  const  UINT4   length = 16;
  static LALStatus  status;
  static COMPLEX8Vector  *vector = ( COMPLEX8Vector * )NULL;
  static COMPLEX8Vector   vstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALCCreateVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }
  
  memset( vector->data, 0, length*sizeof( COMPLEX8 ) );

  if (verbose)
    {
      LALCPrintVector ( vector );
    }
  

  /* Resize up */
  LALCResizeVector ( &status, &vector, length*3 );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }


  memset( vector->data, 0, length*sizeof( COMPLEX8 ) );
  
  if (verbose)
    {
      LALCPrintVector ( vector );
    }

  /* Resize down */
  LALCResizeVector ( &status, &vector, length*2 );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
      LALCPrintVector ( vector );
    }

  /* Destroy */
  LALCDestroyVector ( &status, &vector );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();
  
  /* Check the resize function with create/destroy */
  LALCResizeVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }

  memset( vector->data, 0, length*sizeof( COMPLEX8 ) );

  if (verbose)
    {
      LALCPrintVector ( vector );
    }

  LALCResizeVector ( &status, &vector, 0 );
  TestStatus( &status, CODES( 0 ), 1);

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    if (verbose)
      {
        printf("VFT line %d\n", __LINE__);
        printf("  vector = %#x\n", (unsigned int)vector);
      }
    
    LALCCreateVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALCResizeVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    
    LALCDestroyVector ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALCCreateVector ( &status, NULL, length );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALCDestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    vector = &vstore;
    LALCCreateVector ( &status, &vector, length );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALCDestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
  }

#else
  vector = &vstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALCCreateVector, LALCResizeVector, and LALCDestroyVector \n" );
          
  return;
}



/* -*- C -*- */




















static void DVectorFactoriesTest ( void )
{
  const  UINT4   length = 16;
  static LALStatus  status;
  static REAL8Vector  *vector = ( REAL8Vector * )NULL;
  static REAL8Vector   vstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALDCreateVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }
  
  memset( vector->data, 0, length*sizeof( REAL8 ) );

  if (verbose)
    {
      LALDPrintVector ( vector );
    }
  

  /* Resize up */
  LALDResizeVector ( &status, &vector, length*3 );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }


  memset( vector->data, 0, length*sizeof( REAL8 ) );
  
  if (verbose)
    {
      LALDPrintVector ( vector );
    }

  /* Resize down */
  LALDResizeVector ( &status, &vector, length*2 );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
      LALDPrintVector ( vector );
    }

  /* Destroy */
  LALDDestroyVector ( &status, &vector );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();
  
  /* Check the resize function with create/destroy */
  LALDResizeVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }

  memset( vector->data, 0, length*sizeof( REAL8 ) );

  if (verbose)
    {
      LALDPrintVector ( vector );
    }

  LALDResizeVector ( &status, &vector, 0 );
  TestStatus( &status, CODES( 0 ), 1);

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    if (verbose)
      {
        printf("VFT line %d\n", __LINE__);
        printf("  vector = %#x\n", (unsigned int)vector);
      }
    
    LALDCreateVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALDResizeVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    
    LALDDestroyVector ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALDCreateVector ( &status, NULL, length );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALDDestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    vector = &vstore;
    LALDCreateVector ( &status, &vector, length );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALDDestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
  }

#else
  vector = &vstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALDCreateVector, LALDResizeVector, and LALDDestroyVector \n" );
          
  return;
}



/* -*- C -*- */




















static void SVectorFactoriesTest ( void )
{
  const  UINT4   length = 16;
  static LALStatus  status;
  static REAL4Vector  *vector = ( REAL4Vector * )NULL;
  static REAL4Vector   vstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALSCreateVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }
  
  memset( vector->data, 0, length*sizeof( REAL4 ) );

  if (verbose)
    {
      LALSPrintVector ( vector );
    }
  

  /* Resize up */
  LALSResizeVector ( &status, &vector, length*3 );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }


  memset( vector->data, 0, length*sizeof( REAL4 ) );
  
  if (verbose)
    {
      LALSPrintVector ( vector );
    }

  /* Resize down */
  LALSResizeVector ( &status, &vector, length*2 );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
      LALSPrintVector ( vector );
    }

  /* Destroy */
  LALSDestroyVector ( &status, &vector );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();
  
  /* Check the resize function with create/destroy */
  LALSResizeVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }

  memset( vector->data, 0, length*sizeof( REAL4 ) );

  if (verbose)
    {
      LALSPrintVector ( vector );
    }

  LALSResizeVector ( &status, &vector, 0 );
  TestStatus( &status, CODES( 0 ), 1);

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    if (verbose)
      {
        printf("VFT line %d\n", __LINE__);
        printf("  vector = %#x\n", (unsigned int)vector);
      }
    
    LALSCreateVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALSResizeVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    
    LALSDestroyVector ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALSCreateVector ( &status, NULL, length );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALSDestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    vector = &vstore;
    LALSCreateVector ( &status, &vector, length );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALSDestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
  }

#else
  vector = &vstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALSCreateVector, LALSResizeVector, and LALSDestroyVector \n" );
          
  return;
}



/* -*- C -*- */




















static void I2VectorFactoriesTest ( void )
{
  const  UINT4   length = 16;
  static LALStatus  status;
  static INT2Vector  *vector = ( INT2Vector * )NULL;
  static INT2Vector   vstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALI2CreateVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }
  
  memset( vector->data, 0, length*sizeof( INT2 ) );

  if (verbose)
    {
      LALI2PrintVector ( vector );
    }
  

  /* Resize up */
  LALI2ResizeVector ( &status, &vector, length*3 );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }


  memset( vector->data, 0, length*sizeof( INT2 ) );
  
  if (verbose)
    {
      LALI2PrintVector ( vector );
    }

  /* Resize down */
  LALI2ResizeVector ( &status, &vector, length*2 );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
      LALI2PrintVector ( vector );
    }

  /* Destroy */
  LALI2DestroyVector ( &status, &vector );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();
  
  /* Check the resize function with create/destroy */
  LALI2ResizeVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }

  memset( vector->data, 0, length*sizeof( INT2 ) );

  if (verbose)
    {
      LALI2PrintVector ( vector );
    }

  LALI2ResizeVector ( &status, &vector, 0 );
  TestStatus( &status, CODES( 0 ), 1);

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    if (verbose)
      {
        printf("VFT line %d\n", __LINE__);
        printf("  vector = %#x\n", (unsigned int)vector);
      }
    
    LALI2CreateVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALI2ResizeVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    
    LALI2DestroyVector ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALI2CreateVector ( &status, NULL, length );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALI2DestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    vector = &vstore;
    LALI2CreateVector ( &status, &vector, length );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALI2DestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
  }

#else
  vector = &vstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALI2CreateVector, LALI2ResizeVector, and LALI2DestroyVector \n" );
          
  return;
}



/* -*- C -*- */




















static void I4VectorFactoriesTest ( void )
{
  const  UINT4   length = 16;
  static LALStatus  status;
  static INT4Vector  *vector = ( INT4Vector * )NULL;
  static INT4Vector   vstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALI4CreateVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }
  
  memset( vector->data, 0, length*sizeof( INT4 ) );

  if (verbose)
    {
      LALI4PrintVector ( vector );
    }
  

  /* Resize up */
  LALI4ResizeVector ( &status, &vector, length*3 );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }


  memset( vector->data, 0, length*sizeof( INT4 ) );
  
  if (verbose)
    {
      LALI4PrintVector ( vector );
    }

  /* Resize down */
  LALI4ResizeVector ( &status, &vector, length*2 );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
      LALI4PrintVector ( vector );
    }

  /* Destroy */
  LALI4DestroyVector ( &status, &vector );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();
  
  /* Check the resize function with create/destroy */
  LALI4ResizeVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }

  memset( vector->data, 0, length*sizeof( INT4 ) );

  if (verbose)
    {
      LALI4PrintVector ( vector );
    }

  LALI4ResizeVector ( &status, &vector, 0 );
  TestStatus( &status, CODES( 0 ), 1);

  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector = %#x\n", (unsigned int)vector);
    }

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    if (verbose)
      {
        printf("VFT line %d\n", __LINE__);
        printf("  vector = %#x\n", (unsigned int)vector);
      }
    
    LALI4CreateVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALI4ResizeVector ( &status, &vector, 0 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    
    LALI4DestroyVector ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALI4CreateVector ( &status, NULL, length );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALI4DestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    vector = &vstore;
    LALI4CreateVector ( &status, &vector, length );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALI4DestroyVector ( &status, &vector );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
  }

#else
  vector = &vstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALI4CreateVector, LALI4ResizeVector, and LALI4DestroyVector \n" );
          
  return;
}



/* -*- C -*- */




















static void I8VectorFactoriesTest ( void )
{
  const  UINT4   length = 16;
  static LALStatus  status;
  static INT8Vector  *vector = ( INT8Vector * )NULL;
  static INT8Vector   vstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALI8CreateVector ( &status, &vector, length );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }
  
  memset( vector->data, 0, length*sizeof( INT8 ) );

  if (verbose)
    {
      LALI8PrintVector ( vector );
    }
  

  /* Resize up */
  LALI8ResizeVector ( &status, &vector, length*3 );
  TestStatus( &status, CODES( 0 ), 1 );
  
  if (verbose)
    {
      printf("VFT line %d:\n", __LINE__);
      printf("  vector->length = %d\n", vector->length);
    }


  memset( vector->data, 0, length*sizeof( INT8 ) );
  
  if (verbose)
    {
      LALI8PrintVector ( vector );
    }

  /* Resize down */
  LALI8ResizeVector ( &status, &vector, length*2 );
  TestStatus( &sta