ArrayFactoriesTest.c

Go to the documentation of this file.

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

/* <lalLaTeX>

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

A program to test create/destroy array routines.

\subsubsection*{Usage}
\begin{verbatim}
ArrayFactoriesTest [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
TYPECODECreateArray()
TYPECODEDestroyArray()
\end{verbatim}

\subsubsection*{Notes}

\vfill{\footnotesize\input{ArrayFactoriesTestCV}}

</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/AVFactories.h>

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

NRCSID( MAIN, "$Id: ArrayFactoriesTest.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 ZArrayFactoriesTest ( void )
{
  static UINT4   dims[3]    = { 1, 2, 4 };
  static UINT4   dbad[3]    = { 1, 0, 4 };
  UINT4Vector    dimLength  = { 3, dims };
  UINT4Vector    badLength1 = { 3, NULL };
  UINT4Vector    badLength2 = { 0, dims };
  UINT4Vector    badLength3 = { 3, dbad };
  static LALStatus  status;
  static COMPLEX16Array  *array;
  static COMPLEX16Array   astore;
  static COMPLEX16    datum;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALZCreateArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( COMPLEX16 ) );

  /* resize up */
  /*
   * dimLength.data[0] *= 2;
   * dimLength.data[1] *= 3;
   * dimLength.data[2] *= 4;
  */
  dims[0] *= 2;
  dims[1] *= 3;
  dims[2] *= 4;
  LALZResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( COMPLEX16 ) );
  
  /* resize down */
  dims[0] /= 2;
  dims[1] /= 3;
  dims[2] /= 2;
  LALZResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( COMPLEX16 ) );
  
  /* resize down again */
  dims[2] /= 2;
  LALZResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( COMPLEX16 ) );
  
  LALZDestroyArray ( &status, &array );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */


#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALZCreateArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALZResizeArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALZCreateArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALZResizeArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALZCreateArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALZResizeArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    LALCheckMemoryLeaks();

    LALZDestroyArray ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALZCreateArray ( &status, NULL, &dimLength );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALZResizeArray ( &status, NULL, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALZDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    array = &astore;
    LALZCreateArray ( &status, &array, &dimLength );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALZResizeArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1);

    LALZResizeArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1);

    LALZResizeArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1);

    LALZDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );

    array->data = &datum;
    LALZDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
    ClearStatus( &status );
  }

#else
  array = &astore;
  array->data = &datum;
  badLength1.data = NULL;
  badLength2.length = 0;
  badLength3.data = dbad;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALZCreateArray, LALZResizeArray, and LALZDestroyArray \n" );
          
  return;
}





















static void CArrayFactoriesTest ( void )
{
  static UINT4   dims[3]    = { 1, 2, 4 };
  static UINT4   dbad[3]    = { 1, 0, 4 };
  UINT4Vector    dimLength  = { 3, dims };
  UINT4Vector    badLength1 = { 3, NULL };
  UINT4Vector    badLength2 = { 0, dims };
  UINT4Vector    badLength3 = { 3, dbad };
  static LALStatus  status;
  static COMPLEX8Array  *array;
  static COMPLEX8Array   astore;
  static COMPLEX8    datum;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALCCreateArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( COMPLEX8 ) );

  /* resize up */
  /*
   * dimLength.data[0] *= 2;
   * dimLength.data[1] *= 3;
   * dimLength.data[2] *= 4;
  */
  dims[0] *= 2;
  dims[1] *= 3;
  dims[2] *= 4;
  LALCResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( COMPLEX8 ) );
  
  /* resize down */
  dims[0] /= 2;
  dims[1] /= 3;
  dims[2] /= 2;
  LALCResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( COMPLEX8 ) );
  
  /* resize down again */
  dims[2] /= 2;
  LALCResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( COMPLEX8 ) );
  
  LALCDestroyArray ( &status, &array );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */


#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALCCreateArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALCResizeArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALCCreateArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALCResizeArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALCCreateArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALCResizeArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    LALCheckMemoryLeaks();

    LALCDestroyArray ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALCCreateArray ( &status, NULL, &dimLength );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALCResizeArray ( &status, NULL, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALCDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    array = &astore;
    LALCCreateArray ( &status, &array, &dimLength );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALCResizeArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1);

    LALCResizeArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1);

    LALCResizeArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1);

    LALCDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );

    array->data = &datum;
    LALCDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
    ClearStatus( &status );
  }

