Changeset 41171

Timestamp:

Nov 27, 2019, 11:57:38 AM (6 years ago)

Author:

eugene

Message:

updates to psLib tests

Location:

trunk/psLib

Files:

• src/sys/psString.c (modified) (1 diff)
• test/astro/tap_psTime_03.c (modified) (3 diffs)
• test/fft/tst_psImageFFT.c (deleted)
• test/fft/tst_psVectorFFT.c (deleted)
• test/sys/tap_psError.c (modified) (3 diffs)
• test/sys/tap_psLine.c (modified) (4 diffs)
• test/sys/tap_psMemory.c (modified) (34 diffs)
• test/sys/tap_psString.c (modified) (5 diffs)
• test/sys/tap_psTrace.c (modified) (10 diffs)
• test/sys/tst_psConfigure.c (deleted)
• test/sys/tst_psError.c (deleted)
• test/sys/tst_psLine.c (deleted)
• test/sys/tst_psMemory.c (deleted)
• test/sys/tst_psString.c (deleted)
• test/sys/tst_psTrace.c (deleted)
• test/types (modified) (1 prop)
• test/types/tap_psArguments_all.c (modified) (13 diffs)
• test/types/tap_psList_all.c (modified) (1 diff)
• test/types/tap_psMetadataConfigParse.c (modified) (2 diffs)
• test/types/tap_psMetadata_copying.c (modified) (4 diffs)
• test/types/tap_psMetadata_manip.c (modified) (1 diff)
• test/types/tst_psArguments.c (deleted)
• test/types/tst_psArray.c (deleted)
• test/types/tst_psBitSet.c (deleted)
• test/types/tst_psHash00.c (deleted)
• test/types/tst_psHash01.c (deleted)
• test/types/tst_psHash02.c (deleted)
• test/types/tst_psHash03.c (deleted)
• test/types/tst_psHash04.c (deleted)
• test/types/tst_psHash05.c (deleted)
• test/types/tst_psList.c (deleted)
• test/types/tst_psLookupTable_01.c (deleted)
• test/types/tst_psMetadataIO.c (deleted)
• test/types/tst_psMetadata_01.c (deleted)
• test/types/tst_psMetadata_02.c (deleted)
• test/types/tst_psMetadata_03.c (deleted)
• test/types/tst_psMetadata_04.c (deleted)
• test/types/tst_psMetadata_05.c (deleted)
• test/types/tst_psMetadata_06.c (deleted)
• test/types/tst_psMetadata_07.c (deleted)
• test/types/tst_psPixels.c (deleted)

trunk/psLib/src/sys/psString.c

@@ -107 +107 @@
 
     // Check the number of characters to copy is non-negative
+    // XXX need to limit nChar to < memtotal
     if (nChar < 0) {
         // Log error message and return NULL

trunk/psLib/test/astro/tap_psTime_03.c

@@ -494 +494 @@
             psFree(timeStr);
 
-            bool status = psTimeConvert(time, PS_TIME_TT);
+            psTimeConvert(time, PS_TIME_TT);
             timeStr = psTimeToISO(time);
             is_str(timeStr, testTimeBStrTT[i], "TT ISO string");
@@ -500 +500 @@
 
             // Verify UTC ISO string
-            status = psTimeConvert(time, PS_TIME_UTC);
+            psTimeConvert(time, PS_TIME_UTC);
             time->leapsecond = testTimeBLeapsecond[i];
             timeStr = psTimeToISO(time);
@@ -506 +506 @@
             psFree(timeStr);
 
-            status = psTimeConvert(time, PS_TIME_UT1);
+            psTimeConvert(time, PS_TIME_UT1);
             timeStr = psTimeToISO(time);
             is_str(timeStr, testTimeBStrUT1[i], "UT1 ISO string");

trunk/psLib/test/sys/tap_psError.c

@@ -324 +324 @@
 
         for (psS32 i = 0; i < numErr; i++) {
-            const char* desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+1+i);
-            ok(desc != NULL,
-                "psErrorCode didn't find registered error code.");
-
-            ok(strcmp(desc,errDesc[i].description) == 0,
-                "psErrorCode didn't return the proper description.  Got '%s', expected '%s'.", desc,errDesc[i].description);
-        }
-
-        /*
-            2. invoke psErrorCodeString with a static/builtin psLib error code. Verify:
+            const char *desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+1+i);
+            ok(desc, "psErrorCode found registered error code.");
+            ok(!strcmp(desc,errDesc[i].description), "psErrorCode returned the proper description.  Got '%s', expected '%s'.", desc, errDesc[i].description);
+        }
+
+        /* 2. invoke psErrorCodeString with a static/builtin psLib error code. Verify:
                 a. the result is correct.
         */
-        const char* desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES);
-        ok(desc != NULL, "psErrorCode didn't find static error code.");
-        ok(strcmp(desc,"error classes end marker") == 0,
-            "psErrorCode didn't return the proper description.  Got '%s', expected '%s'.",
-            desc,"error classes end marker");
+        const char *desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES);
+        ok(desc, "psErrorCode found static error code.");
+        ok(!strcmp(desc, "error classes end marker"), "psErrorCode returned the proper description.  Got '%s', expected '%s'.", desc, "error classes end marker");
 
         desc = psErrorCodeString(PS_ERR_NONE);
-        ok(desc != NULL,
-            "psErrorCode didn't find static error code.");
-        ok(strcmp(desc,"not an error") == 0,
-            "psErrorCode didn't return the proper description.  Got '%s', expected '%s'.",
-            desc,"not an error");
+        ok(desc, "psErrorCode found static error code.");
+        ok(!strcmp(desc,"not an error"), "psErrorCode returned the proper description.  Got '%s', expected '%s'.", desc, "not an error");
     
-        /*
-            3. invoke psErrorCodeString with an invalid code. Verify a NULL is returned.
-        */
+        /* 3. invoke psErrorCodeString with an invalid code. Verify a NULL is returned. */
         desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+numErr+1);
