Changeset 1406 for trunk/psLib/test/sysUtils/tst_psMemory.c

Timestamp:

Aug 6, 2004, 12:34:06 PM (22 years ago)

Author:

desonia

Message:

astyle fixed?

File:

• trunk/psLib/test/sysUtils/tst_psMemory.c (modified) (13 diffs)

trunk/psLib/test/sysUtils/tst_psMemory.c

@@ -6 +6 @@
 *  @author Robert DeSonia, MHPCC
 *
-*  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-08-02 19:43:23 $
+*  @version $Revision: 1.22 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-08-06 22:34:06 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -80 +80 @@
                               }
                           };
-                          
+
 int main( int argc, char* argv[] )
 {
     psLogSetLevel( PS_LOG_INFO );
-    
+
     return ( ! runTestSuite( stderr, "psMemory", tests, argc, argv ) );
 }
@@ -94 +94 @@
     const int size = 100;
     int failed = 0;
-    
+
     psLogMsg( __func__, PS_LOG_INFO, "psAlloc shall allocate memory blocks writeable by caller.\n" );
-    
+
     mem = ( int* ) psAlloc( size * sizeof( int ) );
     if ( mem == NULL ) {
-            psError( __FILE__, "psAlloc returned a NULL value in %s!", __func__ );
-            return 1;
+        psError( __FILE__, "psAlloc returned a NULL value in %s!", __func__ );
+        return 1;
+    }
+
+    for ( int index = 0;index < size;index++ ) {
+        mem[ index ] = index;
+    }
+
+    for ( int index = 0;index < size;index++ ) {
+        if ( mem[ index ] != index ) {
+            failed++;
         }
-        
-    for ( int index = 0;index < size;index++ ) {
-            mem[ index ] = index;
-        }
-        
-    for ( int index = 0;index < size;index++ ) {
-            if ( mem[ index ] != index ) {
-                    failed++;
-                }
-        }
-        
+    }
+
     psFree( mem );
-    
+
     return failed;
 }
@@ -123 +123 @@
     int * mem;
     int ref = 0;
-    
+
     psLogMsg( __func__, PS_LOG_INFO, "memory reference count shall be incrementable/decrementable" );
-    
+
     mem = ( int* ) psAlloc( 100 * sizeof( int ) );
-    
+
     ref = psMemGetRefCounter( mem );
     if ( ref != 1 ) {
-            psError( __func__, "Expected to buffer reference count to be initially 1, but it was %d.", ref );
-            return 1;
-        }
-        
+        psError( __func__, "Expected to buffer reference count to be initially 1, but it was %d.", ref );
+        return 1;
+    }
+
     psMemIncrRefCounter( mem );
     psMemIncrRefCounter( mem );
     psMemIncrRefCounter( mem );
-    
+
     ref = psMemGetRefCounter( mem );
     if ( ref != 4 ) {
-            psError( __func__, "Expected to find buffer reference count to be 4, but it was %d.", ref );
-            return 1;
-        }
-        
+        psError( __func__, "Expected to find buffer reference count to be 4, but it was %d.", ref );
+        return 1;
+    }
+
     psMemDecrRefCounter( mem );
     psMemDecrRefCounter( mem );
-    
+
     ref = psMemGetRefCounter( mem );
     if ( ref != 2 ) {
-            psError( __func__, "Expected to find buffer reference count to be 2, but it was %d.", ref );
-            return 1;
-        }
-        
+        psError( __func__, "Expected to find buffer reference count to be 2, but it was %d.", ref );
+        return 1;
+    }
+
     psLogMsg( __func__, PS_LOG_INFO, "psFree shall be just decrement a multiple refererenced pointer." );
-    
+
     psFree( mem );
-    
+
     ref = psMemGetRefCounter( mem );
     if ( ref != 1 ) {
-            psError( __func__, "Expected to find buffer reference count to be 1, but it was %d.", ref );
-            return 1;
-        }
-        
+        psError( __func__, "Expected to find buffer reference count to be 1, but it was %d.", ref );
+        return 1;
+    }
+
     psFree( mem );
-    
+
     return 0;
 }
@@ -174 +174 @@
     int * mem[ 100 ];
     psMemExhaustedCallback cb;