#else
  array = &astore;
  array->data = &datum;
  badLength1.data = NULL;
  badLength2.length = 0;
  badLength3.data = dbad;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALCCreateArray, LALCResizeArray, and LALCDestroyArray \n" );
          
  return;
}





















static void DArrayFactoriesTest ( void )
{
  static UINT4   dims[3]    = { 1, 2, 4 };
  static UINT4   dbad[3]    = { 1, 0, 4 };
  UINT4Vector    dimLength  = { 3, dims };
  UINT4Vector    badLength1 = { 3, NULL };
  UINT4Vector    badLength2 = { 0, dims };
  UINT4Vector    badLength3 = { 3, dbad };
  static LALStatus  status;
  static REAL8Array  *array;
  static REAL8Array   astore;
  static REAL8    datum;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALDCreateArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( REAL8 ) );

  /* resize up */
  /*
   * dimLength.data[0] *= 2;
   * dimLength.data[1] *= 3;
   * dimLength.data[2] *= 4;
  */
  dims[0] *= 2;
  dims[1] *= 3;
  dims[2] *= 4;
  LALDResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( REAL8 ) );
  
  /* resize down */
  dims[0] /= 2;
  dims[1] /= 3;
  dims[2] /= 2;
  LALDResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( REAL8 ) );
  
  /* resize down again */
  dims[2] /= 2;
  LALDResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( REAL8 ) );
  
  LALDDestroyArray ( &status, &array );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */


#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALDCreateArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALDResizeArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALDCreateArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALDResizeArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALDCreateArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALDResizeArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    LALCheckMemoryLeaks();

    LALDDestroyArray ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALDCreateArray ( &status, NULL, &dimLength );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALDResizeArray ( &status, NULL, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALDDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    array = &astore;
    LALDCreateArray ( &status, &array, &dimLength );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALDResizeArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1);

    LALDResizeArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1);

    LALDResizeArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1);

    LALDDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );

    array->data = &datum;
    LALDDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
    ClearStatus( &status );
  }

#else
  array = &astore;
  array->data = &datum;
  badLength1.data = NULL;
  badLength2.length = 0;
  badLength3.data = dbad;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALDCreateArray, LALDResizeArray, and LALDDestroyArray \n" );
          
  return;
}





















static void SArrayFactoriesTest ( void )
{
  static UINT4   dims[3]    = { 1, 2, 4 };
  static UINT4   dbad[3]    = { 1, 0, 4 };
  UINT4Vector    dimLength  = { 3, dims };
  UINT4Vector    badLength1 = { 3, NULL };
  UINT4Vector    badLength2 = { 0, dims };
  UINT4Vector    badLength3 = { 3, dbad };
  static LALStatus  status;
  static REAL4Array  *array;
  static REAL4Array   astore;
  static REAL4    datum;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALSCreateArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( REAL4 ) );

  /* resize up */
  /*
   * dimLength.data[0] *= 2;
   * dimLength.data[1] *= 3;
   * dimLength.data[2] *= 4;
  */
  dims[0] *= 2;
  dims[1] *= 3;
  dims[2] *= 4;
  LALSResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( REAL4 ) );
  
  /* resize down */
  dims[0] /= 2;
  dims[1] /= 3;
  dims[2] /= 2;
  LALSResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( REAL4 ) );
  
  /* resize down again */
  dims[2] /= 2;
  LALSResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( REAL4 ) );
  
  LALSDestroyArray ( &status, &array );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */


#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALSCreateArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALSResizeArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALSCreateArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALSResizeArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALSCreateArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALSResizeArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    LALCheckMemoryLeaks();

    LALSDestroyArray ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALSCreateArray ( &status, NULL, &dimLength );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALSResizeArray ( &status, NULL, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALSDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    array = &astore;
    LALSCreateArray ( &status, &array, &dimLength );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALSResizeArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1);

    LALSResizeArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1);

    LALSResizeArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1);

    LALSDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );

    array->data = &datum;
    LALSDestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
    ClearStatus( &status );
  }

