VectorSequenceFactoriesTest.c

Go to the documentation of this file.

/*************** <lalVerbatim file="VectorSequenceFactoriesTestCV"> ****
$Id: VectorSequenceFactoriesTest.m4,v 1.7 2001/03/04 22:37:11 jolien Exp $
**************** </lalVerbatim> ****************************************/

/* <lalLaTeX>

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

A program to test create/destroy vector sequence routines.

\subsubsection*{Usage}
\begin{verbatim}
VectorSequenceFactoriesTest [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
TYPECODECreateVectorSequence()
TYPECODEDestroyVectorSequence()
\end{verbatim}

\subsubsection*{Notes}

\vfill{\footnotesize\input{VectorSequenceFactoriesTestCV}}

</lalLaTeX> */

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

#include <lal/LALConfig.h>

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

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

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

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

NRCSID( MAIN, "$Id: VectorSequenceFactoriesTest.m4,v 1.7 2001/03/04 22:37:11 jolien 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);




















static void ZVectorSequenceFactoriesTest ( void )
{
  CreateVectorSequenceIn input   = { 2, 8 };
  CreateVectorSequenceIn badslen = { 0, 8 };
  CreateVectorSequenceIn badvlen = { 2, 0 };
  static LALStatus  status;
  static COMPLEX16VectorSequence  *sequence;
  static COMPLEX16VectorSequence   sstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALZCreateVectorSequence ( &status, &sequence, &input );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( sequence->data, 0, input.length*input.vectorLength*sizeof( COMPLEX16 ) );

  LALZDestroyVectorSequence ( &status, &sequence );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALZCreateVectorSequence ( &status, &sequence, &badslen );
    TestStatus( &status, CODES( SEQFACTORIESH_ESLENGTH ), 1 );

    LALZCreateVectorSequence ( &status, &sequence, &badvlen );
    TestStatus( &status, CODES( SEQFACTORIESH_EVLENGTH ), 1 );

    LALZCreateVectorSequence ( &status, &sequence, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EINPTR ), 1 );

    LALZDestroyVectorSequence ( &status, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALZCreateVectorSequence ( &status, NULL, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALZDestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    sequence = &sstore;
    LALZCreateVectorSequence ( &status, &sequence, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    LALZDestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EDPTR ), 1 );
  }

#else
  badslen.length = 0;
  badvlen.vectorLength = 0;
  sequence = &sstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALZCreateVectorSequence and LALZDestroyVectorSequence \n" );
          
  return;
}





















static void CVectorSequenceFactoriesTest ( void )
{
  CreateVectorSequenceIn input   = { 2, 8 };
  CreateVectorSequenceIn badslen = { 0, 8 };
  CreateVectorSequenceIn badvlen = { 2, 0 };
  static LALStatus  status;
  static COMPLEX8VectorSequence  *sequence;
  static COMPLEX8VectorSequence   sstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALCCreateVectorSequence ( &status, &sequence, &input );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( sequence->data, 0, input.length*input.vectorLength*sizeof( COMPLEX8 ) );

  LALCDestroyVectorSequence ( &status, &sequence );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALCCreateVectorSequence ( &status, &sequence, &badslen );
    TestStatus( &status, CODES( SEQFACTORIESH_ESLENGTH ), 1 );

    LALCCreateVectorSequence ( &status, &sequence, &badvlen );
    TestStatus( &status, CODES( SEQFACTORIESH_EVLENGTH ), 1 );

    LALCCreateVectorSequence ( &status, &sequence, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EINPTR ), 1 );

    LALCDestroyVectorSequence ( &status, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALCCreateVectorSequence ( &status, NULL, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALCDestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    sequence = &sstore;
    LALCCreateVectorSequence ( &status, &sequence, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    LALCDestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EDPTR ), 1 );
  }

#else
  badslen.length = 0;
  badvlen.vectorLength = 0;
  sequence = &sstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALCCreateVectorSequence and LALCDestroyVectorSequence \n" );
          
  return;
}





