-    
-    for ( int lcv = 0; lcv < 100; lcv++ ) {
-            mem[ lcv ] = NULL;
-        }
-        
+
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+        mem[ lcv ] = NULL;
+    }
+
     psLogMsg( __func__, PS_LOG_INFO, "Upon requesting more memory than is available, psRealloc shall call "
               "the psMemExhaustedCallback.\n" );
-              
+
     exhaustedCallbackCalled = 0;
-    
+
     cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback );
-    
-    for ( int lcv = 0; lcv < 100; lcv++ ) {
-            mem[ lcv ] = ( int* ) psAlloc( 10 );
-        }
-        
-    for ( int lcv = 0; lcv < 100; lcv++ ) {
-            mem[ lcv ] = ( int* ) psRealloc( mem[ lcv ], SIZE_MAX - 1000 );
-        }
-        
+
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+        mem[ lcv ] = ( int* ) psAlloc( 10 );
+    }
+
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+        mem[ lcv ] = ( int* ) psRealloc( mem[ lcv ], SIZE_MAX - 1000 );
+    }
+
     psMemExhaustedCallbackSet( cb );
-    
+
     if ( exhaustedCallbackCalled == 0 ) {
-            psError( __FILE__, "Called psRealloc with HUGE memory requirement and survived in %s!", __func__ );
-            return 1;
-        }
-        
-    for ( int lcv = 0; lcv < 100; lcv++ ) {
-            psFree( mem[ lcv ] );
-        }
-        
+        psError( __FILE__, "Called psRealloc with HUGE memory requirement and survived in %s!", __func__ );
+        return 1;
+    }
+
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+        psFree( mem[ lcv ] );
+    }
+
     return 0;
 }
@@ -213 +213 @@
     int * mem[ 100 ];
     psMemExhaustedCallback cb;
-    
-    for ( int lcv = 0; lcv < 100; lcv++ ) {
-            mem[ lcv ] = NULL;
-        }
-        
+
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+        mem[ lcv ] = NULL;
+    }
+
     psLogMsg( __func__, PS_LOG_INFO, "Upon requesting more memory than is available, psalloc shall call "
               "the psMemExhaustedCallback.\n" );
-              
+
     exhaustedCallbackCalled = 0;
-    
+
     cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback );
-    
-    for ( int lcv = 0; lcv < 100; lcv++ ) {
-            mem[ lcv ] = ( int* ) psAlloc( SIZE_MAX - 1000 );
-        }
-        
+
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+        mem[ lcv ] = ( int* ) psAlloc( SIZE_MAX - 1000 );
+    }
+
     psMemExhaustedCallbackSet( cb );
-    
+
     if ( exhaustedCallbackCalled == 0 ) {
-            psError( __FILE__, "Called psAlloc with HUGE memory requirement and survived in %s!", __func__ );
-            return 1;
-        }
-        
-    for ( int lcv = 0; lcv < 100; lcv++ ) {
-            psFree( mem[ lcv ] );
-        }
-        
+        psError( __FILE__, "Called psAlloc with HUGE memory requirement and survived in %s!", __func__ );
+        return 1;
+    }
+
+    for ( int lcv = 0; lcv < 100; lcv++ ) {
+        psFree( mem[ lcv ] );
+    }
+
     return 0;
 }
@@ -250 +250 @@
     int* mem3;
     const int initialSize = 100;
-    
+
     psLogMsg( __func__, PS_LOG_INFO, "psRealloc shall increase/decrease memory buffer while "
               "preserving contents" );
-              
+
     // allocate buffer with known values.
     mem1 = ( int* ) psAlloc( initialSize * sizeof( int ) );
@@ -259 +259 @@
     mem3 = ( int* ) psAlloc( initialSize * sizeof( int ) );
     for ( int lcv = 0;lcv < initialSize;lcv++ ) {
-            mem1[ lcv ] = mem2[ lcv ] = mem3[ lcv ] = lcv;
-        }
-        
+        mem1[ lcv ] = mem2[ lcv ] = mem3[ lcv ] = lcv;
+    }
+
     psMemCheckCorruption( 1 );
     psLogMsg( __func__, PS_LOG_INFO, "Expanding memory buffer." );
-    
+
     // realloc to 2x
     mem1 = ( int* ) psRealloc( mem1, 2 * initialSize * sizeof( int ) );
     mem2 = ( int* ) psRealloc( mem2, 2 * initialSize * sizeof( int ) );
     mem3 = ( int* ) psRealloc( mem3, 2 * initialSize * sizeof( int ) );
