/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include <errno.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <semaphore.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <time.h>


#ifdef __HAIKU__
#	include <OS.h>
#else

typedef int64_t bigtime_t;

static bigtime_t
system_time()
{
	timeval tv;
	gettimeofday(&tv, NULL);
	return (bigtime_t)tv.tv_sec * 1000000 + tv.tv_usec;
}


#endif	// !__HAIKU__

#include "TestUnitUtils.h"

#if 0
static void
dump_sem(const char* name, sem_t* sem)
{
	printf("%s, %p: ", name, sem);
	for (size_t i = 0; i < sizeof(sem_t); i++)
		printf("%02x", ((char*)sem)[i]);
	printf("\n");
}
#endif


static const char* const kSemName1 = "/test_sem1";


static void
test_open_close_unlink()
{
	TEST_SET("sem_{open,close,unlink}()");

	const char* currentTest = NULL;

	// open non-existing with O_CREAT
	TEST("sem_open(O_CREAT) non-existing");
	sem_t* sem = sem_open(kSemName1, O_CREAT, S_IRUSR | S_IWUSR, 1);
	assert_posix_bool_success(sem != SEM_FAILED);

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));

	// open existing with O_CREAT
	TEST("sem_open(O_CREAT) existing");
	sem = sem_open(kSemName1, O_CREAT, S_IRUSR | S_IWUSR, 1);
	assert_posix_bool_success(sem != SEM_FAILED);

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));

	// open existing without O_CREAT
	TEST("sem_open() existing");
	sem = sem_open(kSemName1, 0);
	assert_posix_bool_success(sem != SEM_FAILED);

	// re-open existing without O_CREAT
	TEST("sem_open() existing");
	sem_t* sem2 = sem_open(kSemName1, 0);
	assert_posix_bool_success(sem2 != SEM_FAILED);
	assert_equals(sem, sem2);

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));

	// open existing with O_CREAT | O_EXCL
	TEST("sem_open(O_CREAT | O_EXCL) existing");
	sem = sem_open(kSemName1, O_CREAT | O_EXCL, S_IRUSR | S_IWUSR, 1);
	assert_posix_bool_error(EEXIST, sem != SEM_FAILED);

	// open existing without O_CREAT
	TEST("sem_open() existing");
	sem = sem_open(kSemName1, 0);
	assert_posix_bool_success(sem != SEM_FAILED);

	// unlink
	TEST("unlink() existing");
	assert_posix_success(sem_unlink(kSemName1));

	// open non-existing with O_CREAT | O_EXCL
	TEST("sem_open(O_CREAT | O_EXCL) non-existing");
	sem2 = sem_open(kSemName1, O_CREAT | O_EXCL, S_IRUSR | S_IWUSR, 2);
	assert_posix_bool_success(sem2 != SEM_FAILED);
	assert_equals_not(sem, sem2);

	// unlink
	TEST("unlink() existing");
	assert_posix_success(sem_unlink(kSemName1));

	// unlink
	TEST("unlink() non-existing");
	assert_posix_error(ENOENT, sem_unlink(kSemName1));

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem2));

	TEST("done");
}


static void
test_init_destroy()
{
	TEST_SET("sem_{init,destroy}()");

	const char* currentTest = NULL;

	// init
	TEST("sem_init()");
	sem_t sem;
	assert_posix_success(sem_init(&sem, 0, 1));

	// destroy
	TEST("sem_destroy()");
	assert_posix_success(sem_destroy(&sem));

	// init
	TEST("sem_init()");
	assert_posix_success(sem_init(&sem, 0, 1));

	// init
	TEST("sem_init()");
	sem_t sem2;
	assert_posix_success(sem_init(&sem2, 0, 2));

	// destroy
	TEST("sem_destroy()");
	assert_posix_success(sem_destroy(&sem));

	// destroy
	TEST("sem_destroy()");
	assert_posix_success(sem_destroy(&sem2));

	TEST("done");
}


static void
test_open_close_fork()
{
	TEST_SET("sem_{open,close}() with fork()");

	const char* currentTest = NULL;

	// open non-existing with O_CREAT
	TEST("sem_open(O_CREAT) non-existing");
	sem_t* sem = sem_open(kSemName1, O_CREAT, S_IRUSR | S_IWUSR, 1);
	assert_posix_bool_success(sem != SEM_FAILED);

	TEST("close_sem() forked");
	pid_t child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		assert_posix_success(sem_close(sem));
		exit(0);
	} else {
		// parent
		assert_posix_success(sem_close(sem));
		wait_for_child(child);
	}

	TEST("sem_open() existing forked");
	child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		sem = sem_open(kSemName1, O_CREAT);
		assert_posix_bool_success(sem != SEM_FAILED);
		exit(0);
	} else {
		// parent
		sem = sem_open(kSemName1, O_CREAT);
		wait_for_child(child);
		assert_posix_success(sem_close(sem));
	}

	TEST("done");
}