-        ok(desc == NULL,
-            "psErrorCode didn't return a NULL with a bogus input code.");
-
-        /*
-            4. invoke psErrorRegister with a NULL psErrorDescription. Verify that:
+        ok(!desc, "psErrorCode returns a NULL with a bogus input code.");
+
+        /* 4. invoke psErrorRegister with a NULL psErrorDescription. Verify that:
                 a. the execution does not cease.
                 b. an appropriate error is generated.
@@ -366 +353 @@
         psErr* err = psErrorLast();
         ok(err->code == PS_ERR_BAD_PARAMETER_NULL,
-        "psErrorCode didn't generate proper error code for NULL input.");
+        "psErrorCode generated proper error code for NULL input.");
 
         psFree(err);
@@ -377 +364 @@
         err = psErrorLast();
         ok(err->code == PS_ERR_NONE,
-            "psErrorCode generated an error for nErrors = 0.");
+            "psErrorCode did not generate an error for nErrors = 0.");
         psFree(err);
     }

trunk/psLib/test/sys/tap_psLine.c

@@ -23 +23 @@
     psLogSetLevel(PS_LOG_INFO);
 
-    //testLineAlloc()
+    // testLineAlloc()
     {
         psMemId id = psMemGetId();
         psLine *lineline = NULL;
         lineline = psLineAlloc(20);
-        ok(lineline->NLINE==20, "psLine set NLINE parameter during Allocation");
-        ok(lineline->Nline == 0, "psLine set Nline parameter during Allocation");
+        ok(lineline->NLINE == 20, "psLine set NLINE parameter during Allocation");
+        ok(lineline->Nline ==  0, "psLine set Nline parameter during Allocation");
         strncpy(lineline->line, "Hello World", 20);
-        ok(!strncmp(lineline->line, "Hello World", 20),
-            "psLine was stored a simple string!");
+        ok(!strncmp(lineline->line, "Hello World", 20), "psLine was stored a simple string!");
         psFree(lineline);
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
@@ -41 +40 @@
         psMemId id = psMemGetId();
         psLine *line = NULL;
-        //Return false for NULL input
+        // Return false for NULL input
         int okay = !psLineInit(line);
         ok(okay, "psLineInit.  Expected false for NULL psLine input");
-        //Allocate a line and return true on Init
+        // Allocate a line and return true on Init
         line = psLineAlloc(1);
         okay = psLineInit(line);
@@ -65 +64 @@
         int okay = psLineAdd(line, "Hello %s", "World");
         ok( okay, "psLineAdd.  Expected true for valid psLine input");
-        ok(line->NLINE == 20 && line->Nline == 11,
-            "psLineAdd failed to return the correct line parameters");
-        ok(!strncmp(line->line, "Hello World", 20),
-            "psLineAdd failed to store the correct line string.");
+        ok(line->NLINE == 20 && line->Nline == 11, "psLineAdd failed to return the correct line parameters");
+        ok(!strncmp(line->line, "Hello World", 20), "psLineAdd failed to store the correct line string.");
         psFree(line);
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
@@ -79 +76 @@
         psLine *line = NULL;
         //Return false for Null input line
-        ok(!psMemCheckLine(line),
-            "psMemCheckLine return false for NULL line input");
+        ok(!psMemCheckLine(line), "psMemCheckLine return false for NULL line input");
         line = psLineAlloc(1);
-        ok(psMemCheckLine(line),
-            "psMemCheckLine return true for valid line input");
+        ok(psMemCheckLine(line), "psMemCheckLine return true for valid line input");
         psFree(line);
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");

trunk/psLib/test/sys/tap_psMemory.c

@@ -41 +41 @@
     psLogSetFormat("HLNM");
     psLogSetLevel(PS_LOG_INFO);
-    plan_tests(46);
+    plan_tests(54);
 
     // TPFreeReferencedMemory()
@@ -79 +79 @@
     // the psMemExhaustedCallback.
     // XXXX: Skipping TPOutOfMemory() because of test abort failure
-    if (0) {
+    skip_start (1, 2, "Skipping TPOutOfMemory() because of test abort failure");
+    {
         psMemId id = psMemGetId();
         psS32 *mem[ 100 ];
@@ -88 +89 @@
         exhaustedCallbackCalled = 0;
         cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback );
-        #ifdef COMMENTED_OUT
+        // #ifdef COMMENTED_OUT
         // Don't include since intentionally aborts
         for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
@@ -99 +100 @@
             psFree( mem[ lcv ] );
         }
-        #endif
-        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
-    }
-
+        // #endif
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+    skip_end();
 
 
@@ -108 +109 @@
     // psRealloc shall call the psMemExhaustedCallback.
     // XXXX: Skipping TPReallocOutOfMemory() because of test abort failure
-    if (0) {
+    skip_start (1, 2, "Skipping TPReallocOutOfMemory() because of test abort failure");
+    {
         psMemId id = psMemGetId();
         psS32 *mem[ 100 ];
@@ -131 +133 @@
         ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     }
-
+    skip_end();
 
     // psAlloc shall allocate memory blocks writeable by caller.
@@ -236 +238 @@
     // TPcheckLeaks()
     // XXXX: Skipping TPcheckLeaks() because of test abort failure
-    if (0) {
+    skip_start (1, 6, "Skipping TPcheckLeaks() because of test abort failure");
+    {
         const psS32 numBuffers = 5;
         psS32* buffers[ 5 ];
@@ -288 +291 @@
         psFree(buffers[3]);
     }
+    skip_end();
 
 
@@ -304 +308 @@
         psArray *array = psArrayAlloc(100);
         int okay = psMemCheckType(PS_DATA_ARRAY,array);
-        if (!okay) {
-            psFree(array);
-        }
-        ok(okay, "psMemCheckArray in memCheckType");
-
-        ok(!psMemCheckType(PS_DATA_ARRAY, neg), "psMemCheckType with metadata input");
+        if (!okay) psFree(array);
+        ok(okay, "psMemCheckType PS_DATA_ARRAY in memCheckType");
+
+        ok(!psMemCheckType(PS_DATA_ARRAY, neg), "psMemCheckType PS_DATA_ARRAY with metadata input");
         psFree(array);
 
-        psBitSet *bits;
-        bits = psBitSetAlloc(100);
-        okay = psMemCheckType(PS_DATA_BITSET, bits);
-        if (!okay )
-            psFree(bits);
-        ok(okay, "psMemCheckBitSet in memCheckType");
-        ok(!psMemCheckType(PS_DATA_BITSET, negative), "psMemCheckType on psArray");
-        psFree(bits);
+        // XXX EAM 2019.11.08 : this data type no longer exists
+        // psBitSet *bits;
+        // bits = psBitSetAlloc(100);
+        // okay = psMemCheckType(PS_DATA_BITSET, bits);
+        // if (!okay ) psFree(bits);
+        // 
+        // ok(okay, "psMemCheckBitSet in memCheckType");
+        // ok(!psMemCheckType(PS_DATA_BITSET, negative), "psMemCheckType on psArray");
+        // psFree(bits);
 
         psCube *cube;
         cube = psCubeAlloc();
         okay = psMemCheckType(PS_DATA_CUBE, cube);
-        if (!okay )
-            psFree(cube);
+        if (!okay ) psFree(cube);
         ok(okay, "psMemCheckCube in memCheckType");
         psFree(cube);
@@ -335 +337 @@
         psFree(img);
         okay = psMemCheckType(PS_DATA_FITS, fits);
-        if (!okay )
-            psFree(fits);
+        if (!okay ) psFree(fits);
         ok(okay, "psMemCheckFits in memCheckType");
         psFitsClose(fits);
@@ -343 +344 @@
         hash = psHashAlloc(100);
         okay = psMemCheckType(PS_DATA_HASH, hash);
-        if (!okay )
-            psFree(hash);
+        if (!okay ) psFree(hash);
         ok(okay, "psMemCheckHash in memCheckType");
         psFree(hash);
@@ -351 +351 @@
         histogram = psHistogramAlloc(1.1, 2.2, 2);
         okay = psMemCheckType(PS_DATA_HISTOGRAM, histogram);
-        if (!okay )
-            psFree(histogram);
+        if (!okay ) psFree(histogram);
         ok(okay, "psMemCheckHistogram in memCheckType");
         psFree(histogram);
@@ -359 +358 @@
         image = psImageAlloc(5, 5, PS_TYPE_F32);
         okay = psMemCheckType(PS_DATA_IMAGE, image);
-        if (!okay )
-            psFree(image);
+        if (!okay ) psFree(image);
         ok(okay, "psMemCheckImage in memCheckType");
         psFree(image);
@@ -367 +365 @@
         kernel = psKernelAlloc(0, 1, 0, 1);
         okay = psMemCheckType(PS_DATA_KERNEL, kernel);
-        if (!okay )
-            psFree(kernel);
+        if (!okay ) psFree(kernel);
         ok(okay, "psMemCheckKernel in memCheckType");
         psFree(kernel);
@@ -375 +372 @@
         list = psListAlloc(NULL);
         okay = psMemCheckType(PS_DATA_LIST, list);
-        if (!okay )
-            psFree(list);
+        if (!okay ) psFree(list);
         ok(okay, "psMemCheckList in memCheckType");
         psFree(list);
@@ -385 +381 @@
         lookup = psLookupTableAlloc(file, format, 10);
         okay = psMemCheckType(PS_DATA_LOOKUPTABLE, lookup);
-        if (!okay )
-            psFree(lookup);
+        if (!okay ) psFree(lookup);
         ok(okay, "psMemCheckLookupTable in memCheckType");
         psFree(lookup);
@@ -393 +388 @@
         metadata = psMetadataAlloc();
         okay = psMemCheckType(PS_DATA_METADATA, metadata);
-        if (!okay )
-            psFree(metadata);
+        if (!okay ) psFree(metadata);
         ok(okay, "psMemCheckMetadata in memCheckType");
         psFree(metadata);
@@ -401 +395 @@
         metaItem = psMetadataItemAlloc("name", PS_DATA_S32, "COMMENT", 1);
         okay = psMemCheckType(PS_DATA_METADATAITEM, metaItem);
-        if (!okay )
-            psFree(metaItem);
+        if (!okay ) psFree(metaItem);
         ok(okay, "psMemCheckMetadataItem in memCheckType");
         psFree(metaItem);
 
         psMinimization *min;
-        min = psMinimizationAlloc(3, 0.1);
+        min = psMinimizationAlloc(3, 0.1, 1.0);
         okay = psMemCheckType(PS_DATA_MINIMIZATION, min);
-        if (!okay )
-            psFree(min);
+        if (!okay ) psFree(min);
         ok(okay, "psMemCheckMinimization in memCheckType");
         psFree(min);
@@ -417 +409 @@
         pixels = psPixelsAlloc(100);
         okay = psMemCheckType(PS_DATA_PIXELS, pixels);
-        if (!okay )
-            psFree(pixels);
+        if (!okay ) psFree(pixels);
         ok(okay, "psMemCheckPixels in memCheckType");
         psFree(pixels);
@@ -425 +416 @@
         plane = psPlaneAlloc();
         okay = psMemCheckType(PS_DATA_PLANE, plane);
-        if (!okay )
-            psFree(plane);
+        if (!okay ) psFree(plane);
         ok(okay, "psMemCheckPlane in memCheckType.");
         psFree(plane);
@@ -433 +423 @@
         planeDistort = psPlaneDistortAlloc(1, 1, 1, 1);
         okay =  psMemCheckType(PS_DATA_PLANEDISTORT, planeDistort);
-        if (!okay )
-            psFree(planeDistort);
+        if (!okay ) psFree(planeDistort);
         ok(okay, "psMemCheckPlaneDistort in memCheckType.");
         psFree(planeDistort);
@@ -441 +430 @@
         planeTransform = psPlaneTransformAlloc(1, 1);
         okay = psMemCheckType(PS_DATA_PLANETRANSFORM, planeTransform);
-        if (!okay )
-            psFree(planeTransform);
+        if (!okay ) psFree(planeTransform);
         ok(okay, "psMemCheckPlaneTransform in memCheckType");
         psFree(planeTransform);
@@ -449 +437 @@
         poly1 = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 2);
         okay = psMemCheckType(PS_DATA_POLYNOMIAL1D, poly1);
-        if (!okay )
-            psFree(poly1);
+        if (!okay ) psFree(poly1);
         ok(okay, "psMemCheckPolynomial1D in memCheckType");
         psFree(poly1);
@@ -457 +444 @@
         poly2 = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 2, 1);
         okay = psMemCheckType(PS_DATA_POLYNOMIAL2D, poly2);
-        if (!okay )
-            psFree(poly2);
+        if (!okay ) psFree(poly2);
         ok(okay, "psMemCheckPolynomial2D in memCheckType");
         psFree(poly2);
@@ -465 +451 @@
         poly3 = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 1);
         okay = psMemCheckType(PS_DATA_POLYNOMIAL3D, poly3);
-        if (!okay )
-            psFree(poly3);
+        if (!okay ) psFree(poly3);
         ok(okay, "psMemCheckPolynomial3D in memCheckType");
         psFree(poly3);
@@ -473 +458 @@
         poly4 = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 2, 1);
         okay = psMemCheckType(PS_DATA_POLYNOMIAL4D, poly4);
-        if (!okay )
-            psFree(poly4);
+        if (!okay ) psFree(poly4);
         ok(okay, "psMemCheckPolynomial4D in memCheckType");
         psFree(poly4);
@@ -481 +465 @@
         proj = psProjectionAlloc(1, 1, 2.1, 2.1, PS_PROJ_TAN);
         okay = psMemCheckType(PS_DATA_PROJECTION, proj);
-        if (!okay )
-            psFree(proj);
+        if (!okay ) psFree(proj);
         ok(okay, "psMemCheckProjection in memCheckType.");
         psFree(proj);
@@ -490 +473 @@
         scalar = psScalarAlloc(f64, PS_TYPE_F64);
         okay = psMemCheckType(PS_DATA_SCALAR, scalar);
-        if (!okay )
-            psFree(scalar);
+        if (!okay ) psFree(scalar);
         ok(okay, "psMemCheckScalar in memCheckType");
         psFree(scalar);
@@ -498 +480 @@
         sphere = psSphereAlloc();
         okay = psMemCheckType(PS_DATA_SPHERE, sphere);
-        if (!okay )
-            psFree(sphere);
+        if (!okay ) psFree(sphere);
         ok(okay, "psMemCheckSphere in memCheckType");
         psFree(sphere);
@@ -506 +487 @@
         sphereRot = psSphereRotAlloc(0, 0, 20);
         okay = psMemCheckType(PS_DATA_SPHEREROT, sphereRot);
-        if (!okay )
-            psFree(sphereRot);
+        if (!okay ) psFree(sphereRot);
         ok(okay, "psMemCheckSphereRot in memCheckType");
         psFree(sphereRot);
@@ -516 +496 @@
         spline = psSpline1DAlloc();
         okay = psMemCheckType(PS_DATA_SPLINE1D, spline);
-        if (!okay )
-            psFree(spline);
+        if (!okay ) psFree(spline);
         ok(okay, "psMemCheckSpline1D in memCheckType");
         psFree(spline);
@@ -524 +503 @@
         stats = psStatsAlloc(PS_STAT_MAX);
         okay = psMemCheckType(PS_DATA_STATS, stats);
-        if (!okay )
-            psFree(stats);
+        if (!okay ) psFree(stats);
         ok(okay, "psMemCheckStats in memCheckType");
         psFree(stats);
@@ -532 +510 @@
         time = psTimeAlloc(PS_TIME_UT1);
         okay = psMemCheckType(PS_DATA_TIME, time);
-        if (!okay )
-            psFree(time);
+        if (!okay ) psFree(time);
         ok(okay, "psMemCheckTime in memCheckType");
         psFree(time);
@@ -548 +525 @@
 }
 
-
 #if 0
 void TPmemCorruption( void )

trunk/psLib/test/sys/tap_psString.c

@@ -111 +111 @@
     {
         psMemId id = psMemGetId();
-        psS32   result = 0;
-        psS32   result1 = 0;
-        char  *strResult;
         char  *stringvalnocopy = "F A I L";
 
         // Test point #4 Verify empty string copy with length - psStringNCopy
-        strResult = psStringNCopy(stringvalnocopy, 0);
-        // Perform string compare and get sting length
-        result = strcmp(strResult, stringvalnocopy);
-        result1 = strlen(strResult);
-        ok(result != 0,
-             "test point #4 strcmp result = %d didn't expected %d",result,0);
+        char *strResult = psStringNCopy(stringvalnocopy, 0);
+
+        // Perform string compare and get string length
+        int result = strcmp(strResult, stringvalnocopy);
+        ok(result != 0, "test point #4 strcmp result = %d, expected %d", result, 4);
+
+        int resultLen = strlen(strResult);
+        ok(resultLen == 0, "test point #4 strcmp result = %d, expected %d", resultLen, 0);
+
         psFree(strResult);
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
@@ -149 +149 @@
     }
 
-// XXX This test needs to be modified to check for maximum size
-//     This will require a mod to psStringNCopy source to check for maximum size
-//
-//psS32 testStringCopy05()
-//{
-//    char  *strResult;
-//    char  stringval[20] = "E R R O R";
-//    psS32   negativeSize = -5;
-//
-//    // Test point #6 Copy string with negative size - psStringNCopy
-//    strResult = psStringNCopy(stringval, negativeSize);
-//    if ( strResult != NULL ) {
-//        fprintf(stderr,"Failed test point #6 return value = %p expected NULL\n",
-//                strResult);
-//        return 1;
-//    }
-//    // Memory should not have been allocated
-//
-//    return 0;
-//}
-
+    // XXX This test needs to be modified to check for maximum size
+    // This will require a mod to psStringNCopy source to check for maximum size
+
+    // psS32 testStringCopy05()
+    skip_start (1, 6, "Skipping psSTringNCopy() because of failure to test max value");
+    {
+      char  *strResult;
+      char  stringval[20] = "E R R O R";
+      psS32   negativeSize = -5;
+
+      // Test point #6 Copy string with negative size - psStringNCopy
+      strResult = psStringNCopy(stringval, negativeSize);
+      if ( strResult != NULL ) {
+        fprintf(stderr,"Failed test point #6 return value = %p expected NULL\n",
+                strResult);
+        return 1;
+      }
+      // Memory should not have been allocated
+    }
+    skip_end();
 
     // testStringCopy06()
@@ -200 +199 @@
     }
 
-#if 0
     // testStrAppend01()
     {
         psMemId id = psMemGetId();
-        char *str=NULL;
+        char *str = NULL;
         // test nonsensical invocations ...
         ssize_t sz = psStringAppend(NULL, NULL);
-        ok(sz == 0, "Failed test point");
+        ok(!sz, "append NULL string to NULL string");
         sz = psStringAppend(&str, NULL);
-        ok(sz == 0, "Failed test point");
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
-#endif
+        ok(!sz, "append NULL string to NULL string");
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
 
     // testStrAppend02()
@@ -251 +248 @@
     }
 
-#if 0
     // testStrPrepend01()
     {
@@ -263 +259 @@
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     }
-#endif
 
     // testStrPrepend02()

trunk/psLib/test/sys/tap_psTrace.c

@@ -2 +2 @@
     This code will test whether trace levels can be set successfully.
  
-    XXX: For the last two testpoints, must verify that the results are
-    correct, and put that verification in the test as well.
- *****************************************************************************/
+  XXX : various tests result in text sent to stdout -- these should go to a file 
+        or buffer and be validated against a truth set.
+
+  XXX : some of the error messages have the wrong sense (they report a negative result even if the test is successful)
+*****************************************************************************/
 #include <stdio.h>
 #include <fcntl.h>
