text: 
  #include <winpr/crt.h>
  #include <winpr/synch.h>
  #include <winpr/thread.h>
  
  
  static BOOL test_mutex_basic(void)
  {
  	HANDLE mutex;
  	DWORD rc;
  
  	if (!(mutex = CreateMutex(NULL, FALSE, NULL)))
  	{
  		printf("%s: CreateMutex failed\n", __FUNCTION__);
  		return FALSE;
  	}
  
  	rc = WaitForSingleObject(mutex, INFINITE);
  
  	if (rc != WAIT_OBJECT_0)
  	{
  		printf("%s: WaitForSingleObject on mutex failed with %"PRIu32"\n", __FUNCTION__, rc);
  		return FALSE;
  	}
  
  	if (!ReleaseMutex(mutex))
  	{
  		printf("%s: ReleaseMutex failed\n", __FUNCTION__);
  		return FALSE;
  	}
  
  	if (ReleaseMutex(mutex))
  	{
  		printf("%s: ReleaseMutex unexpectedly succeeded on released mutex\n", __FUNCTION__);
  		return FALSE;
  	}
  
  	if (!CloseHandle(mutex))
  	{
  		printf("%s: CloseHandle on mutex failed\n", __FUNCTION__);
  		return FALSE;
  	}
  
  	return TRUE;
  }
  
  static BOOL test_mutex_recursive(void)
  {
  	HANDLE mutex;
  	DWORD rc, i, cnt = 50;
  
  	if (!(mutex = CreateMutex(NULL, TRUE, NULL)))
  	{
  		printf("%s: CreateMutex failed\n", __FUNCTION__);
  		return FALSE;
  	}
  
  	for (i = 0; i < cnt; i++)
  	{
  		rc = WaitForSingleObject(mutex, INFINITE);
  
  		if (rc != WAIT_OBJECT_0)
  		{
  			printf("%s: WaitForSingleObject #%"PRIu32" on mutex failed with %"PRIu32"\n", __FUNCTION__, i, rc);
  			return FALSE;
  		}
  	}
  
  	for (i = 0; i < cnt; i++)
  	{
  		if (!ReleaseMutex(mutex))
  		{
  			printf("%s: ReleaseMutex #%"PRIu32" failed\n", __FUNCTION__, i);
  			return FALSE;
  		}
  	}
  
  	if (!ReleaseMutex(mutex))
  	{
  		/* Note: The mutex was initially owned ! */
  		printf("%s: Final ReleaseMutex failed\n", __FUNCTION__);
  		return FALSE;
  	}
  
  	if (ReleaseMutex(mutex))
  	{
  		printf("%s: ReleaseMutex unexpectedly succeeded on released mutex\n", __FUNCTION__);
  		return FALSE;
  	}
  
  	if (!CloseHandle(mutex))
  	{
  		printf("%s: CloseHandle on mutex failed\n", __FUNCTION__);
  		return FALSE;
  	}
  
  	return TRUE;
  }
  
  static HANDLE thread1_mutex1 = NULL;
  static HANDLE thread1_mutex2 = NULL;
  static BOOL   thread1_failed = TRUE;
  
  static DWORD WINAPI test_mutex_thread1(LPVOID lpParam)
  {
  	HANDLE hStartEvent = (HANDLE)lpParam;
  	DWORD rc = 0;
  
  	if (WaitForSingleObject(hStartEvent, INFINITE) != WAIT_OBJECT_0)
  	{
  		fprintf(stderr, "%s: failed to wait for start event\n", __FUNCTION__);
  		return 0;
  	}
  
  	/**
  	 * at this point:
  	 * thread1_mutex1 is expected to be locked
  	 * thread1_mutex2 is expected to be unlocked
  	 * defined task:
  	 * try to lock thread1_mutex1 (expected to fail)
  	 * lock and unlock thread1_mutex2 (expected to work)
  	 */
  	rc = WaitForSingleObject(thread1_mutex1, 10);
  
  	if (rc != WAIT_TIMEOUT)
  	{
  		fprintf(stderr,
  		        "%s: WaitForSingleObject on thread1_mutex1 unexpectedly returned %"PRIu32" instead of WAIT_TIMEOUT (%u)\n",
  		        __FUNCTION__, rc, WAIT_TIMEOUT);
  		return 0;
  	}
  
  	rc = WaitForSingleObject(thread1_mutex2, 10);
  
  	if (rc != WAIT_OBJECT_0)
  	{
  		fprintf(stderr,
  		        "%s: WaitForSingleObject on thread1_mutex2 unexpectedly returned %"PRIu32" instead of WAIT_OBJECT_0\n",
  		        __FUNCTION__, rc);
  		return 0;
  	}
  
  	if (!ReleaseMutex(thread1_mutex2))
  	{
  		fprintf(stderr, "%s: ReleaseMutex failed on thread1_mutex2\n",	__FUNCTION__);
  		return 0;
  	}
  
  	thread1_failed = FALSE;
  	return 0;
  }
  
  static BOOL test_mutex_threading(void)
  {
  	HANDLE hThread = NULL;
  	HANDLE hStartEvent = NULL;
  
  	if (!(thread1_mutex1 = CreateMutex(NULL, TRUE, NULL)))
  	{
  		printf("%s: CreateMutex thread1_mutex1 failed\n", __FUNCTION__);
  		goto fail;
  	}
  
  	if (!(thread1_mutex2 = CreateMutex(NULL, FALSE, NULL)))
  	{
  		printf("%s: CreateMutex thread1_mutex2 failed\n", __FUNCTION__);
  		goto fail;
  	}
  
  	if (!(hStartEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
  	{
  		fprintf(stderr, "%s: error creating start event\n", __FUNCTION__);
  		goto fail;
  	}
  
  	thread1_failed = TRUE;
  
  	if (!(hThread = CreateThread(NULL, 0, test_mutex_thread1, (LPVOID)hStartEvent, 0, NULL)))
  	{
  		fprintf(stderr, "%s: error creating test_mutex_thread_1\n", __FUNCTION__);
  		goto fail;
  	}
  
  	Sleep(100);
  
  	if (!thread1_failed)
  	{
  		fprintf(stderr, "%s: thread1 premature success\n", __FUNCTION__);
  		goto fail;
  	}
  
  	SetEvent(hStartEvent);
  
  	if (WaitForSingleObject(hThread, 2000) != WAIT_OBJECT_0)
  	{
  		fprintf(stderr, "%s: thread1 premature success\n", __FUNCTION__);
  		goto fail;
  	}
  
  	if (thread1_failed)
  	{
  		fprintf(stderr, "%s: thread1 has not reported success\n", __FUNCTION__);
  		goto fail;
  	}
  
  	/**
  	 * - thread1 must not have succeeded to lock thread1_mutex1
  	 * - thread1 must have locked and unlocked thread1_mutex2
  	 */
  
  	if (!ReleaseMutex(thread1_mutex1))
  	{
  		printf("%s: ReleaseMutex unexpectedly failed on thread1_mutex1\n", __FUNCTION__);
  		goto fail;
  	}
  
  	if (ReleaseMutex(thread1_mutex2))
  	{
  		printf("%s: ReleaseMutex unexpectedly succeeded on thread1_mutex2\n", __FUNCTION__);
  		goto fail;
  	}
  
  	CloseHandle(hThread);
  	CloseHandle(hStartEvent);
  	CloseHandle(thread1_mutex1);
  	CloseHandle(thread1_mutex2);
  	return TRUE;
  fail:
  	ReleaseMutex(thread1_mutex1);
  	ReleaseMutex(thread1_mutex2);
  	CloseHandle(thread1_mutex1);
  	CloseHandle(thread1_mutex2);
  	CloseHandle(hStartEvent);
  	CloseHandle(hThread);
  	return FALSE;
  }
  
  int TestSynchMutex(int argc, char* argv[])
  {
  	int rc = 0;
  	WINPR_UNUSED(argc);
  	WINPR_UNUSED(argv);
  
  	if (!test_mutex_basic())
  		rc += 1;
  
  	if (!test_mutex_recursive())
  		rc += 2;
  
  	if (!test_mutex_threading())
  		rc += 4;
  
  	printf("TestSynchMutex result %d\n", rc);
  	return rc;
  }
  