static void
test_init_destroy_fork()
{
	TEST_SET("sem_{init,destroy}() with fork()");

	const char* currentTest = NULL;

	// init
	TEST("sem_init()");
	sem_t sem;
	assert_posix_success(sem_init(&sem, 0, 1));

	// destroy
	TEST("sem_destroy() forked");
	pid_t child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		assert_posix_success(sem_destroy(&sem));
		exit(0);
	} else {
		// parent
		assert_posix_success(sem_destroy(&sem));
		wait_for_child(child);
	}

	TEST("done");
}


static void
test_post_wait_named()
{
	TEST_SET("sem_{post,wait,trywait,timedwait}() named semaphore");

	const char* currentTest = NULL;

	// make sure the sem doesn't exist yet
	sem_unlink(kSemName1);

	// open non-existing with O_CREAT
	TEST("sem_open(O_CREAT) non-existing");
	sem_t* sem = sem_open(kSemName1, O_CREAT, S_IRUSR | S_IWUSR, 1);
	assert_posix_bool_success(sem != SEM_FAILED);

	TEST("sem_getvalue()");
	int value;
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// post
	TEST("sem_post() no waiting");
	assert_posix_success(sem_post(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(2, value);

	// wait
	TEST("sem_wait() non-blocking");
	assert_posix_success(sem_wait(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// wait
	TEST("sem_wait() non-blocking");
	assert_posix_success(sem_wait(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));

	// re-open existing
	TEST("sem_open() existing");
	sem = sem_open(kSemName1, 0);
	assert_posix_bool_success(sem != SEM_FAILED);

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// post
	TEST("sem_post() no waiting");
	assert_posix_success(sem_post(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// post
	TEST("sem_post() no waiting");
	assert_posix_success(sem_post(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(2, value);

	// trywait
	TEST("sem_trywait() success");
	assert_posix_success(sem_trywait(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// trywait
	TEST("sem_trywait() success");
	assert_posix_success(sem_trywait(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// trywait failure
	TEST("sem_trywait() failure");
	assert_posix_error(EAGAIN, sem_trywait(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// post
	TEST("sem_post() no waiting");
	assert_posix_success(sem_post(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// post
	TEST("sem_post() no waiting");
	assert_posix_success(sem_post(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(2, value);

	// timedwait
	TEST("sem_timedwait() success");
	timespec timeout;
	assert_posix_success(sem_timedwait(sem,
		absolute_timeout(timeout, 1000000)));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	TEST("sem_timedwait() success");
	assert_posix_success(sem_timedwait(sem,
		absolute_timeout(timeout, 1000000)));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("sem_timedwait() timeout");
	bigtime_t startTime = system_time();
	assert_posix_error(ETIMEDOUT, sem_timedwait(sem,
		absolute_timeout(timeout, 1000000)));
	bigtime_t diffTime = system_time() - startTime;
	assert_time_equals(1000000, diffTime);

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));

	TEST("done");
}


static void
test_post_wait_unnamed()
{
	TEST_SET("sem_{post,wait,trywait,timedwait}() unnamed semaphore");

	const char* currentTest = NULL;

	// init
	TEST("sem_init()");
	sem_t _sem;
	assert_posix_success(sem_init(&_sem, 0, 1));
	sem_t* sem = &_sem;

	TEST("sem_getvalue()");
	int value;
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// post
	TEST("sem_post() no waiting");
	assert_posix_success(sem_post(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(2, value);

	// wait
	TEST("sem_wait() non-blocking");
	assert_posix_success(sem_wait(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// wait
	TEST("sem_wait() non-blocking");
	assert_posix_success(sem_wait(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// post
	TEST("sem_post() no waiting");
	assert_posix_success(sem_post(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// post
	TEST("sem_post() no waiting");
	assert_posix_success(sem_post(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(2, value);

	// trywait
	TEST("sem_trywait() success");
	assert_posix_success(sem_trywait(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// trywait
	TEST("sem_trywait() success");
	assert_posix_success(sem_trywait(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// trywait failure
	TEST("sem_trywait() failure");
	assert_posix_error(EAGAIN, sem_trywait(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// post
	TEST("sem_post() no waiting");
	assert_posix_success(sem_post(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// post
	TEST("sem_post() no waiting");
	assert_posix_success(sem_post(sem));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(2, value);

	// timedwait
	TEST("sem_timedwait() success");
	timespec timeout;
	assert_posix_success(sem_timedwait(sem,
		absolute_timeout(timeout, 1000000)));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	TEST("sem_timedwait() success");
	assert_posix_success(sem_timedwait(sem,
		absolute_timeout(timeout, 1000000)));

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("sem_timedwait() timeout");
	bigtime_t startTime = system_time();
	assert_posix_error(ETIMEDOUT, sem_timedwait(sem,
		absolute_timeout(timeout, 1000000)));
	bigtime_t diffTime = system_time() - startTime;
	assert_time_equals(1000000, diffTime);

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// destroy
	TEST("sem_destroy()");
	assert_posix_success(sem_destroy(sem));

	TEST("done");
}


static void
test_post_wait_named_fork()
{
	TEST_SET("sem_{post,wait,trywait,timedwait}() named semaphore with fork()");

	const char* currentTest = NULL;

	// make sure the sem doesn't exist yet
	sem_unlink(kSemName1);

	// open non-existing with O_CREAT
	TEST("sem_open(O_CREAT) non-existing");
	sem_t* sem = sem_open(kSemName1, O_CREAT, S_IRUSR | S_IWUSR, 0);
	assert_posix_bool_success(sem != SEM_FAILED);

	TEST("sem_getvalue()");
	int value;
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("unblock child after wait");
	pid_t child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		bigtime_t startTime = system_time();
		assert_posix_success(sem_wait(sem));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		exit(0);
	} else {
		// parent
		sleep(1);
		assert_posix_success(sem_post(sem));
		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("unblock parent after wait");
	child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		sleep(1);
		assert_posix_success(sem_post(sem));

		exit(0);
	} else {
		// parent
		bigtime_t startTime = system_time();
		assert_posix_success(sem_wait(sem));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("unblock child after wait before timeout");
	child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		timespec timeout;
		bigtime_t startTime = system_time();
		assert_posix_success(sem_timedwait(sem,
			absolute_timeout(timeout, 2000000)));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		exit(0);
	} else {
		// parent
		sleep(1);
		assert_posix_success(sem_post(sem));
		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("unblock child after wait after timeout");
	child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		timespec timeout;
		bigtime_t startTime = system_time();
		assert_posix_error(ETIMEDOUT, sem_timedwait(sem,
			absolute_timeout(timeout, 1000000)));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		exit(0);
	} else {
		// parent
		sleep(2);
		assert_posix_success(sem_post(sem));
		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));

	TEST("done");
}


static void
test_post_wait_named_fork2()
{
	TEST_SET("sem_{post,wait,trywait,timedwait}() named semaphore open after "
		"fork");

	const char* currentTest = NULL;

	// make sure the sem doesn't exist yet
	sem_unlink(kSemName1);

	// open non-existing with O_CREAT
	TEST("sem_open(O_CREAT) non-existing");
	sem_t* sem = sem_open(kSemName1, O_CREAT, S_IRUSR | S_IWUSR, 0);
	assert_posix_bool_success(sem != SEM_FAILED);

	TEST("sem_getvalue()");
	int value;
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));
	sem = NULL;

	TEST("unblock child after wait");
	pid_t child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		sem = sem_open(kSemName1, 0);
		assert_posix_bool_success(sem != SEM_FAILED);

		bigtime_t startTime = system_time();
		assert_posix_success(sem_wait(sem));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		exit(0);
	} else {
		// parent
		sem = sem_open(kSemName1, 0);
		assert_posix_bool_success(sem != SEM_FAILED);

		sleep(1);
		assert_posix_success(sem_post(sem));
		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));
	sem = NULL;

	TEST("unblock child after wait before timeout");
	child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		sem = sem_open(kSemName1, 0);
		assert_posix_bool_success(sem != SEM_FAILED);

		timespec timeout;
		bigtime_t startTime = system_time();
		assert_posix_success(sem_timedwait(sem,
			absolute_timeout(timeout, 2000000)));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		exit(0);
	} else {
		// parent
		sem = sem_open(kSemName1, 0);
		assert_posix_bool_success(sem != SEM_FAILED);

		sleep(1);
		assert_posix_success(sem_post(sem));
		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));
	sem = NULL;

	TEST("unblock child after wait after timeout");
	child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		sem = sem_open(kSemName1, 0);
		assert_posix_bool_success(sem != SEM_FAILED);

		timespec timeout;
		bigtime_t startTime = system_time();
		assert_posix_error(ETIMEDOUT, sem_timedwait(sem,
			absolute_timeout(timeout, 1000000)));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		exit(0);
	} else {
		// parent
		sem = sem_open(kSemName1, 0);
		assert_posix_bool_success(sem != SEM_FAILED);

		sleep(2);
		assert_posix_success(sem_post(sem));
		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// close
	TEST("sem_close()");
	assert_posix_success(sem_close(sem));

	TEST("done");
}


static void
test_post_wait_unnamed_fork()
{
	TEST_SET("sem_{post,wait,trywait,timedwait}() unnamed semaphore with "
		"fork()");

	const char* currentTest = NULL;

	// init
	TEST("sem_init()");
	sem_t _sem;
	assert_posix_success(sem_init(&_sem, 0, 1));
	sem_t* sem = &_sem;

	TEST("sem_getvalue()");
	int value;
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	TEST("sem_wait() on fork()ed unnamed sem in parent and child");
	pid_t child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		sleep(1);
		assert_posix_success(sem_wait(sem));

		assert_posix_success(sem_getvalue(sem, &value));
		assert_equals(0, value);

		exit(0);
	} else {
		// parent
		assert_posix_success(sem_wait(sem));
		assert_posix_success(sem_getvalue(sem, &value));
		assert_equals(0, value);

		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("sem_post() on fork()ed unnamed sem in parent and child");
	child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		assert_posix_success(sem_post(sem));

		assert_posix_success(sem_getvalue(sem, &value));
		assert_equals(1, value);

		exit(0);
	} else {
		// parent
		assert_posix_success(sem_post(sem));
		assert_posix_success(sem_getvalue(sem, &value));
		assert_equals(1, value);

		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// destroy
	TEST("sem_destroy()");
	assert_posix_success(sem_destroy(sem));

	TEST("done");
}


static void
test_post_wait_unnamed_fork_shared()
{
	TEST_SET("sem_{post,wait,trywait,timedwait}() unnamed semaphore with "
		"fork() in shared memory");

	const char* currentTest = NULL;

	// create shared memory area
	void* address = mmap(NULL, 4096, PROT_READ | PROT_WRITE,
		MAP_SHARED | MAP_ANON, -1, 0);
	assert_posix_bool_success(address != MAP_FAILED);

	// init
	TEST("sem_init()");
	sem_t* sem = (sem_t*)address;
	assert_posix_success(sem_init(sem, 1, 0));

	TEST("sem_getvalue()");
	int value;
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("unblock child after wait");
	pid_t child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		bigtime_t startTime = system_time();
		assert_posix_success(sem_wait(sem));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		exit(0);
	} else {
		// parent
		sleep(1);
		assert_posix_success(sem_post(sem));
		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("unblock parent after wait");
	child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		sleep(1);
		assert_posix_success(sem_post(sem));

		exit(0);
	} else {
		// parent
		bigtime_t startTime = system_time();
		assert_posix_success(sem_wait(sem));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("unblock child after wait before timeout");
	child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		timespec timeout;
		bigtime_t startTime = system_time();
		assert_posix_success(sem_timedwait(sem,
			absolute_timeout(timeout, 2000000)));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		exit(0);
	} else {
		// parent
		sleep(1);
		assert_posix_success(sem_post(sem));
		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(0, value);

	TEST("unblock child after wait after timeout");
	child = fork();
	assert_posix_bool_success(child >= 0);

	if (child == 0) {
		// child
		timespec timeout;
		bigtime_t startTime = system_time();
		assert_posix_error(ETIMEDOUT, sem_timedwait(sem,
			absolute_timeout(timeout, 1000000)));
		bigtime_t diffTime = system_time() - startTime;
		assert_time_equals(1000000, diffTime);

		exit(0);
	} else {
		// parent
		sleep(2);
		assert_posix_success(sem_post(sem));
		wait_for_child(child);
	}

	TEST("sem_getvalue()");
	assert_posix_success(sem_getvalue(sem, &value));
	assert_equals(1, value);

	// destroy
	TEST("sem_destroy()");
	assert_posix_success(sem_destroy(sem));

	// unmap memory
	assert_posix_success(munmap(address, 4096));

	TEST("done");
}


int
main()
{
	test_open_close_unlink();
	test_init_destroy();
	test_open_close_fork();
	test_init_destroy_fork();
	test_post_wait_named();
	test_post_wait_unnamed();
	test_post_wait_named_fork();
	test_post_wait_named_fork2();
	test_post_wait_unnamed_fork();
	test_post_wait_unnamed_fork_shared();

	printf("\nall tests OK\n");
}