@@ -20 +22 @@
 
 # define DEBUG 1
-# if (DEBUG)
+# if (!DEBUG)
     FILE *output = fopen ("/dev/null", "w");
     int outFD = fileno (output);
@@ -30 +32 @@
     {
         psMemId id = psMemGetId();
-        psS32 lev = 0;
-        (void)psTraceSetDestination(outFD);
-        for (int i=0;i<10;i++) {
-            (void)psTraceSetLevel(".", i);
-            lev = psTraceGetLevel(".");
-            ok(lev == i, "trace level was %d, actual was %d", i, lev);
-        }
-
-        (void)psTraceSetLevel(".", 3);
-        for (int i=5;i<10;i++) {
-            (void)psTraceSetLevel(".NODE00", i);
-            lev = psTraceGetLevel(".NODE00");
-            ok (lev == i,"(.NODE00) expected trace level was %d, actual was %d",
-                i, lev);
+        psTraceSetDestination(outFD);
+        for (int i = 0; i < 10; i++) {
+            psTraceSetLevel(".", i);
+            int lev = psTraceGetLevel(".");
+            ok (lev == i, "trace level was %d, actual was %d", i, lev);
+        }
+
+        psTraceSetLevel(".", 3);
+        for (int i = 5; i < 10;i++) {
+            psTraceSetLevel(".NODE00", i);
+            int lev1 = psTraceGetLevel(".NODE00");
+            ok (lev1 == i,"(.NODE00) expected trace level was %d, actual was %d", i, lev1);
     
-            lev = psTraceGetLevel(".");
-            ok (lev == 3,
-                "expected trace level was %d, actual was %d", i, 3);
+            int lev2 = psTraceGetLevel(".");
+            ok (lev2 == 3, "expected trace level was %d, actual was %d", 3, lev2);
         }
     
-        (void)psTraceSetLevel(".NODE00.NODE01", 4);
-        for (int i=0;i<10;i++) {
-            (void)psTraceSetLevel(".NODE00.NODE01", i);
-            lev = psTraceGetLevel(".NODE00.NODE01");
-            ok (lev == i,
-                "(.NODE00.NODE01) expected trace level was %d, actual was %d",
-                i, lev);
-        }
-
+        psTraceSetLevel(".NODE00.NODE01", 4);
+        for (int i = 0; i < 10; i++) {
+            psTraceSetLevel(".NODE00.NODE01", i);
+            int lev = psTraceGetLevel(".NODE00.NODE01");
+            ok (lev == i, "(.NODE00.NODE01) expected trace level was %d, actual was %d", i, lev);
+        }
         ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     }
@@ -64 +60 @@
 
     // testTrace01()
-    {
-        psMemId id = psMemGetId();
-        (void)psTraceSetDestination(outFD);
-        (void)psTraceSetLevel(".A.B.C.D.E", 5);
-        psTrace(".A.C.D.C",1,"You should not see this");
-        psTrace(".A.B.C.D.E",2,"You should see this");
-        psTrace(".A.B.C.D.E.F",3,"You should see this too");
-        psTracePrintLevels();
-        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
-    }
-
+    // XXX need to check the output on these as part of the test
+    {
+        psMemId id = psMemGetId();
+        psTraceSetDestination(outFD);
+        psTraceSetLevel(".A.B.C.D.E", 5);
+        psTrace(".A.C.D.C",     1, "You should not see this");
+        psTrace(".A.B.C.D.E",   2, "You should see this");
+        psTrace(".A.B.C.D.E.F", 3, "You should see this too");
+        psTracePrintLevels();
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 
     // testTrace02()
@@ -80 +76 @@
         psMemId id = psMemGetId();
         psTraceReset();
-        (void)psTraceSetDestination(outFD);
-        (void)psTraceSetLevel(".A.B", 2);
-        (void)psTraceSetLevel(".A.B.C.D.E", 5);
-        psTracePrintLevels();
-        (void)psTraceSetLevel(".A.B", 10);
-        psTracePrintLevels();
-
-        ok (10 == psTraceGetLevel(".A.B.C"),
-            ".A.B.C did not dynamically inherit a trace level (%d)",
-            psTraceGetLevel(".A.B.C"));
-
-        ok (10 == psTraceGetLevel(".A.B.C.D"),
-            ".A.B.C.D did not dynamically inherit a trace level (%d)",
-            psTraceGetLevel(".A.B.C.D"));
-
-        ok (5 == psTraceGetLevel(".A.B.C.D.E"),
-            ".A.B.C.D.E did dynamically inherit a trace level (%d)",
-            psTraceGetLevel(".A.B.C.D.E"));
-        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
-    }
-
+        psTraceSetDestination(outFD);
+        psTraceSetLevel(".A.B", 2);
+        psTraceSetLevel(".A.B.C.D.E", 5);
+        psTracePrintLevels();
+        psTraceSetLevel(".A.B", 10);
+        psTracePrintLevels();
+
+        ok (10 == psTraceGetLevel(".A.B.C"),     ".A.B.C did not dynamically inherit a trace level (%d)", psTraceGetLevel(".A.B.C"));
+        ok (10 == psTraceGetLevel(".A.B.C.D"),   ".A.B.C.D did not dynamically inherit a trace level (%d)", psTraceGetLevel(".A.B.C.D"));
+        ok ( 5 == psTraceGetLevel(".A.B.C.D.E"), ".A.B.C.D.E did dynamically inherit a trace level (%d)", psTraceGetLevel(".A.B.C.D.E"));
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 
     // testTrace03()
     {
         psMemId id = psMemGetId();
-        (void)psTraceSetDestination(outFD);
-
-        for (int i=0;i<10;i++) {
-            (void)psTraceSetLevel(".", i);
+        psTraceSetDestination(outFD);
+
+        for (int i = 0; i < 10; i++) {
+            psTraceSetLevel(".", i);
             psTraceReset();
             int lev = psTraceGetLevel(".");
-            ok (lev == PS_UNKNOWN_TRACE_LEVEL,
-                "expected trace level was %d, actual was %d",
-                PS_UNKNOWN_TRACE_LEVEL, lev);
-        }
-
-        (void)psTraceSetLevel(".", 5);
-        (void)psTraceSetLevel(".a", 4);
-        (void)psTraceSetLevel(".a.b", 3);
-        (void)psTraceSetLevel(".a.b.c", 2);
-        ok (!((5 != psTraceGetLevel(".")) ||
-              (4 != psTraceGetLevel(".a")) ||
-              (3 != psTraceGetLevel(".a.b")) ||
-              (2 != psTraceGetLevel(".a.b.c"))),
-            "trace successFlag = false;levels were not settable?");
-
-        psTraceReset();
-        ok (!((PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".")) ||
-              (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a")) ||
-              (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a.b")) ||
-              (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a.b.c"))),
-            "trace levels were not reset properly");
-        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
-    }
-
+            ok (lev == PS_UNKNOWN_TRACE_LEVEL, "expected trace level was %d, actual was %d", PS_UNKNOWN_TRACE_LEVEL, lev);
+        }
+
+        psTraceSetLevel(".", 5);
+        psTraceSetLevel(".a", 4);
+        psTraceSetLevel(".a.b", 3);
+        psTraceSetLevel(".a.b.c", 2);
+        ok (5 == psTraceGetLevel("."), "level 0");
+        ok (4 == psTraceGetLevel(".a"), "level 1");
+        ok (3 == psTraceGetLevel(".a.b"), "level 2");
+        ok (2 == psTraceGetLevel(".a.b.c"), "level 3");
+
+        psTraceReset();
+        ok (PS_UNKNOWN_TRACE_LEVEL == psTraceGetLevel("."), "trace levels were not reset properly");
+        ok (PS_UNKNOWN_TRACE_LEVEL == psTraceGetLevel(".a"), "trace levels were not reset properly");
+        ok (PS_UNKNOWN_TRACE_LEVEL == psTraceGetLevel(".a.b"), "trace levels were not reset properly");
+        ok (PS_UNKNOWN_TRACE_LEVEL == psTraceGetLevel(".a.b.c"), "trace levels were not reset properly");
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 
     // testTrace04()
@@ -140 +122 @@
         psMemId id = psMemGetId();
         int FD = creat("tst_psTrace02_OUT", 0666);
-        for (int nb = 0 ; nb<4;nb++) {
-            if (nb == 0)
-                (void)psTraceSetDestination(((outFD == 2) ? 1 : outFD));
-            if (nb == 1)
-                (void)psTraceSetDestination(((outFD == 2) ? 2 : outFD));
-            if (nb == 2)
-                (void)psTraceSetDestination(((outFD == 2) ? 0 : outFD));
-            if (nb == 3)
-                (void)psTraceSetDestination(FD);
-
-            (void)psTraceSetLevel(".", 4);
-            psTrace(".", 5, "(0) This message should not be displayed (%x)",
-                    0xbeefface);
-            (void)psTraceSetLevel(".", 7);
-            psTrace(".", 5, "(0) This message should be displayed (%x)",
-                    0xbeefface);
-
-            (void)psTraceSetLevel(".a", 4);
-            psTrace(".a", 5, "(1) This message should not be displayed (%x)",
-                    0xbeefface);
-            (void)psTraceSetLevel(".a", 7);
-            psTrace(".a", 5, "(1) This message should be displayed (%x)",
-                    0xbeefface);
-
-            (void)psTraceSetLevel(".a.b", 4);
-            psTrace(".a.b", 5, "(2) This message should not be displayed (%x)",
-                    0xbeefface);
-            (void)psTraceSetLevel(".a.b", 7);
-            psTrace(".a.b", 5, "(2) This message should be displayed (%x)",
-                    0xbeefface);
-            (void)psTraceSetLevel(".a.b.c", 12);
-            psTrace(".a.b.c", 11, "(3) This message should be displayed (%x)",
-                    0xbeefface);
+        for (int nb = 0; nb < 4; nb++) {
+            if (nb == 0) psTraceSetDestination(((outFD == 2) ? 1 : outFD));
+            if (nb == 1) psTraceSetDestination(((outFD == 2) ? 2 : outFD));
+            if (nb == 2) psTraceSetDestination(((outFD == 2) ? 0 : outFD));
+            if (nb == 3) psTraceSetDestination(FD);
+
+            psTraceSetLevel(".", 4);
+            psTrace(".", 5, "(0) This message should not be displayed (%x)", 0xbeefface);
+            psTraceSetLevel(".", 7);
+            psTrace(".", 5, "(0) This message should be displayed (%x)", 0xbeefface);
+
+            psTraceSetLevel(".a", 4);
+            psTrace(".a", 5, "(1) This message should not be displayed (%x)", 0xbeefface);
+            psTraceSetLevel(".a", 7);
+            psTrace(".a", 5, "(1) This message should be displayed (%x)", 0xbeefface);
+
+            psTraceSetLevel(".a.b", 4);
+            psTrace(".a.b", 5, "(2) This message should not be displayed (%x)", 0xbeefface);
+            psTraceSetLevel(".a.b", 7);
+            psTrace(".a.b", 5, "(2) This message should be displayed (%x)", 0xbeefface);
+
+            psTraceSetLevel(".a.b.c", 12);
+            psTrace(".a.b.c", 11, "(3) This message should be displayed (%x)", 0xbeefface);
         }
         close(FD);
@@ -182 +154 @@
     {
         psMemId id = psMemGetId();
-        (void)psTraceSetDestination(outFD);
-        (void)psTraceSetLevel(".", 9);
-        (void)psTraceSetLevel(".a", 8);
-        (void)psTraceSetLevel(".b", 7);
-        (void)psTraceSetLevel(".c", 5);
-        (void)psTraceSetLevel(".a.a", 4);
-        (void)psTraceSetLevel(".a.b", 3);
-        (void)psTraceSetLevel(".b.a", 2);
-        (void)psTraceSetLevel(".b.b", 1);
-        (void)psTraceSetLevel(".c.a", 0);
-        (void)psTraceSetLevel(".c.b", 3);
-        (void)psTraceSetLevel(".c.c", 5);
+        psTraceSetDestination(outFD);
+        psTraceSetLevel(".", 9);
+        psTraceSetLevel(".a", 8);
+        psTraceSetLevel(".b", 7);
+        psTraceSetLevel(".c", 5);
+        psTraceSetLevel(".a.a", 4);
+        psTraceSetLevel(".a.b", 3);
+        psTraceSetLevel(".b.a", 2);
+        psTraceSetLevel(".b.b", 1);
+        psTraceSetLevel(".c.a", 0);
+        psTraceSetLevel(".c.b", 3);
+        psTraceSetLevel(".c.c", 5);
         psTracePrintLevels();
         ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
@@ -202 +174 @@
     {
         psMemId id = psMemGetId();
-        (void)psTraceSetLevel(".", 9);
-        (void)psTraceSetLevel("a", 8);
-        (void)psTraceSetLevel("b", 7);
-        (void)psTraceSetLevel("c", 5);
-        (void)psTraceSetLevel("a.a", 4);
-        (void)psTraceSetLevel("a.b", 3);
-        (void)psTraceSetLevel("b.a", 2);
-        (void)psTraceSetLevel("b.b", 1);
-        (void)psTraceSetLevel("c.a", 0);
-        (void)psTraceSetLevel("c.b", 3);
-        (void)psTraceSetLevel("c.c", 5);
+        psTraceSetLevel(".", 9);
+        psTraceSetLevel("a", 8);
+        psTraceSetLevel("b", 7);
+        psTraceSetLevel("c", 5);
+        psTraceSetLevel("a.a", 4);
+        psTraceSetLevel("a.b", 3);
+        psTraceSetLevel("b.a", 2);
+        psTraceSetLevel("b.b", 1);
+        psTraceSetLevel("c.a", 0);
+        psTraceSetLevel("c.b", 3);
+        psTraceSetLevel("c.c", 5);
         psTracePrintLevels();
         ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
@@ -221 +193 @@
     {
         psMemId id = psMemGetId();
-        (void)psTraceSetDestination(outFD);
-        (void)psTraceSetLevel(".", 9);
-        (void)psTraceSetLevel(".a", 8);
-        (void)psTraceSetLevel(".b", 7);
-        (void)psTraceSetLevel(".c", 5);
-        (void)psTraceSetLevel(".a.a", 4);
-        (void)psTraceSetLevel(".a.b", 3);
-        (void)psTraceSetLevel(".b.a", 2);
-        (void)psTraceSetLevel(".b.b", 1);
-        (void)psTraceSetLevel(".c.a", 0);
-        (void)psTraceSetLevel(".c.b", 3);
-        (void)psTraceSetLevel(".c.c", 5);
-        psTraceReset();
-
-        if ((psTraceGetLevel(".")!=PS_UNKNOWN_TRACE_LEVEL) ||
-            (psTraceGetLevel(".a")!=PS_UNKNOWN_TRACE_LEVEL) ||
-            (psTraceGetLevel(".b")!=PS_UNKNOWN_TRACE_LEVEL) ||
-            (psTraceGetLevel(".c")!=PS_UNKNOWN_TRACE_LEVEL) ||
-            (psTraceGetLevel(".a.a")!=PS_UNKNOWN_TRACE_LEVEL) ||
-            (psTraceGetLevel(".a.b")!=PS_UNKNOWN_TRACE_LEVEL) ||
-            (psTraceGetLevel(".b.a")!=PS_UNKNOWN_TRACE_LEVEL) ||
-            (psTraceGetLevel(".b.b")!=PS_UNKNOWN_TRACE_LEVEL) ||
-            (psTraceGetLevel(".c.a")!=PS_UNKNOWN_TRACE_LEVEL) ||
-            (psTraceGetLevel(".c.b")!=PS_UNKNOWN_TRACE_LEVEL) ||
-            (psTraceGetLevel(".c.c")!=PS_UNKNOWN_TRACE_LEVEL)) {
-            return 1;
-        }
-        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
-    }
-
+        psTraceSetDestination(outFD);
+        psTraceSetLevel(".", 9);
+        psTraceSetLevel(".a", 8);
+        psTraceSetLevel(".b", 7);
+        psTraceSetLevel(".c", 5);
+        psTraceSetLevel(".a.a", 4);
+        psTraceSetLevel(".a.b", 3);
+        psTraceSetLevel(".b.a", 2);
+        psTraceSetLevel(".b.b", 1);
+        psTraceSetLevel(".c.a", 0);
+        psTraceSetLevel(".c.b", 3);
+        psTraceSetLevel(".c.c", 5);
+        psTraceReset();
+
+        // the reset should clear all of the levels above
+        ok (psTraceGetLevel(".")    == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+        ok (psTraceGetLevel(".a")   == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+        ok (psTraceGetLevel(".b")   == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+        ok (psTraceGetLevel(".c")   == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+        ok (psTraceGetLevel(".a.a") == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+        ok (psTraceGetLevel(".a.b") == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+        ok (psTraceGetLevel(".b.a") == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+        ok (psTraceGetLevel(".b.b") == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+        ok (psTraceGetLevel(".c.a") == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+        ok (psTraceGetLevel(".c.b") == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+        ok (psTraceGetLevel(".c.c") == PS_UNKNOWN_TRACE_LEVEL, "valid trace level");
+
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 
     // Ensure that the leading dot in the component names are optional.
@@ -257 +228 @@
         psMemId id = psMemGetId();
         psTraceReset();
-        (void)psTraceSetLevel(".", 9);
-        (void)psTraceSetLevel(".a", 8);
-        (void)psTraceSetLevel(".b", 7);
-        (void)psTraceSetLevel(".c", 5);
-        (void)psTraceSetLevel(".a.a", 4);
-        (void)psTraceSetLevel(".a.b", 3);
-        (void)psTraceSetLevel(".b.a", 2);
-        (void)psTraceSetLevel(".b.b", 1);
-        (void)psTraceSetLevel(".c.a", 0);
-        (void)psTraceSetLevel(".c.b", 3);
-        (void)psTraceSetLevel(".c.c", 5);
-        psTracePrintLevels();
-        if ((psTraceGetLevel(".")!=9) ||
-            (psTraceGetLevel("a")!=8) ||
-            (psTraceGetLevel("b")!=7) ||
-            (psTraceGetLevel("c")!=5) ||
-            (psTraceGetLevel("a.a")!=4) ||
-            (psTraceGetLevel("a.b")!=3) ||
-            (psTraceGetLevel("b.a")!=2) ||
-            (psTraceGetLevel("b.b")!=1) ||
-            (psTraceGetLevel("c.a")!=0) ||
-            (psTraceGetLevel("c.b")!=3) ||
-            (psTraceGetLevel("c.c")!=5)) {
-            printf("psTraceGetLevel(.) is %d", psTraceGetLevel("."));
-            printf("psTraceGetLevel(a) is %d", psTraceGetLevel("a"));
-            printf("psTraceGetLevel(b) is %d", psTraceGetLevel("b"));
-            printf("psTraceGetLevel(c) is %d", psTraceGetLevel("c"));
-            printf("psTraceGetLevel(a.a) is %d", psTraceGetLevel("a.a"));
-            printf("psTraceGetLevel(a.b) is %d", psTraceGetLevel("a.b"));
-            printf("psTraceGetLevel(b.a) is %d", psTraceGetLevel("b.a"));
-            printf("psTraceGetLevel(b.b) is %d", psTraceGetLevel("b.b"));
-            printf("psTraceGetLevel(c.a) is %d", psTraceGetLevel("c.a"));
-            printf("psTraceGetLevel(c.b) is %d", psTraceGetLevel("c.b"));
-            printf("psTraceGetLevel(c.c) is %d", psTraceGetLevel("c.c"));
-            return 1;
-        }
+        psTraceSetLevel(".", 9);
+        psTraceSetLevel(".a", 8);
+        psTraceSetLevel(".b", 7);
+        psTraceSetLevel(".c", 5);
+        psTraceSetLevel(".a.a", 4);
+        psTraceSetLevel(".a.b", 3);
+        psTraceSetLevel(".b.a", 2);
+        psTraceSetLevel(".b.b", 1);
+        psTraceSetLevel(".c.a", 0);
+        psTraceSetLevel(".c.b", 3);
+        psTraceSetLevel(".c.c", 5);
+        psTracePrintLevels();
+
+        ok(psTraceGetLevel(".")   == 9, "level is valid without first dot");
+        ok(psTraceGetLevel("a")   == 8, "level is valid without first dot");
+        ok(psTraceGetLevel("b")   == 7, "level is valid without first dot");
+        ok(psTraceGetLevel("c")   == 5, "level is valid without first dot");
+        ok(psTraceGetLevel("a.a") == 4, "level is valid without first dot");
+        ok(psTraceGetLevel("a.b") == 3, "level is valid without first dot");
+        ok(psTraceGetLevel("b.a") == 2, "level is valid without first dot");
+        ok(psTraceGetLevel("b.b") == 1, "level is valid without first dot");
+        ok(psTraceGetLevel("c.a") == 0, "level is valid without first dot");
+        ok(psTraceGetLevel("c.b") == 3, "level is valid without first dot");
+        ok(psTraceGetLevel("c.c") == 5, "level is valid without first dot");
+
         ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     }

trunk/psLib/test/types

@@ -75 +75 @@
 tap_psMetadataOverlay
 tap_psTree
+tap_psBits_all

@@ -75 +75 @@
 tap_psMetadataOverlay
 tap_psTree
+tap_psBits_all

trunk/psLib/test/types/tap_psArguments_all.c

@@ -37 +37 @@
         int argc = 5;
 
-        // Try to get an argument's position
-        int i = psArgumentGet(argc, argv, "-float");
-        {
-            ok( i == 3,
-                "psArgumentGet:         return correct location of input argument.");
-        }
-
-        // Return 0 for attempting to get from a NULL input argument.
-        {
-            ok( psArgumentGet(argc, NULL, "-float") == 0,
-                "psArgumentGet:         return 0 for a NULL input argument.");
-        }
-
-        // Return 0 for attempting to find a NULL string
-        {
-            ok( psArgumentGet(argc, argv, NULL) == 0,
-                "psArgumentGet:         return 0 for a NULL input string.");
-        }
-
-        // Return 0 for attempting to find an empty string
-        {
-            ok( psArgumentGet(argc, argv, "") == 0,
-                "psArgumentGet:         return 0 for an empty input string.");
-        }
-
-        // Return 0 for attempting to get an argument that doesn't match
-        {
-            ok( psArgumentGet(argc, argv, "-xxx") == 0,
-                "psArgumentGet:         return 0 for an empty input string.");
-        }
-
-        // Return false for attempting to remove argnum = 0
-        {
-            ok( !psArgumentRemove(0, &argc, argv),
-                "psArgumentRemove:      return false for argnum = 0.");
-        }
-
-        // Return false for attempting to remove NULL argc
-        {
-            ok( !psArgumentRemove(0, NULL, argv),
-                "psArgumentRemove:      return false for NULL argc.");
-        }
+        // define a simple fake argument list : this is not modified
+        char *argvBad[5];
+        argvBad[0] = "./program";
+        argvBad[1] = "-string";
+        argvBad[2] = "new";
+        argvBad[3] = "-test";
+        argvBad[4] = "6.66";
+        int argcBad = 5;
 
         // simple argument definitions for comparison
@@ -86 +52 @@
         psMetadataAdd(args, PS_LIST_TAIL, "-double", PS_DATA_F64, "Test Double", 0.666);
 
+        ok( psArgumentGet(argc, argv, "-float") == 3, "psArgumentGet: return correct location of input argument.");
+        ok( psArgumentGet(argc, NULL, "-float") == 0, "psArgumentGet: return 0 for a NULL input argument.");
+
+        ok( psArgumentGet(argc, argv, NULL) == 0, "psArgumentGet: return 0 for a NULL input string.");
+        ok( psArgumentGet(argc, argv, "")   == 0, "psArgumentGet: return 0 for an empty input string.");
+
+        ok( psArgumentGet(argc, argv, "-xxx") == 0, "psArgumentGet: return 0 for an unmatched input string.");
+
+        ok( !psArgumentRemove(0, &argc, argv), "psArgumentRemove: return false for argnum = 0.");
+        ok( !psArgumentRemove(0, NULL, argv), "psArgumentRemove: return false for NULL argc.");
+
         // psArgumentParse tests
-        // Return false for NULL input arguments
-        {
-            ok( !psArgumentParse(NULL, &argc, argv),
-                "psArgumentParse:       return false for NULL argument metadata input.");
-        }
-
-        // Return false for NULL input argc
-        {
-            ok( !psArgumentParse(args, NULL, argv),
-                "psArgumentParse:       return false for NULL argc input.");
-        }
-
-        // Return false for NULL input argv
-        {
-            ok( !psArgumentParse(args, &argc, NULL),
-                "psArgumentParse:       return false for NULL argv input.");
-        }
-
-        // Return false for argc = 0
-        {
-            int tempc = 0;
-            ok( !psArgumentParse(args, &tempc, argv),
-                "psArgumentParse:       return false for argc = 1 input.");
-        }
-
-        // Return false for string not found in metadata arguments
-        {
-            // define a simple fake argument list : this is not modified
-            char *argvBad[5];
-            argvBad[0] = "./program";
-            argvBad[1] = "-string";
-            argvBad[2] = "new";
-            argvBad[3] = "-test";
-            argvBad[4] = "6.66";
-            int argcBad = 5;
-
-            ok( !psArgumentParse(args, &argcBad, argvBad),
-                "psArgumentParse:      return false for argv containing unspecified input.");
-        }
-
-        // Check for Memory leaks
-        {
-            psFree(args);
-            checkMem();
-        }
+        ok( !psArgumentParse(NULL, &argc, argv), "psArgumentParse: return false for NULL argument metadata input.");
+        ok( !psArgumentParse(args, NULL, argv),  "psArgumentParse: return false for NULL argc input.");
+        ok( !psArgumentParse(args, &argc, NULL), "psArgumentParse: return false for NULL argv input.");
+
+        int tempc = 0;
+        ok( !psArgumentParse(args, &tempc, argv), "psArgumentParse: return false for argc = 0 input.");
+        ok( !psArgumentParse(args, &argcBad, argvBad), "psArgumentParse: return false for argv containing unspecified input.");
+
+        psFree(args);
         ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     }
@@ -195 +136 @@
         ok( psArgumentParse(args, &argc, argv), "psArgumentParse:      return true for valid inputs.");
 
+        // XXX does not check the results...
+
         // Check for Memory leaks
         psFree(args);
@@ -221 +164 @@
             argv[0] = "./program";
             argv[1] = "-string";
-            ok( !psArgumentParse(tempArg, &argc, argv),
-                "psArgumentParse:      return false for inconsistent argc.");
+            ok( !psArgumentParse(tempArg, &argc, argv), "psArgumentParse: return false for inconsistent argc.");
             psFree(tempArg);
+            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
         }
 
@@ -240 +183 @@
             argv[0] = "./program";
             argv[1] = "-string";
-            ok( !psArgumentParse(args, &argc, argv),
-                "psArgumentParse:      return false for incomplete string syntax.");
+            ok( !psArgumentParse(args, &argc, argv), "psArgumentParse: return false for incomplete string syntax.");
         }
 
@@ -251 +193 @@
             argv[1] = "-multi";
             argv[2] = "2";
-            ok( psArgumentParse(args, &argc, argv),
-                "psArgumentParse:      return true for MULTI.");
+            ok( psArgumentParse(args, &argc, argv), "psArgumentParse: return true for MULTI.");
         }
 
         // Check for Memory leaks
-        {
-            psFree(args);
-            checkMem();
-        }
+        psFree(args);
         ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     }
@@ -269 +207 @@
         {
             int argc = 1;
-            ok( psArgumentVerbosity(&argc, NULL) == 2,
-                "psArgumentVerbosity:  return 2 for NULL argument input.");
+            ok( psArgumentVerbosity(&argc, NULL) == 2, "psArgumentVerbosity: return 2 for NULL argument input.");
         }
 
@@ -277 +214 @@
             char *argv[1];
             argv[0] = "./program";
-            ok( psArgumentVerbosity(NULL, argv) == 2,
-                "psArgumentVerbosity:  return 2 for NULL argument input.");
+            ok( psArgumentVerbosity(NULL, argv) == 2, "psArgumentVerbosity: return 2 for NULL argument input.");
         }
 
@@ -287 +223 @@
             argv[0] = "./program";
             argv[1] = "-v";
-            ok( psArgumentVerbosity(&argc, argv) == 3,
-                "psArgumentVerbosity:  return 3 for '-v' argument input.");
+            ok( psArgumentVerbosity(&argc, argv) == 3, "psArgumentVerbosity:  return 3 for '-v' argument input.");
         }
 
@@ -297 +232 @@
             argv[0] = "./program";
             argv[1] = "-vv";
-            ok( psArgumentVerbosity(&argc, argv) == 4,
-                "psArgumentVerbosity:  return 4 for '-vv' argument input.");
+            ok( psArgumentVerbosity(&argc, argv) == 4, "psArgumentVerbosity:  return 4 for '-vv' argument input.");
         }
 
@@ -307 +241 @@
             argv[0] = "./program";
             argv[1] = "-vvv";
-            ok( psArgumentVerbosity(&argc, argv) == 5,
-                "psArgumentVerbosity:  return 5 for '-vvv' argument input.");
+            ok( psArgumentVerbosity(&argc, argv) == 5, "psArgumentVerbosity:  return 5 for '-vvv' argument input.");
         }
 
@@ -359 +292 @@
         {
             // this function sends output to the screen or /dev/null (i
-            # if (!DEBUG)
+# if (!DEBUG)
             FILE *f = fopen ("/dev/null", "w");
             int fd = fileno(f);
             psTraceSetDestination (fd);
-            # endif
+# endif
 
             int argc = 2;
@@ -374 +307 @@
         ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     }
+
+    /** EAM 2019.11.09 this section is commented out because these functions do not exist
+    void testLogTraceArguments(void)
+    {
+        note("  >>>Test 3:  psLogArguments & psTraceArguments Fxns");
+ 
+        // Return 2 (default) for NULL arguments input
+        {
+            int argc = 4;
+            ok( psLogArguments(&argc, NULL) == 2, "psLogArguments: return 2 for NULL argument input.");
+        }
+
+        // Return 2 (default) for NULL argc input
+        {
+            char *argv[1];
+            argv[0] = "./program";
+            ok( psLogArguments(NULL, argv) == 2, "psLogArguments: return 2 for NULL argc input.");
+        }
+
+        // Return 3 for "-v" option
+        {
+            int argc = 2;
+            char *argv[2];
+            argv[0] = "./program";
+            argv[1] = "-v";
+            ok( psLogArguments(&argc, argv) == 3, "psLogArguments: return 3 for '-v' argument input.");
+        }
+
+        // Return 4 for "-vv" option
+        {
+            int argc = 2;
+            char *argv[2];
+            argv[0] = "./program";
+            argv[1] = "-vv";
+            ok( psLogArguments(&argc, argv) == 4, "psLogArguments: return 4 for '-vv' argument input.");
+        }
+
+        // Return 5 for "-vvv" option
+        {
+            int argc = 2;
+            char *argv[2];
+            argv[0] = "./program";
+            argv[1] = "-vvv";
+            ok( psLogArguments(&argc, argv) == 5, "psLogArguments: return 5 for '-vvv' argument input.");
+        }
+
+        // Return 2 for "-logfmt" option
+        {
+            int argc = 2;
+            char *argv[2];
+            argv[0] = "./program";
+            argv[1] = "-logfmt";
+            ok( psLogArguments(&argc, argv) == 2, "psLogArguments: return 2 for '-logfmt' argument input.");
+        }
+
+        // Return 2 for "-logfmt" option with "H"
+        {
+            int argc = 3;
+            char *argv[3];
+            argv[0] = "./program";
+            argv[1] = "-logfmt";
+            argv[2] = "H";
+            ok( psLogArguments(&argc, argv) == 2, "psLogArguments: return 2 for '-logfmt H' argument inputs.");
+        }
+ 
+        // psTraceArguments Tests
+        // Return 0 (default) for NULL arguments input
+        {
+            int argc = 4;
+            ok( psTraceArguments(&argc, NULL) == 0, "psTraceArguments: return 0 for NULL argument input.");
+        }
+
+        // Return 0 (default) for NULL argc input
+        {
+            char *argv[1];
+            argv[0] = "./program";
+            ok( psTraceArguments(NULL, argv) == 0, "psTraceArguments: return 0 for NULL argc input.");
+        }
+
+        // Return 0 for "-trace" option
+        {
+            int argc = 2;
+            char *argv[2];
+            argv[0] = "./program";
+            argv[1] = "-trace";
+            ok( psTraceArguments(&argc, argv) == 0, "psTraceArguments: return 2 for '-trace' argument input.");
+        }
+
+        // Return 2 for "-trace 1 2" option
+        {
+            int argc = 4;
+            char *argv[4];
+            argv[0] = "./program";
+            argv[1] = "-trace";
+            argv[2] = "1";
+            argv[3] = "2";
+            ok( psTraceArguments(&argc, argv) == 1, "psTraceArguments: return 2 for '-trace 1 2' argument inputs.");
+        }
+
+        // Return 2 for "-trace-levels" option
+        {
+            int argc = 2;
+            char *argv[2];
+            argv[0] = "./program";
+            argv[1] = "-trace-levels";
+            ok( psTraceArguments(&argc, argv) == 0, "psTraceArguments: return 2 for '-trace-levels' argument input.");
+        }
+ 
+        // Check for Memory leaks
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+    **/
 }
-
-
-/* XXX: Why is this commented out?
-   void testLogTraceArguments(void)
-   {
-   note("  >>>Test 3:  psLogArguments & psTraceArguments Fxns");
- 
-   // Return 2 (default) for NULL arguments input
-   {
-   int argc = 4;
-   ok( psLogArguments(&argc, NULL) == 2,
-   "psLogArguments:       return 2 for NULL argument input.");
-   }
-   // Return 2 (default) for NULL argc input
-   {
-   char *argv[1];
-   argv[0] = "./program";
-   ok( psLogArguments(NULL, argv) == 2,
-   "psLogArguments:       return 2 for NULL argc input.");
-   }
-   // Return 3 for "-v" option
-   {
-   int argc = 2;
-   char *argv[2];
-   argv[0] = "./program";
-   argv[1] = "-v";
-   ok( psLogArguments(&argc, argv) == 3,
-   "psLogArguments:       return 3 for '-v' argument input.");
-   }
-   // Return 4 for "-vv" option
-   {
-   int argc = 2;
-   char *argv[2];
-   argv[0] = "./program";
-   argv[1] = "-vv";
-   ok( psLogArguments(&argc, argv) == 4,
-   "psLogArguments:       return 4 for '-vv' argument input.");
-   }
-   // Return 5 for "-vvv" option
-   {
-   int argc = 2;
-   char *argv[2];
-   argv[0] = "./program";
-   argv[1] = "-vvv";
-   ok( psLogArguments(&argc, argv) == 5,
-   "psLogArguments:       return 5 for '-vvv' argument input.");
-   }
-   // Return 2 for "-logfmt" option
-   {
-   int argc = 2;
-   char *argv[2];
-   argv[0] = "./program";
-   argv[1] = "-logfmt";
-   ok( psLogArguments(&argc, argv) == 2,
-   "psLogArguments:       return 2 for '-logfmt' argument input.");
-   }
-   // Return 2 for "-logfmt" option with "H"
-   {
-   int argc = 3;
-   char *argv[3];
-   argv[0] = "./program";
-   argv[1] = "-logfmt";
-   argv[2] = "H";
-   ok( psLogArguments(&argc, argv) == 2,
-   "psLogArguments:       return 2 for '-logfmt H' argument inputs.");
-   }
- 
- 
-   // psTraceArguments Tests
-   // Return 0 (default) for NULL arguments input
-   {
-   int argc = 4;
-   ok( psTraceArguments(&argc, NULL) == 0,
-   "psTraceArguments:     return 0 for NULL argument input.");
-   }
-   // Return 0 (default) for NULL argc input
-   {
-   char *argv[1];
-   argv[0] = "./program";
-   ok( psTraceArguments(NULL, argv) == 0,
-   "psTraceArguments:     return 0 for NULL argc input.");
-   }
-   // Return 0 for "-trace" option
-   {
-   int argc = 2;
-   char *argv[2];
-   argv[0] = "./program";
-   argv[1] = "-trace";
-   ok( psTraceArguments(&argc, argv) == 0,
-   "psTraceArguments:     return 2 for '-trace' argument input.");
-   }
-   // Return 2 for "-trace 1 2" option
-   {
-   int argc = 4;
-   char *argv[4];
-   argv[0] = "./program";
-   argv[1] = "-trace";
-   argv[2] = "1";
-   argv[3] = "2";
-   ok( psTraceArguments(&argc, argv) == 1,
-   "psTraceArguments:     return 2 for '-trace 1 2' argument inputs.");
-   }
-   // Return 2 for "-trace-levels" option
-   {
-   int argc = 2;
-   char *argv[2];
-   argv[0] = "./program";
-   argv[1] = "-trace-levels";
-   ok( psTraceArguments(&argc, argv) == 0,
-   "psTraceArguments:     return 2 for '-trace-levels' argument input.");
-   }
- 
-   // Check for Memory leaks
-   {
-   checkMem();
-   }
-   }
-*/

trunk/psLib/test/types/tap_psList_all.c

@@ -150 +150 @@
                 "psListAddAfter:         return true for adding a list element to the head.");
         }
+        psFree(noList);
+
         //Return true for adding to an empty list
-        psFree(noList);
         noList = psListAlloc(NULL);
         psListIterator *iter3 = psListIteratorAlloc(noList, 0, true);
         {
-            ok( psListAddAfter(iter3, md),
-                "psListAddAfter:         return true for adding to an empty list.");
+            ok( psListAddAfter(iter3, md), "psListAddAfter: return true for adding to an empty list.");
         }
 

trunk/psLib/test/types/tap_psMetadataConfigParse.c

@@ -58 +58 @@
         skip_start(item == NULL, 2,
                      "Skipping 1 tests because metadata container is empty!");
-        ok(item->type == PS_TYPE_S32, "return correcot metdataItem type");
+        ok(item->type == PS_DATA_S32, "return correct metdataItem type");
         is_int(item->data.S32, 666, "return correct metadataItem data");
         is_str(item->name, "new", "return correct metadataItem name");
@@ -105 +105 @@
         skip_start(item == NULL, 2,
                 "Skipping 1 tests because metadata container is empty!");
-        ok(item->type == PS_TYPE_S8, "metdataItem type");
+        ok(item->type == PS_DATA_S8, "metdataItem type");
         is_int(item->data.S8, 3, "metdataItem value");
         is_str(item->name, "item8", "return correct metadataItem name");

trunk/psLib/test/types/tap_psMetadata_copying.c

@@ -421 +421 @@
         //Return false for NULL in input
         {
-            ok( !psMetadataItemSupplement(out, NULL, key),
+          ok( !psMetadataItemSupplement(NULL, out, NULL, key),
                 "psMetadataItemSupplement:  return false for NULL in metadata.");
         }
         //Return false for NULL out input
         {
-            ok( !psMetadataItemSupplement(NULL, in, key),
+            ok( !psMetadataItemSupplement(NULL, NULL, in, key),
                 "psMetadataItemSupplement:  return false for NULL out metadata.");
         }
         //Return false for NULL key input
         {
-            ok( !psMetadataItemSupplement(out, in, NULL),
+            ok( !psMetadataItemSupplement(NULL, out, in, NULL),
                 "psMetadataItemSupplement:  return false for NULL key string.");
         }
@@ -439 +439 @@
         //Return true for valid inputs
         {
-            bool transfered = psMetadataItemSupplement(out, in, key);
+            bool transfered = psMetadataItemSupplement(NULL, out, in, key);
             psMetadataItem *item = NULL;
             if (transfered)
@@ -460 +460 @@
         {
             strncpy(key, "not MY key", 15);
-            ok( !psMetadataItemSupplement(out, in, key),
+            ok( !psMetadataItemSupplement(NULL, out, in, key),
                 "psMetadataItemSupplement:  return false for invalid key.");
         }
@@ -468 +468 @@
         invalid->hash = NULL;
         {
-            ok( !psMetadataItemSupplement(invalid, in, "key"),
+            ok( !psMetadataItemSupplement(NULL, invalid, in, "key"),
                 "psMetadataItemSupplement:  return false for invalid metadata.");
         }

trunk/psLib/test/types/tap_psMetadata_manip.c

@@ -231 +231 @@
             psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", s);
             psFree(s);
-            psMetadataItem *metadataItem = NULL;
-            metadataItem = psMetadataLookup(metadata, "ptr");
+            // psMetadataItem *metadataItem = NULL;
+            // metadataItem = psMetadataLookup(metadata, "ptr");
             bool status = false;
             psSphere *sph = NULL;

@@ -75 +75 @@
 tap_psMetadataOverlay
 tap_psTree
+tap_psBits_all