static void DVectorSequenceFactoriesTest ( void )
{
  CreateVectorSequenceIn input   = { 2, 8 };
  CreateVectorSequenceIn badslen = { 0, 8 };
  CreateVectorSequenceIn badvlen = { 2, 0 };
  static LALStatus  status;
  static REAL8VectorSequence  *sequence;
  static REAL8VectorSequence   sstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALDCreateVectorSequence ( &status, &sequence, &input );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( sequence->data, 0, input.length*input.vectorLength*sizeof( REAL8 ) );

  LALDDestroyVectorSequence ( &status, &sequence );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALDCreateVectorSequence ( &status, &sequence, &badslen );
    TestStatus( &status, CODES( SEQFACTORIESH_ESLENGTH ), 1 );

    LALDCreateVectorSequence ( &status, &sequence, &badvlen );
    TestStatus( &status, CODES( SEQFACTORIESH_EVLENGTH ), 1 );

    LALDCreateVectorSequence ( &status, &sequence, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EINPTR ), 1 );

    LALDDestroyVectorSequence ( &status, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALDCreateVectorSequence ( &status, NULL, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALDDestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    sequence = &sstore;
    LALDCreateVectorSequence ( &status, &sequence, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    LALDDestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EDPTR ), 1 );
  }

#else
  badslen.length = 0;
  badvlen.vectorLength = 0;
  sequence = &sstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALDCreateVectorSequence and LALDDestroyVectorSequence \n" );
          
  return;
}





















static void SVectorSequenceFactoriesTest ( void )
{
  CreateVectorSequenceIn input   = { 2, 8 };
  CreateVectorSequenceIn badslen = { 0, 8 };
  CreateVectorSequenceIn badvlen = { 2, 0 };
  static LALStatus  status;
  static REAL4VectorSequence  *sequence;
  static REAL4VectorSequence   sstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALSCreateVectorSequence ( &status, &sequence, &input );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( sequence->data, 0, input.length*input.vectorLength*sizeof( REAL4 ) );

  LALSDestroyVectorSequence ( &status, &sequence );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALSCreateVectorSequence ( &status, &sequence, &badslen );
    TestStatus( &status, CODES( SEQFACTORIESH_ESLENGTH ), 1 );

    LALSCreateVectorSequence ( &status, &sequence, &badvlen );
    TestStatus( &status, CODES( SEQFACTORIESH_EVLENGTH ), 1 );

    LALSCreateVectorSequence ( &status, &sequence, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EINPTR ), 1 );

    LALSDestroyVectorSequence ( &status, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALSCreateVectorSequence ( &status, NULL, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALSDestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    sequence = &sstore;
    LALSCreateVectorSequence ( &status, &sequence, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    LALSDestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EDPTR ), 1 );
  }

#else
  badslen.length = 0;
  badvlen.vectorLength = 0;
  sequence = &sstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALSCreateVectorSequence and LALSDestroyVectorSequence \n" );
          
  return;
}





















static void I2VectorSequenceFactoriesTest ( void )
{
  CreateVectorSequenceIn input   = { 2, 8 };
  CreateVectorSequenceIn badslen = { 0, 8 };
  CreateVectorSequenceIn badvlen = { 2, 0 };
  static LALStatus  status;
  static INT2VectorSequence  *sequence;
  static INT2VectorSequence   sstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALI2CreateVectorSequence ( &status, &sequence, &input );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( sequence->data, 0, input.length*input.vectorLength*sizeof( INT2 ) );

  LALI2DestroyVectorSequence ( &status, &sequence );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALI2CreateVectorSequence ( &status, &sequence, &badslen );
    TestStatus( &status, CODES( SEQFACTORIESH_ESLENGTH ), 1 );

    LALI2CreateVectorSequence ( &status, &sequence, &badvlen );
    TestStatus( &status, CODES( SEQFACTORIESH_EVLENGTH ), 1 );

    LALI2CreateVectorSequence ( &status, &sequence, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EINPTR ), 1 );

    LALI2DestroyVectorSequence ( &status, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALI2CreateVectorSequence ( &status, NULL, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALI2DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    sequence = &sstore;
    LALI2CreateVectorSequence ( &status, &sequence, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    LALI2DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EDPTR ), 1 );
  }