-    
+
     // check values of initial block
     for ( int i = 0;i < initialSize;i++ ) {
-            if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) {
-                    psError( __FILE__, "Realloc didn't preserve the contents with expanding buffer in %s.",
-                             __func__ );
-                    break;
-                }
+        if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) {
+            psError( __FILE__, "Realloc didn't preserve the contents with expanding buffer in %s.",
+                     __func__ );
+            break;
         }
-        
+    }
+
     psMemCheckCorruption( 1 );
     psLogMsg( __func__, PS_LOG_INFO, "Shrinking memory buffer." );
-    
+
     // realloc to 1/2 initial value.
     mem1 = ( int* ) psRealloc( mem1, ( initialSize / 2 ) * sizeof( int ) );
     mem2 = ( int* ) psRealloc( mem2, ( initialSize / 2 ) * sizeof( int ) );
     mem3 = ( int* ) psRealloc( mem3, ( initialSize / 2 ) * sizeof( int ) );
-    
+
     // check values of initial block
     for ( int i = 0;i < initialSize / 2;i++ ) {
-            if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) {
-                    psError( __FILE__, "Realloc didn't preserve the contents with shrinking buffer in %s.",
-                             __func__ );
-                    break;
-                }
+        if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) {
+            psError( __FILE__, "Realloc didn't preserve the contents with shrinking buffer in %s.",
+                     __func__ );
+            break;
         }
-        
+    }
+
     psFree( mem1 );
     psFree( mem2 );
     psFree( mem3 );
-    
+
     return 0;
 }
@@ -311 +311 @@
     const int initialSize = 100;
     int mark;
-    
+
     allocCallbackCalled = 0;
     freeCallbackCalled = 0;
     psMemAllocateCallbackSet( memAllocateCallback );
     psMemFreeCallbackSet( memFreeCallback );
-    
+
     psMemAllocateCallbackSetID( currentId + 1 );
     psMemFreeCallbackSetID( currentId + 1 );
-    
+
     psLogMsg( __func__, PS_LOG_INFO, "call to psAlloc/psRealloc shall generate a callback if specified "
               "memory ID is allocated." );
-              
+
     // allocate buffer with known values.
     mem1 = ( int* ) psAlloc( initialSize * sizeof( int ) );
     mem2 = ( int* ) psAlloc( initialSize * sizeof( int ) );
     mem3 = ( int* ) psAlloc( initialSize * sizeof( int ) );
-    
+
     psFree( mem1 );
     psFree( mem2 );
     psFree( mem3 );
-    
+
     if ( allocCallbackCalled != 2 || freeCallbackCalled != 2 ) {
-            psError( __FILE__, "alloc/free callbacks were not called the proper number of times in %s",
-                     __func__ );
-            return 1;
-        }
-        
+        psError( __FILE__, "alloc/free callbacks were not called the proper number of times in %s",
+                 __func__ );
+        return 1;
+    }
+
     allocCallbackCalled = 0;
     freeCallbackCalled = 0;
-    
+
     mark = psMemGetId();
-    
+
     mem1 = ( int* ) psAlloc( initialSize * sizeof( int ) );
-    
+
     psMemAllocateCallbackSetID( mark );
-    
+
     mem1 = ( int* ) psRealloc( mem1, initialSize * 2 * sizeof( int ) );
-    
+
     psFree( mem1 );
-    
+
     if ( allocCallbackCalled != 2 ) {
-            psError( __FILE__, "realloc callbacks were not called the proper number of times in %s",
-                     __func__ );
-            return 1;
-        }
-        
-    return 0;
-    
+        psError( __FILE__, "realloc callbacks were not called the proper number of times in %s",
+                 __func__ );
+        return 1;
+    }
+
+    return 0;
+
 }
 
@@ -370 +370 @@
     int nLeaks = 0;
     int lineMark = 0;
-    
+
     psLogMsg( __func__, PS_LOG_INFO, "psMemCheckLeaks shall return the number of blocks above an ID "
               "that are still allocated" );