#else
  array = &astore;
  array->data = &datum;
  badLength1.data = NULL;
  badLength2.length = 0;
  badLength3.data = dbad;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALSCreateArray, LALSResizeArray, and LALSDestroyArray \n" );
          
  return;
}





















static void I2ArrayFactoriesTest ( void )
{
  static UINT4   dims[3]    = { 1, 2, 4 };
  static UINT4   dbad[3]    = { 1, 0, 4 };
  UINT4Vector    dimLength  = { 3, dims };
  UINT4Vector    badLength1 = { 3, NULL };
  UINT4Vector    badLength2 = { 0, dims };
  UINT4Vector    badLength3 = { 3, dbad };
  static LALStatus  status;
  static INT2Array  *array;
  static INT2Array   astore;
  static INT2    datum;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALI2CreateArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( INT2 ) );

  /* resize up */
  /*
   * dimLength.data[0] *= 2;
   * dimLength.data[1] *= 3;
   * dimLength.data[2] *= 4;
  */
  dims[0] *= 2;
  dims[1] *= 3;
  dims[2] *= 4;
  LALI2ResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( INT2 ) );
  
  /* resize down */
  dims[0] /= 2;
  dims[1] /= 3;
  dims[2] /= 2;
  LALI2ResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( INT2 ) );
  
  /* resize down again */
  dims[2] /= 2;
  LALI2ResizeArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );
  
  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( INT2 ) );
  
  LALI2DestroyArray ( &status, &array );
  TestStatus( &status, CODES( 0 ), 1 );

  LALCheckMemoryLeaks();


  /*
   *
   * Test error codes.
   *
   */


#ifndef LAL_NDEBUG

  if ( ! lalNoDebug )
  {
    LALI2CreateArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALI2ResizeArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALI2CreateArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALI2ResizeArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALI2CreateArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );

    LALI2ResizeArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1 );
    LALCheckMemoryLeaks();

    LALI2DestroyArray ( &status, NULL );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALI2CreateArray ( &status, NULL, &dimLength );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALI2ResizeArray ( &status, NULL, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1 );

    LALI2DestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    array = &astore;
    LALI2CreateArray ( &status, &array, &dimLength );
    TestStatus( &status, CODES( AVFACTORIESH_EUPTR ), 1 );

    LALI2ResizeArray ( &status, &array, &badLength1 );
    TestStatus( &status, CODES( AVFACTORIESH_EVPTR ), 1);

    LALI2ResizeArray ( &status, &array, &badLength2 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1);

    LALI2ResizeArray ( &status, &array, &badLength3 );
    TestStatus( &status, CODES( AVFACTORIESH_ELENGTH ), 1);

    LALI2DestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );

    array->data = &datum;
    LALI2DestroyArray ( &status, &array );
    TestStatus( &status, CODES( AVFACTORIESH_EDPTR ), 1 );
    ClearStatus( &status );
  }

#else
  array = &astore;
  array->data = &datum;
  badLength1.data = NULL;
  badLength2.length = 0;
  badLength3.data = dbad;
#endif

  LALCheckMemoryLeaks();
  printf( "PASS: tests of LALI2CreateArray, LALI2ResizeArray, and LALI2DestroyArray \n" );
          
  return;
}





















static void I4ArrayFactoriesTest ( void )
{
  static UINT4   dims[3]    = { 1, 2, 4 };
  static UINT4   dbad[3]    = { 1, 0, 4 };
  UINT4Vector    dimLength  = { 3, dims };
  UINT4Vector    badLength1 = { 3, NULL };
  UINT4Vector    badLength2 = { 0, dims };
  UINT4Vector    badLength3 = { 3, dbad };
  static LALStatus  status;
  static INT4Array  *array;
  static INT4Array   astore;
  static INT4    datum;


  /*
   *
   * Test ordinary behavior.
   *
   */


  LALI4CreateArray ( &status, &array, &dimLength );
  TestStatus( &status, CODES( 0 ), 1 );

  memset( array->data, 0, dims[0]*dims[1]*dims[2]*sizeof( INT4 ) );

  /* resize up */
  /*
   * dimLength.data[0] *= 2;
   * dimLength.data[1] *= 3;
   * dimLength.data[2] *= 4;
  */
  dims[0] *= 2;
  dims[1] *= 3;
  dims[2] *= 4;
  LALI4ResizeArray ( &status, &array, &dimLength );
  TestStatus( &status,