#else
  badslen.length = 0;
  badvlen.vectorLength = 0;
  sequence = &sstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALI2CreateVectorSequence and LALI2DestroyVectorSequence \n" );
          
  return;
}





















static void I4VectorSequenceFactoriesTest ( void )
{
  CreateVectorSequenceIn input   = { 2, 8 };
  CreateVectorSequenceIn badslen = { 0, 8 };
  CreateVectorSequenceIn badvlen = { 2, 0 };
  static LALStatus  status;
  static INT4VectorSequence  *sequence;
  static INT4VectorSequence   sstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALI4CreateVectorSequence ( &status, &sequence, &input );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( sequence->data, 0, input.length*input.vectorLength*sizeof( INT4 ) );

  LALI4DestroyVectorSequence ( &status, &sequence );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALI4CreateVectorSequence ( &status, &sequence, &badslen );
    TestStatus( &status, CODES( SEQFACTORIESH_ESLENGTH ), 1 );

    LALI4CreateVectorSequence ( &status, &sequence, &badvlen );
    TestStatus( &status, CODES( SEQFACTORIESH_EVLENGTH ), 1 );

    LALI4CreateVectorSequence ( &status, &sequence, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EINPTR ), 1 );

    LALI4DestroyVectorSequence ( &status, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALI4CreateVectorSequence ( &status, NULL, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALI4DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    sequence = &sstore;
    LALI4CreateVectorSequence ( &status, &sequence, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    LALI4DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EDPTR ), 1 );
  }

#else
  badslen.length = 0;
  badvlen.vectorLength = 0;
  sequence = &sstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALI4CreateVectorSequence and LALI4DestroyVectorSequence \n" );
          
  return;
}





















static void I8VectorSequenceFactoriesTest ( void )
{
  CreateVectorSequenceIn input   = { 2, 8 };
  CreateVectorSequenceIn badslen = { 0, 8 };
  CreateVectorSequenceIn badvlen = { 2, 0 };
  static LALStatus  status;
  static INT8VectorSequence  *sequence;
  static INT8VectorSequence   sstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALI8CreateVectorSequence ( &status, &sequence, &input );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( sequence->data, 0, input.length*input.vectorLength*sizeof( INT8 ) );

  LALI8DestroyVectorSequence ( &status, &sequence );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALI8CreateVectorSequence ( &status, &sequence, &badslen );
    TestStatus( &status, CODES( SEQFACTORIESH_ESLENGTH ), 1 );

    LALI8CreateVectorSequence ( &status, &sequence, &badvlen );
    TestStatus( &status, CODES( SEQFACTORIESH_EVLENGTH ), 1 );

    LALI8CreateVectorSequence ( &status, &sequence, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EINPTR ), 1 );

    LALI8DestroyVectorSequence ( &status, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALI8CreateVectorSequence ( &status, NULL, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALI8DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    sequence = &sstore;
    LALI8CreateVectorSequence ( &status, &sequence, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    LALI8DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EDPTR ), 1 );
  }

#else
  badslen.length = 0;
  badvlen.vectorLength = 0;
  sequence = &sstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALI8CreateVectorSequence and LALI8DestroyVectorSequence \n" );
          
  return;
}





