-              
+
     for ( lcv = 0;lcv < numBuffers;lcv++ ) {
-            lineMark = __LINE__ + 1;
-            buffers[ lcv ] = psAlloc( sizeof( int ) );
-        }
-        
+        lineMark = __LINE__ + 1;
+        buffers[ lcv ] = psAlloc( sizeof( int ) );
+    }
+
     for ( lcv = 1;lcv < numBuffers;lcv++ ) {
+        psFree( buffers[ lcv ] );
+    }
+
+    psLogMsg( __func__, PS_LOG_INFO, "following psMemCheckLeaks call should produce one instance." );
+
+    nLeaks = psMemCheckLeaks( currentId, &blks, stderr );
+
+    if ( nLeaks != 1 ) {
+        psError( __FILE__, "psMemCheckLeaks should have found 1 leak, but found %d in %s.", nLeaks, __func__ );
+        return 1;
+    }
+
+    if ( blks[ 0 ] ->lineno != lineMark ) {
+        psError( __FILE__, "psMemCheckLeaks found a leak other than the expected one (line %d vs %d) in %s.",
+                 lineMark, blks[ 0 ] ->lineno, __func__ );
+        return 1;
+    }
+
+    psFree( buffers[ 0 ] );
+    psFree( blks );
+
+    psLogMsg( __func__, PS_LOG_INFO, "Testing psMemCheckLeaks again with a different leak location" );
+    psMemCheckLeaks( currentId, NULL, stderr );
+
+    for ( lcv = 0;lcv < numBuffers;lcv++ ) {
+        lineMark = __LINE__ + 1;
+        buffers[ lcv ] = psAlloc( sizeof( int ) );
+    }
+
+    for ( lcv = 0;lcv < numBuffers - 1;lcv++ ) {
+        psFree( buffers[ lcv ] );
+    }
+
+    psLogMsg( __func__, PS_LOG_INFO, "following psMemCheckLeaks call should produce one error." );
+
+    nLeaks = psMemCheckLeaks( currentId, &blks, stderr );
+
+    if ( nLeaks != 1 ) {
+        psError( __FILE__, "psMemCheckLeaks should have found 1 leak, but found %d in %s.", nLeaks, __func__ );
+        return 1;
+    }
+
+    if ( blks[ 0 ] ->lineno != lineMark ) {
+        psError( __FILE__, "psMemCheckLeaks found a leak other than the expected one in %s.", __func__ );
+        return 1;
+    }
+
+    psFree( buffers[ 4 ] );
+    psFree( blks );
+
+    psLogMsg( __func__, PS_LOG_INFO, "Testing psMemCheckLeaks again with multiple leak locations." );
+
+    for ( lcv = 0;lcv < numBuffers;lcv++ ) {
+        lineMark = __LINE__ + 1;
+        buffers[ lcv ] = psAlloc( sizeof( int ) );
+    }
+
+    for ( lcv = 0;lcv < numBuffers;lcv++ ) {
+        if ( lcv % 2 == 0 ) {
             psFree( buffers[ lcv ] );
         }
-        
-    psLogMsg( __func__, PS_LOG_INFO, "following psMemCheckLeaks call should produce one instance." );
-    
+    }
+
+    psLogMsg( __func__, PS_LOG_INFO, "following psMemCheckLeaks call should produce two errors." );
+
     nLeaks = psMemCheckLeaks( currentId, &blks, stderr );
