Changeset 25350

Show
Ignore:
Timestamp:
05/07/08 10:42:10 (1 week ago)
Author:
bonefish
Message:
* Added more tests for unnamed semaphores. Looks like I have to think of
  an alternative implementation.
* Improved output a bit.
Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • haiku/trunk/src/tests/system/libroot/posix/realtime_sem_test1.cpp

    r25347 r25350  
    1212#include <unistd.h> 
    1313#include <semaphore.h> 
     14#include <sys/mman.h> 
    1415#include <sys/stat.h> 
    1516#include <sys/time.h> 
    …… 
    125126 
    126127static void 
     128test_set(const char* testSet) 
     129{ 
     130        printf("\nTEST SET: %s\n", testSet); 
     131} 
     132 
     133 
     134static void 
    127135test_ok(const char* test) 
    128136{ 
    …… 
    139147        _assert_posix_bool_success(test, result >= 0, lineNumber); 
    140148        _assert_equals(test, child, result, lineNumber); 
    141 } 
    142  
    143  
    144 #define TEST(test)      test_ok(currentTest); currentTest = (test); 
     149        _assert_equals(test, 0, status, lineNumber); 
     150} 
     151 
     152 
     153#if 0 
     154static void 
     155dump_sem(const char* name, sem_t* sem) 
     156{ 
     157        printf("%s, %p: ", name, sem); 
     158        for (size_t i = 0; i < sizeof(sem_t); i++) 
     159                printf("%02x", ((char*)sem)[i]); 
     160        printf("\n"); 
     161} 
     162#endif 
     163 
     164 
     165#define TEST_SET(testSet)       test_set(testSet) 
     166#define TEST(test)      test_ok(currentTest); currentTest = (test) 
    145167 
    146168#define assert_equals(expected, actual) \ 
    …… 
    176198test_open_close_unlink() 
    177199{ 
     200        TEST_SET("sem_{open,close,unlink}()"); 
     201 
    178202        const char* currentTest = NULL; 
    179203 
    …… 
    258282test_init_destroy() 
    259283{ 
     284        TEST_SET("sem_{init,destroy}()"); 
     285 
    260286        const char* currentTest = NULL; 
    261287 
    …… 
    293319test_open_close_fork() 
    294320{ 
     321        TEST_SET("sem_{open,close}() with fork()"); 
     322 
    295323        const char* currentTest = NULL; 
    296324 
    …… 
    337365test_init_destroy_fork() 
    338366{ 
     367        TEST_SET("sem_{init,destroy}() with fork()"); 
     368 
    339369        const char* currentTest = NULL; 
    340370 
    …… 
    366396test_post_wait_named() 
    367397{ 
     398        TEST_SET("sem_{post,wait,trywait,timedwait}() named semaphore"); 
     399 
    368400        const char* currentTest = NULL; 
    369401 
    …… 
    514546test_post_wait_unnamed() 
    515547{ 
     548        TEST_SET("sem_{post,wait,trywait,timedwait}() unnamed semaphore"); 
     549 
    516550        const char* currentTest = NULL; 
    517551 
    …… 
    647681test_post_wait_named_fork() 
    648682{ 
     683        TEST_SET("sem_{post,wait,trywait,timedwait}() named semaphore with fork()"); 
     684 
    649685        const char* currentTest = NULL; 
    650686 
    …… 
    770806test_post_wait_named_fork2() 
    771807{ 
     808        TEST_SET("sem_{post,wait,trywait,timedwait}() named semaphore open after " 
     809                "fork"); 
     810 
    772811        const char* currentTest = NULL; 
    773812 
    …… 
    899938 
    900939 
    901 #ifdef __HAIKU__ 
    902  
    903940static void 
    904941test_post_wait_unnamed_fork() 
    905942{ 
     943        TEST_SET("sem_{post,wait,trywait,timedwait}() unnamed semaphore with " 
     944                "fork()"); 
     945 
    906946        const char* currentTest = NULL; 
    907947 
    …… 
    909949        TEST("sem_init()"); 
    910950        sem_t _sem; 
    911         assert_posix_success(sem_init(&_sem, 1, 0)); 
     951        assert_posix_success(sem_init(&_sem, 1, 1)); 
    912952        sem_t* sem = &_sem; 
     953 
     954        TEST("sem_getvalue()"); 
     955        int value; 
     956        assert_posix_success(sem_getvalue(sem, &value)); 
     957        assert_equals(1, value); 
     958 
     959        TEST("sem_wait() on fork()ed unnamed sem in parent and child"); 
     960        pid_t child = fork(); 
     961        assert_posix_bool_success(child >= 0); 
     962 
     963        if (child == 0) { 
     964                // child 
     965                sleep(1); 
     966                assert_posix_success(sem_wait(sem)); 
     967 
     968                assert_posix_success(sem_getvalue(sem, &value)); 
     969                assert_equals(0, value); 
     970 
     971                exit(0); 
     972        } else { 
     973                // parent 
     974                assert_posix_success(sem_wait(sem)); 
     975                assert_posix_success(sem_getvalue(sem, &value)); 
     976                assert_equals(0, value); 
     977 
     978                wait_for_child(child); 
     979        } 
     980 
     981        TEST("sem_getvalue()"); 
     982        assert_posix_success(sem_getvalue(sem, &value)); 
     983        assert_equals(0, value); 
     984 
     985        TEST("sem_post() on fork()ed unnamed sem in parent and child"); 
     986        child = fork(); 
     987        assert_posix_bool_success(child >= 0); 
     988 
     989        if (child == 0) { 
     990                // child 
     991                assert_posix_success(sem_post(sem)); 
     992 
     993                assert_posix_success(sem_getvalue(sem, &value)); 
     994                assert_equals(1, value); 
     995 
     996                exit(0); 
     997        } else { 
     998                // parent 
     999                assert_posix_success(sem_post(sem)); 
     1000                assert_posix_success(sem_getvalue(sem, &value)); 
     1001                assert_equals(1, value); 
     1002 
     1003                wait_for_child(child); 
     1004        } 
     1005 
     1006        TEST("sem_getvalue()"); 
     1007        assert_posix_success(sem_getvalue(sem, &value)); 
     1008        assert_equals(1, value); 
     1009 
     1010        // destroy 
     1011        TEST("sem_destroy()"); 
     1012        assert_posix_success(sem_destroy(sem)); 
     1013 
     1014        TEST("done"); 
     1015} 
     1016 
     1017 
     1018static void 
     1019test_post_wait_unnamed_fork_shared() 
     1020{ 
     1021        TEST_SET("sem_{post,wait,trywait,timedwait}() unnamed semaphore with " 
     1022                "fork() in shared memory"); 
     1023 
     1024        const char* currentTest = NULL; 
     1025 
     1026        // create shared memory area 
     1027        void* address = mmap(NULL, 4096, PROT_READ | PROT_WRITE, 
     1028                MAP_SHARED | MAP_ANON, -1, 0); 
     1029        assert_posix_bool_success(address != MAP_FAILED); 
     1030 
     1031        // init 
     1032        TEST("sem_init()"); 
     1033        sem_t* sem = (sem_t*)address; 
     1034        assert_posix_success(sem_init(sem, 1, 0)); 
    9131035 
    9141036        TEST("sem_getvalue()"); 
    …… 
    10181140        assert_posix_success(sem_destroy(sem)); 
    10191141 
     1142        // unmap memory 
     1143        assert_posix_success(munmap(address, 4096)); 
     1144 
    10201145        TEST("done"); 
    10211146} 
    1022  
    1023 #endif  // __HAIKU__ 
    10241147 
    10251148 
    …… 
    10351158        test_post_wait_named_fork(); 
    10361159        test_post_wait_named_fork2(); 
    1037 #ifdef __HAIKU__ 
    10381160        test_post_wait_unnamed_fork(); 
    1039 // TODO: Check whether Linux and Solaris actually create an 
    1040 // independent clone of an unnamed semaphore on fork(). Check what happens when 
    1041 // putting the semaphore in anonymously mmap()ed memory. 
    1042 #endif 
    1043 } 
     1161        test_post_wait_unnamed_fork_shared(); 
     1162 
     1163        printf("\nall tests OK\n"); 
     1164}