static void U2VectorSequenceFactoriesTest ( void )
{
  CreateVectorSequenceIn input   = { 2, 8 };
  CreateVectorSequenceIn badslen = { 0, 8 };
  CreateVectorSequenceIn badvlen = { 2, 0 };
  static LALStatus  status;
  static UINT2VectorSequence  *sequence;
  static UINT2VectorSequence   sstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALU2CreateVectorSequence ( &status, &sequence, &input );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( sequence->data, 0, input.length*input.vectorLength*sizeof( UINT2 ) );

  LALU2DestroyVectorSequence ( &status, &sequence );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALU2CreateVectorSequence ( &status, &sequence, &badslen );
    TestStatus( &status, CODES( SEQFACTORIESH_ESLENGTH ), 1 );

    LALU2CreateVectorSequence ( &status, &sequence, &badvlen );
    TestStatus( &status, CODES( SEQFACTORIESH_EVLENGTH ), 1 );

    LALU2CreateVectorSequence ( &status, &sequence, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EINPTR ), 1 );

    LALU2DestroyVectorSequence ( &status, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALU2CreateVectorSequence ( &status, NULL, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALU2DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    sequence = &sstore;
    LALU2CreateVectorSequence ( &status, &sequence, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    LALU2DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EDPTR ), 1 );
  }

#else
  badslen.length = 0;
  badvlen.vectorLength = 0;
  sequence = &sstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALU2CreateVectorSequence and LALU2DestroyVectorSequence \n" );
          
  return;
}





















static void U4VectorSequenceFactoriesTest ( void )
{
  CreateVectorSequenceIn input   = { 2, 8 };
  CreateVectorSequenceIn badslen = { 0, 8 };
  CreateVectorSequenceIn badvlen = { 2, 0 };
  static LALStatus  status;
  static UINT4VectorSequence  *sequence;
  static UINT4VectorSequence   sstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALU4CreateVectorSequence ( &status, &sequence, &input );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( sequence->data, 0, input.length*input.vectorLength*sizeof( UINT4 ) );

  LALU4DestroyVectorSequence ( &status, &sequence );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALU4CreateVectorSequence ( &status, &sequence, &badslen );
    TestStatus( &status, CODES( SEQFACTORIESH_ESLENGTH ), 1 );

    LALU4CreateVectorSequence ( &status, &sequence, &badvlen );
    TestStatus( &status, CODES( SEQFACTORIESH_EVLENGTH ), 1 );

    LALU4CreateVectorSequence ( &status, &sequence, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EINPTR ), 1 );

    LALU4DestroyVectorSequence ( &status, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALU4CreateVectorSequence ( &status, NULL, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALU4DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    sequence = &sstore;
    LALU4CreateVectorSequence ( &status, &sequence, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    LALU4DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EDPTR ), 1 );
  }

#else
  badslen.length = 0;
  badvlen.vectorLength = 0;
  sequence = &sstore;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALU4CreateVectorSequence and LALU4DestroyVectorSequence \n" );
          
  return;
}





















static void U8VectorSequenceFactoriesTest ( void )
{
  CreateVectorSequenceIn input   = { 2, 8 };
  CreateVectorSequenceIn badslen = { 0, 8 };
  CreateVectorSequenceIn badvlen = { 2, 0 };
  static LALStatus  status;
  static UINT8VectorSequence  *sequence;
  static UINT8VectorSequence   sstore;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALU8CreateVectorSequence ( &status, &sequence, &input );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( sequence->data, 0, input.length*input.vectorLength*sizeof( UINT8 ) );

  LALU8DestroyVectorSequence ( &status, &sequence );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */

#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALU8CreateVectorSequence ( &status, &sequence, &badslen );
    TestStatus( &status, CODES( SEQFACTORIESH_ESLENGTH ), 1 );

    LALU8CreateVectorSequence ( &status, &sequence, &badvlen );
    TestStatus( &status, CODES( SEQFACTORIESH_EVLENGTH ), 1 );

    LALU8CreateVectorSequence ( &status, &sequence, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EINPTR ), 1 );

    LALU8DestroyVectorSequence ( &status, NULL );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALU8CreateVectorSequence ( &status, NULL, &input );
    TestStatus( &status, CODES( SEQFACTORIESH_EVPTR ), 1 );

    LALU8DestroyVectorSequence ( &status, &sequence );
    TestStatus( &status, CODES( SEQFACTORIESH_EUPTR ), 1 );

    sequence = &sstore;
    LALU8CreateVectorSequence ( &status, &sequence, &input );