-    
-    if ( nLeaks != 1 ) {
-            psError( __FILE__, "psMemCheckLeaks should have found 1 leak, but found %d in %s.", nLeaks, __func__ );
-            return 1;
-        }
-        
+
+    if ( nLeaks != 2 ) {
+        psError( __FILE__, "psMemCheckLeaks should have found 1 leak, but found %d in %s.", nLeaks, __func__ );
+        return 1;
+    }
+
     if ( blks[ 0 ] ->lineno != lineMark ) {
-            psError( __FILE__, "psMemCheckLeaks found a leak other than the expected one (line %d vs %d) in %s.",
-                     lineMark, blks[ 0 ] ->lineno, __func__ );
-            return 1;
-        }
-        
-    psFree( buffers[ 0 ] );
-    psFree( blks );
-    
-    psLogMsg( __func__, PS_LOG_INFO, "Testing psMemCheckLeaks again with a different leak location" );
-    psMemCheckLeaks( currentId, NULL, stderr );
-    
-    for ( lcv = 0;lcv < numBuffers;lcv++ ) {
-            lineMark = __LINE__ + 1;
-            buffers[ lcv ] = psAlloc( sizeof( int ) );
-        }
-        
-    for ( lcv = 0;lcv < numBuffers - 1;lcv++ ) {
-            psFree( buffers[ lcv ] );
-        }
-        
-    psLogMsg( __func__, PS_LOG_INFO, "following psMemCheckLeaks call should produce one error." );
-    
-    nLeaks = psMemCheckLeaks( currentId, &blks, stderr );
-    
-    if ( nLeaks != 1 ) {
-            psError( __FILE__, "psMemCheckLeaks should have found 1 leak, but found %d in %s.", nLeaks, __func__ );
-            return 1;
-        }
-        
-    if ( blks[ 0 ] ->lineno != lineMark ) {
-            psError( __FILE__, "psMemCheckLeaks found a leak other than the expected one in %s.", __func__ );
-            return 1;
-        }
-        
-    psFree( buffers[ 4 ] );
-    psFree( blks );
-    
-    psLogMsg( __func__, PS_LOG_INFO, "Testing psMemCheckLeaks again with multiple leak locations." );
-    
-    for ( lcv = 0;lcv < numBuffers;lcv++ ) {
-            lineMark = __LINE__ + 1;
-            buffers[ lcv ] = psAlloc( sizeof( int ) );
-        }
-        
-    for ( lcv = 0;lcv < numBuffers;lcv++ ) {
-            if ( lcv % 2 == 0 ) {
-                    psFree( buffers[ lcv ] );
-                }
-        }
-        
-    psLogMsg( __func__, PS_LOG_INFO, "following psMemCheckLeaks call should produce two errors." );
-    
-    nLeaks = psMemCheckLeaks( currentId, &blks, stderr );
-    
-    if ( nLeaks != 2 ) {
-            psError( __FILE__, "psMemCheckLeaks should have found 1 leak, but found %d in %s.", nLeaks, __func__ );
-            return 1;
-        }
-        
-    if ( blks[ 0 ] ->lineno != lineMark ) {
-            psError( __FILE__, "psMemCheckLeaks found a leak other than the expected one in %s.", __func__ );
-            return 1;
-        }
-        
+        psError( __FILE__, "psMemCheckLeaks found a leak other than the expected one in %s.", __func__ );
+        return 1;
+    }
+
     psFree( blks );
     psFree( buffers[ 1 ] );
     psFree( buffers[ 3 ] );
-    
+
     return 0;
 }
@@ -470 +470 @@
     int corruptions = 0;
     psMemProblemCallback cb;
-    
+
     psLogMsg( __func__, PS_LOG_INFO, "psMemCheckCorruption shall detect memory corruptions" );
-    
+
     buffer = psAlloc( sizeof( int ) );
-    
+
     // cause memory corruption via buffer underflow
     *buffer = 1;
@@ -480 +480 @@
     oldValue = *buffer;
     *buffer = 2;
-    
+
     problemCallbackCalled = 0;
     cb = psMemProblemCallbackSet( memProblemCallback );
-    
+
     psLogMsg( __func__, PS_LOG_INFO, "psMemCheckCorruption should output an error message and "
               "memProblemCallback callback should be called." );
-              
+
     corruptions = psMemCheckCorruption( 0 );
-    
+
     // restore the memory problem callback
     psMemProblemCallbackSet( cb );
-    
+
     // restore the value, 'uncorrupting' the buffer
     *buffer = oldValue;
     buffer++;
-    
+
     psFree( buffer );
-    
+
     if ( corruptions != 1 ) {
-            psError( __FILE__, "Expected one memory corruption but found %d in %s.",
-                     corruptions, __func__ );
-            return 1;
-        }
-        
+        psError( __FILE__, "Expected one memory corruption but found %d in %s.",
+                 corruptions, __func__ );
+        return 1;
+    }
+
     if ( problemCallbackCalled != 1 ) {
-            psError( __FILE__, "The memProblemCallback was not invoked but should have been in %s",
-                     __func__ );
-            return 1;
-        }
-        
-    return 0;
-    
+        psError( __FILE__, "The memProblemCallback was not invoked but should have been in %s",
+                 __func__ );
+        return 1;
+    }
+
+    return 0;
+
 }
 
@@ -547 +547 @@
 
     void * buffer = psAlloc( 1024 );
-    
+
     psFree( buffer );
-    
+
     psLogMsg( __func__, PS_LOG_INFO, "Next should be an error about multiple freeing." );
     psFree( buffer );
-    
-    return 0;
-}
+
+    return 0;
+}