#if ENABLE_UNIT_TESTS
|
|
#include "UnitTest++.h"
|
#include "../Semaphore-c-api.h"
|
#include "../../Semaphore.h"
|
#include "../../Event.h"
|
#include "../../Thread.h"
|
|
SUITE(Semaphore)
|
{
|
struct SemaphoreFixture
|
{
|
SemaphoreFixture()
|
{
|
il2cpp::os::Thread::Init();
|
semaphore = UnityPalSemaphoreNew(0, 1);
|
unblockedThreadEvent = new il2cpp::os::Event();
|
unblockedThreadCount = 0;
|
}
|
|
~SemaphoreFixture()
|
{
|
UnityPalSemaphoreDelete(semaphore);
|
}
|
|
UnityPalSemaphore* semaphore;
|
il2cpp::os::Event* unblockedThreadEvent;
|
int unblockedThreadCount;
|
|
static void WaitForSemaphoreAndIncrementCounter(void* arg)
|
{
|
SemaphoreFixture* data = static_cast<SemaphoreFixture*>(arg);
|
UnityPalSemaphoreWait(data->semaphore, false);
|
data->unblockedThreadCount++;
|
data->unblockedThreadEvent->Set();
|
}
|
};
|
|
TEST_FIXTURE(SemaphoreFixture, CanCreateASemaphore)
|
{
|
CHECK_NOT_NULL(semaphore);
|
}
|
|
TEST_FIXTURE(SemaphoreFixture, VerifyThatPostingASemaphoreAGivenNumberOfTimesReturnsThePreviousCount)
|
{
|
int32_t actualPreviousCount = 0;
|
UnityPalSemaphorePost(semaphore, 2, &actualPreviousCount);
|
CHECK_EQUAL(0, actualPreviousCount);
|
}
|
|
TEST_FIXTURE(SemaphoreFixture, VerifyThatPostWithMultipleThreadsWaitingUnblocksOnlyOneThread)
|
{
|
// Create two threads which each increment the counter once.
|
il2cpp::os::Thread thread1;
|
thread1.Run(WaitForSemaphoreAndIncrementCounter, this);
|
|
il2cpp::os::Thread thread2;
|
thread2.Run(WaitForSemaphoreAndIncrementCounter, this);
|
|
UnityPalSemaphorePost(semaphore, 1, NULL);
|
|
// Let one thread increment and wait for it.
|
unblockedThreadEvent->Wait();
|
|
CHECK_EQUAL(1, unblockedThreadCount);
|
|
// Let the other thread increment and wait for it so we can exit the test cleanly.
|
UnityPalSemaphorePost(semaphore, 1, NULL);
|
unblockedThreadEvent->Wait();
|
|
thread1.Join();
|
thread2.Join();
|
}
|
|
struct SemaphoreHandleFixture
|
{
|
SemaphoreHandleFixture()
|
{
|
il2cpp::os::Thread::Init();
|
semaphore = UnityPalSemaphoreNew(0, 1);
|
semaphoreHandle = UnityPalSemaphoreHandleNew(semaphore);
|
unblockedThreadEvent = new il2cpp::os::Event();
|
unblockedThreadCount = 0;
|
}
|
|
~SemaphoreHandleFixture()
|
{
|
UnityPalSemaphoreHandleDelete(semaphoreHandle);
|
}
|
|
UnityPalSemaphore* semaphore;
|
UnityPalSemaphoreHandle* semaphoreHandle;
|
il2cpp::os::Event* unblockedThreadEvent;
|
int unblockedThreadCount;
|
|
static void WaitForSemaphoreAndIncrementCounter(void* arg)
|
{
|
SemaphoreHandleFixture* data = static_cast<SemaphoreHandleFixture*>(arg);
|
UnityPalSemaphoreHandleWait(data->semaphoreHandle);
|
data->unblockedThreadCount++;
|
data->unblockedThreadEvent->Set();
|
}
|
};
|
|
TEST_FIXTURE(SemaphoreHandleFixture, CanCreateASemaphoreHandle)
|
{
|
CHECK_NOT_NULL(semaphoreHandle);
|
}
|
|
TEST_FIXTURE(SemaphoreHandleFixture, VerifyThatPostingASemaphoreHandleAGivenNumberOfTimesReturnsThePreviousCount)
|
{
|
int32_t actualPreviousCount = 0;
|
UnityPalSemaphoreHandleSignal(semaphoreHandle);
|
CHECK_EQUAL(0, actualPreviousCount);
|
}
|
|
TEST_FIXTURE(SemaphoreHandleFixture, VerifyThatPostHandleWithMultipleThreadsWaitingUnblocksOnlyOneThread)
|
{
|
// Create two threads which each increment the counter once.
|
il2cpp::os::Thread thread1;
|
thread1.Run(WaitForSemaphoreAndIncrementCounter, this);
|
|
il2cpp::os::Thread thread2;
|
thread2.Run(WaitForSemaphoreAndIncrementCounter, this);
|
|
UnityPalSemaphoreHandleSignal(semaphoreHandle);
|
|
// Let one thread increment and wait for it.
|
unblockedThreadEvent->Wait();
|
|
CHECK_EQUAL(1, unblockedThreadCount);
|
|
// Let the other thread increment and wait for it so we can exit the test cleanly.
|
UnityPalSemaphoreHandleSignal(semaphoreHandle);
|
unblockedThreadEvent->Wait();
|
|
thread1.Join();
|
thread2.Join();
|
}
|
}
|
|
#endif // ENABLE_UNIT_TESTS
|
