native_client_sdk/src/libraries/nacl_io_test/event_test.cc - platform/external/chromium_org - Git at Google

 /* Copyright (c) 2013 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/time.h>

 #include "gtest/gtest.h"

 #include "nacl_io/event_emitter.h"
 #include "nacl_io/event_listener.h"


 using namespace nacl_io;
 using namespace sdk_util;

 class EventEmitterTester : public EventEmitter {
  public:
   EventEmitterTester() : event_status_(0), event_cnt_(0) {}

   void SetEventStatus(uint32_t bits) { event_status_ = bits; }
   uint32_t GetEventStatus() { return event_status_; }

   int GetType() { return S_IFSOCK; }

   int NumEvents() { return event_cnt_; }

  public:
   // Make this function public for testing
   void RaiseEvent(uint32_t events) {
     EventEmitter::RaiseEvent(events);
   }

     // Called after registering locally, but while lock is still held.
   void ChainRegisterEventInfo(const ScopedEventInfo& event) {
     event_cnt_++;
   }

   // Called before unregistering locally, but while lock is still held.
   void ChainUnregisterEventInfo(const ScopedEventInfo& event) {
     event_cnt_--;
   }

  protected:
   uint32_t event_status_;
   uint32_t event_cnt_;
 };


 const int MAX_EVENTS = 8;

 // IDs for Emitters
 const int ID_EMITTER = 5;
 const int ID_LISTENER = 6;
 const int ID_EMITTER_DUP = 7;

 // Kernel Event values
 const uint32_t KE_EXPECTED = 4;
 const uint32_t KE_FILTERED = 2;
 const uint32_t KE_NONE = 0;

 // User Data values
 const uint64_t USER_DATA_A = 1;
 const uint64_t USER_DATA_B = 5;

 // Timeout durations
 const int TIMEOUT_IMMEDIATE = 0;
 const int TIMEOUT_SHORT= 100;
 const int TIMEOUT_LONG = 500;
 const int TIMEOUT_NEVER = -1;
 const int TIMEOUT_VERY_LONG = 1000;

 TEST(EventTest, EmitterBasic) {
   ScopedRef<EventEmitterTester> emitter(new EventEmitterTester());
   ScopedRef<EventEmitter> null_emitter;

   ScopedEventListener listener(new EventListener);

   // Verify construction
   EXPECT_EQ(0, emitter->NumEvents());
   EXPECT_EQ(0, emitter->GetEventStatus());

   // Verify status
   emitter->SetEventStatus(KE_EXPECTED);
   EXPECT_EQ(KE_EXPECTED, emitter->GetEventStatus());

   // Fail to update or free an ID not in the set
   EXPECT_EQ(ENOENT, listener->Update(ID_EMITTER, KE_EXPECTED, USER_DATA_A));
   EXPECT_EQ(ENOENT, listener->Free(ID_EMITTER));

   // Fail to Track self
   EXPECT_EQ(EINVAL, listener->Track(ID_LISTENER,
                                     listener,
                                     KE_EXPECTED,
                                     USER_DATA_A));

   // Set the emitter filter and data
   EXPECT_EQ(0, listener->Track(ID_EMITTER, emitter, KE_EXPECTED, USER_DATA_A));
   EXPECT_EQ(1, emitter->NumEvents());

   // Fail to add the same ID
   EXPECT_EQ(EEXIST,
             listener->Track(ID_EMITTER, emitter, KE_EXPECTED, USER_DATA_A));
   EXPECT_EQ(1, emitter->NumEvents());

   int event_cnt = 0;
   EventData ev[MAX_EVENTS];

   // Do not allow a wait with a zero events count.
   EXPECT_EQ(EINVAL, listener->Wait(ev, 0, TIMEOUT_IMMEDIATE, &event_cnt));

   // Do not allow a wait with a negative events count.
   EXPECT_EQ(EINVAL, listener->Wait(ev, -1, TIMEOUT_IMMEDIATE, &event_cnt));

   // Do not allow a wait with a NULL EventData pointer
   EXPECT_EQ(EFAULT,
             listener->Wait(NULL, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));

   // Return with no events if the Emitter has no signals set.
   memset(ev, 0, sizeof(ev));
   event_cnt = 100;
   emitter->SetEventStatus(KE_NONE);
   EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
   EXPECT_EQ(0, event_cnt);

   // Return with no events if the Emitter has a filtered signals set.
   memset(ev, 0, sizeof(ev));
   event_cnt = 100;
   emitter->SetEventStatus(KE_FILTERED);
   EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
   EXPECT_EQ(0, event_cnt);

   // Return with one event if the Emitter has the expected signal set.
   memset(ev, 0, sizeof(ev));
   event_cnt = 100;
   emitter->SetEventStatus(KE_EXPECTED);
   EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
   EXPECT_EQ(1, event_cnt);
   EXPECT_EQ(USER_DATA_A, ev[0].user_data);
   EXPECT_EQ(KE_EXPECTED, ev[0].events);

   // Return with one event containing only the expected signal.
   memset(ev, 0, sizeof(ev));
   event_cnt = 100;
   emitter->SetEventStatus(KE_EXPECTED | KE_FILTERED);
   EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
   EXPECT_EQ(1, event_cnt);
   EXPECT_EQ(USER_DATA_A, ev[0].user_data);
   EXPECT_EQ(KE_EXPECTED, ev[0].events);

   // Change the USER_DATA on an existing event
   EXPECT_EQ(0, listener->Update(ID_EMITTER, KE_EXPECTED, USER_DATA_B));

   // Return with one event signaled with the alternate USER DATA
   memset(ev, 0, sizeof(ev));
   event_cnt = 100;
   emitter->SetEventStatus(KE_EXPECTED | KE_FILTERED);
   EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, 0, &event_cnt));
   EXPECT_EQ(1, event_cnt);
   EXPECT_EQ(USER_DATA_B, ev[0].user_data);
   EXPECT_EQ(KE_EXPECTED, ev[0].events);

   // Reset the USER_DATA.
   EXPECT_EQ(0, listener->Update(ID_EMITTER, KE_EXPECTED, USER_DATA_A));

   // Support adding a DUP.
   EXPECT_EQ(0, listener->Track(ID_EMITTER_DUP,
                                emitter,
                                KE_EXPECTED,
                                USER_DATA_A));
   EXPECT_EQ(2, emitter->NumEvents());

   // Return unsignaled.
   memset(ev, 0, sizeof(ev));
   emitter->SetEventStatus(KE_NONE);
   event_cnt = 100;
   EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
   EXPECT_EQ(0, event_cnt);

   // Return with two event signaled with expected data.
   memset(ev, 0, sizeof(ev));
   emitter->SetEventStatus(KE_EXPECTED);
   event_cnt = 100;
   EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
   EXPECT_EQ(2, event_cnt);
   EXPECT_EQ(USER_DATA_A, ev[0].user_data);
   EXPECT_EQ(KE_EXPECTED, ev[0].events);
   EXPECT_EQ(USER_DATA_A, ev[1].user_data);
   EXPECT_EQ(KE_EXPECTED, ev[1].events);
 }

 long Duration(struct timeval* start, struct timeval* end) {
   if (start->tv_usec > end->tv_usec) {
     end->tv_sec -= 1;
     end->tv_usec += 1000000;
   }
   long cur_time = 1000 * (end->tv_sec - start->tv_sec);
   cur_time += (end->tv_usec - start->tv_usec) / 1000;
   return cur_time;
 }


 // Run a timed wait, and return the average of 8 iterations to reduce
 // chance of false negative on outlier.
 const int TRIES_TO_AVERAGE = 8;
 bool TimedListen(ScopedEventListener& listen,
                  EventData* ev,
                  int ev_max,
                  int ev_expect,
                  int ms_wait,
                  long* duration) {

   struct timeval start;
   struct timeval end;
   long total_time = 0;

   for (int a=0; a < TRIES_TO_AVERAGE; a++) {
     gettimeofday(&start, NULL);

     int signaled;

     EXPECT_EQ(0, listen->Wait(ev, ev_max, ms_wait, &signaled));
     EXPECT_EQ(signaled, ev_expect);

     if (signaled != ev_expect) {
       return false;
     }

     gettimeofday(&end, NULL);

     long cur_time = Duration(&start, &end);
     total_time += cur_time;
   }

   *duration = total_time / TRIES_TO_AVERAGE;
   return true;
 }


 // NOTE:  These timing tests are potentially flaky, the real test is
 // for the zero timeout should be, has the ConditionVariable been waited on?
 // Once we provide a debuggable SimpleCond and SimpleLock we can actually test
 // the correct thing.

 // Normal scheduling would expect us to see ~10ms accuracy, but we'll
 // use a much bigger number (yet smaller than the MAX_MS_TIMEOUT).
 const int SCHEDULING_GRANULARITY = 100;

 const int EXPECT_ONE_EVENT = 1;
 const int EXPECT_NO_EVENT = 0;

 TEST(EventTest, EmitterTimeout) {
   ScopedRef<EventEmitterTester> emitter(new EventEmitterTester());
   ScopedEventListener listener(new EventListener());
   long duration;

   EventData ev[MAX_EVENTS];
   memset(ev, 0, sizeof(ev));
   EXPECT_EQ(0, listener->Track(ID_EMITTER, emitter, KE_EXPECTED, USER_DATA_A));

   // Return immediately when emitter is signaled, with no timeout
   emitter->SetEventStatus(KE_EXPECTED);
   memset(ev, 0, sizeof(ev));
   EXPECT_TRUE(TimedListen(listener, ev, MAX_EVENTS, EXPECT_ONE_EVENT,
                           TIMEOUT_IMMEDIATE, &duration));
   EXPECT_EQ(USER_DATA_A, ev[0].user_data);
   EXPECT_EQ(KE_EXPECTED, ev[0].events);
   EXPECT_EQ(0, duration);

   // Return immediately when emitter is signaled, even with timeout
   emitter->SetEventStatus(KE_EXPECTED);
   memset(ev, 0, sizeof(ev));
   EXPECT_TRUE(TimedListen(listener, ev, MAX_EVENTS, EXPECT_ONE_EVENT,
                           TIMEOUT_LONG, &duration));
   EXPECT_EQ(USER_DATA_A, ev[0].user_data);
   EXPECT_EQ(KE_EXPECTED, ev[0].events);
   EXPECT_GT(SCHEDULING_GRANULARITY, duration);

   // Return immediately if Emiiter is already signaled when blocking forever.
   emitter->SetEventStatus(KE_EXPECTED);
   memset(ev, 0, sizeof(ev));
   EXPECT_TRUE(TimedListen(listener, ev, MAX_EVENTS, EXPECT_ONE_EVENT,
                           TIMEOUT_NEVER, &duration));
   EXPECT_EQ(USER_DATA_A, ev[0].user_data);
   EXPECT_EQ(KE_EXPECTED, ev[0].events);
   EXPECT_GT(SCHEDULING_GRANULARITY, duration);

   // Return immediately if Emitter is no signaled when not blocking.
   emitter->SetEventStatus(KE_NONE);
   memset(ev, 0, sizeof(ev));
   EXPECT_TRUE(TimedListen(listener, ev, MAX_EVENTS, EXPECT_NO_EVENT,
                           TIMEOUT_IMMEDIATE, &duration));
   EXPECT_EQ(0, duration);

   // Wait TIMEOUT_LONG if the emitter is not in a signaled state.
   emitter->SetEventStatus(KE_NONE);
   memset(ev, 0, sizeof(ev));
   EXPECT_TRUE(TimedListen(listener, ev, MAX_EVENTS, EXPECT_NO_EVENT,
                           TIMEOUT_LONG, &duration));
   EXPECT_LT(TIMEOUT_LONG - 1, duration);
   EXPECT_GT(TIMEOUT_LONG + SCHEDULING_GRANULARITY, duration);
 }

 struct SignalInfo {
   EventEmitterTester* em;
   unsigned int ms_wait;
   uint32_t events;
 };

 void *SignalEmitter(void *ptr) {
   SignalInfo* info = (SignalInfo*) ptr;
   struct timespec ts;
   ts.tv_sec = 0;
   ts.tv_nsec = info->ms_wait * 1000000;

   nanosleep(&ts, NULL);

   info->em->RaiseEvent(info->events);
   return NULL;
 }

 TEST(EventTest, EmitterSignalling) {
   ScopedRef<EventEmitterTester> emitter(new EventEmitterTester());
   ScopedEventListener listener(new EventListener);

   SignalInfo siginfo;
   struct timeval start;
   struct timeval end;
   long duration;

   EventData ev[MAX_EVENTS];
   memset(ev, 0, sizeof(ev));
   EXPECT_EQ(0, listener->Track(ID_EMITTER, emitter, KE_EXPECTED, USER_DATA_A));

   // Setup another thread to wait 1/4 of the max time, and signal both
   // an expected, and unexpected value.
   siginfo.em = emitter.get();
   siginfo.ms_wait = TIMEOUT_SHORT;
   siginfo.events = KE_EXPECTED | KE_FILTERED;
   pthread_t tid;
   pthread_create(&tid, NULL, SignalEmitter, &siginfo);

   // Wait for the signal from the other thread and time it.
   gettimeofday(&start, NULL);
   int cnt = 0;
   EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_VERY_LONG, &cnt));
   EXPECT_EQ(1, cnt);
   gettimeofday(&end, NULL);

   // Verify the wait duration, and that we only recieved the expected signal.
   duration = Duration(&start, &end);
   EXPECT_GT(TIMEOUT_SHORT + SCHEDULING_GRANULARITY, duration);
   EXPECT_LT(TIMEOUT_SHORT - 1, duration);
   EXPECT_EQ(USER_DATA_A, ev[0].user_data);
   EXPECT_EQ(KE_EXPECTED, ev[0].events);
 }
	/* Copyright (c) 2013 The Chromium Authors. All rights reserved.
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include <errno.h>
	#include <fcntl.h>
	#include <sys/stat.h>
	#include <sys/time.h>

	#include "gtest/gtest.h"

	#include "nacl_io/event_emitter.h"
	#include "nacl_io/event_listener.h"


	using namespace nacl_io;
	using namespace sdk_util;

	class EventEmitterTester : public EventEmitter {
	public:
	EventEmitterTester() : event_status_(0), event_cnt_(0) {}

	void SetEventStatus(uint32_t bits) { event_status_ = bits; }
	uint32_t GetEventStatus() { return event_status_; }

	int GetType() { return S_IFSOCK; }

	int NumEvents() { return event_cnt_; }

	public:
	// Make this function public for testing
	void RaiseEvent(uint32_t events) {
	EventEmitter::RaiseEvent(events);
	}

	// Called after registering locally, but while lock is still held.
	void ChainRegisterEventInfo(const ScopedEventInfo& event) {
	event_cnt_++;
	}

	// Called before unregistering locally, but while lock is still held.
	void ChainUnregisterEventInfo(const ScopedEventInfo& event) {
	event_cnt_--;
	}

	protected:
	uint32_t event_status_;
	uint32_t event_cnt_;
	};


	const int MAX_EVENTS = 8;

	// IDs for Emitters
	const int ID_EMITTER = 5;
	const int ID_LISTENER = 6;
	const int ID_EMITTER_DUP = 7;

	// Kernel Event values
	const uint32_t KE_EXPECTED = 4;
	const uint32_t KE_FILTERED = 2;
	const uint32_t KE_NONE = 0;

	// User Data values
	const uint64_t USER_DATA_A = 1;
	const uint64_t USER_DATA_B = 5;

	// Timeout durations
	const int TIMEOUT_IMMEDIATE = 0;
	const int TIMEOUT_SHORT= 100;
	const int TIMEOUT_LONG = 500;
	const int TIMEOUT_NEVER = -1;
	const int TIMEOUT_VERY_LONG = 1000;

	TEST(EventTest, EmitterBasic) {
	ScopedRef<EventEmitterTester> emitter(new EventEmitterTester());
	ScopedRef<EventEmitter> null_emitter;

	ScopedEventListener listener(new EventListener);

	// Verify construction
	EXPECT_EQ(0, emitter->NumEvents());
	EXPECT_EQ(0, emitter->GetEventStatus());

	// Verify status
	emitter->SetEventStatus(KE_EXPECTED);
	EXPECT_EQ(KE_EXPECTED, emitter->GetEventStatus());

	// Fail to update or free an ID not in the set
	EXPECT_EQ(ENOENT, listener->Update(ID_EMITTER, KE_EXPECTED, USER_DATA_A));
	EXPECT_EQ(ENOENT, listener->Free(ID_EMITTER));

	// Fail to Track self
	EXPECT_EQ(EINVAL, listener->Track(ID_LISTENER,
	listener,
	KE_EXPECTED,
	USER_DATA_A));

	// Set the emitter filter and data
	EXPECT_EQ(0, listener->Track(ID_EMITTER, emitter, KE_EXPECTED, USER_DATA_A));
	EXPECT_EQ(1, emitter->NumEvents());

	// Fail to add the same ID
	EXPECT_EQ(EEXIST,
	listener->Track(ID_EMITTER, emitter, KE_EXPECTED, USER_DATA_A));
	EXPECT_EQ(1, emitter->NumEvents());

	int event_cnt = 0;
	EventData ev[MAX_EVENTS];

	// Do not allow a wait with a zero events count.
	EXPECT_EQ(EINVAL, listener->Wait(ev, 0, TIMEOUT_IMMEDIATE, &event_cnt));

	// Do not allow a wait with a negative events count.
	EXPECT_EQ(EINVAL, listener->Wait(ev, -1, TIMEOUT_IMMEDIATE, &event_cnt));

	// Do not allow a wait with a NULL EventData pointer
	EXPECT_EQ(EFAULT,
	listener->Wait(NULL, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));

	// Return with no events if the Emitter has no signals set.
	memset(ev, 0, sizeof(ev));
	event_cnt = 100;
	emitter->SetEventStatus(KE_NONE);
	EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
	EXPECT_EQ(0, event_cnt);

	// Return with no events if the Emitter has a filtered signals set.
	memset(ev, 0, sizeof(ev));
	event_cnt = 100;
	emitter->SetEventStatus(KE_FILTERED);
	EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
	EXPECT_EQ(0, event_cnt);

	// Return with one event if the Emitter has the expected signal set.
	memset(ev, 0, sizeof(ev));
	event_cnt = 100;
	emitter->SetEventStatus(KE_EXPECTED);
	EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
	EXPECT_EQ(1, event_cnt);
	EXPECT_EQ(USER_DATA_A, ev[0].user_data);
	EXPECT_EQ(KE_EXPECTED, ev[0].events);

	// Return with one event containing only the expected signal.
	memset(ev, 0, sizeof(ev));
	event_cnt = 100;
	emitter->SetEventStatus(KE_EXPECTED \| KE_FILTERED);
	EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
	EXPECT_EQ(1, event_cnt);
	EXPECT_EQ(USER_DATA_A, ev[0].user_data);
	EXPECT_EQ(KE_EXPECTED, ev[0].events);

	// Change the USER_DATA on an existing event
	EXPECT_EQ(0, listener->Update(ID_EMITTER, KE_EXPECTED, USER_DATA_B));

	// Return with one event signaled with the alternate USER DATA
	memset(ev, 0, sizeof(ev));
	event_cnt = 100;
	emitter->SetEventStatus(KE_EXPECTED \| KE_FILTERED);
	EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, 0, &event_cnt));
	EXPECT_EQ(1, event_cnt);
	EXPECT_EQ(USER_DATA_B, ev[0].user_data);
	EXPECT_EQ(KE_EXPECTED, ev[0].events);

	// Reset the USER_DATA.
	EXPECT_EQ(0, listener->Update(ID_EMITTER, KE_EXPECTED, USER_DATA_A));

	// Support adding a DUP.
	EXPECT_EQ(0, listener->Track(ID_EMITTER_DUP,
	emitter,
	KE_EXPECTED,
	USER_DATA_A));
	EXPECT_EQ(2, emitter->NumEvents());

	// Return unsignaled.
	memset(ev, 0, sizeof(ev));
	emitter->SetEventStatus(KE_NONE);
	event_cnt = 100;
	EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
	EXPECT_EQ(0, event_cnt);

	// Return with two event signaled with expected data.
	memset(ev, 0, sizeof(ev));
	emitter->SetEventStatus(KE_EXPECTED);
	event_cnt = 100;
	EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_IMMEDIATE, &event_cnt));
	EXPECT_EQ(2, event_cnt);
	EXPECT_EQ(USER_DATA_A, ev[0].user_data);
	EXPECT_EQ(KE_EXPECTED, ev[0].events);
	EXPECT_EQ(USER_DATA_A, ev[1].user_data);
	EXPECT_EQ(KE_EXPECTED, ev[1].events);
	}

	long Duration(struct timeval* start, struct timeval* end) {
	if (start->tv_usec > end->tv_usec) {
	end->tv_sec -= 1;
	end->tv_usec += 1000000;
	}
	long cur_time = 1000 * (end->tv_sec - start->tv_sec);
	cur_time += (end->tv_usec - start->tv_usec) / 1000;
	return cur_time;
	}


	// Run a timed wait, and return the average of 8 iterations to reduce
	// chance of false negative on outlier.
	const int TRIES_TO_AVERAGE = 8;
	bool TimedListen(ScopedEventListener& listen,
	EventData* ev,
	int ev_max,
	int ev_expect,
	int ms_wait,
	long* duration) {

	struct timeval start;
	struct timeval end;
	long total_time = 0;

	for (int a=0; a < TRIES_TO_AVERAGE; a++) {
	gettimeofday(&start, NULL);

	int signaled;

	EXPECT_EQ(0, listen->Wait(ev, ev_max, ms_wait, &signaled));
	EXPECT_EQ(signaled, ev_expect);

	if (signaled != ev_expect) {
	return false;
	}

	gettimeofday(&end, NULL);

	long cur_time = Duration(&start, &end);
	total_time += cur_time;
	}

	*duration = total_time / TRIES_TO_AVERAGE;
	return true;
	}


	// NOTE: These timing tests are potentially flaky, the real test is
	// for the zero timeout should be, has the ConditionVariable been waited on?
	// Once we provide a debuggable SimpleCond and SimpleLock we can actually test
	// the correct thing.

	// Normal scheduling would expect us to see ~10ms accuracy, but we'll
	// use a much bigger number (yet smaller than the MAX_MS_TIMEOUT).
	const int SCHEDULING_GRANULARITY = 100;

	const int EXPECT_ONE_EVENT = 1;
	const int EXPECT_NO_EVENT = 0;

	TEST(EventTest, EmitterTimeout) {
	ScopedRef<EventEmitterTester> emitter(new EventEmitterTester());
	ScopedEventListener listener(new EventListener());
	long duration;

	EventData ev[MAX_EVENTS];
	memset(ev, 0, sizeof(ev));
	EXPECT_EQ(0, listener->Track(ID_EMITTER, emitter, KE_EXPECTED, USER_DATA_A));

	// Return immediately when emitter is signaled, with no timeout
	emitter->SetEventStatus(KE_EXPECTED);
	memset(ev, 0, sizeof(ev));
	EXPECT_TRUE(TimedListen(listener, ev, MAX_EVENTS, EXPECT_ONE_EVENT,
	TIMEOUT_IMMEDIATE, &duration));
	EXPECT_EQ(USER_DATA_A, ev[0].user_data);
	EXPECT_EQ(KE_EXPECTED, ev[0].events);
	EXPECT_EQ(0, duration);

	// Return immediately when emitter is signaled, even with timeout
	emitter->SetEventStatus(KE_EXPECTED);
	memset(ev, 0, sizeof(ev));
	EXPECT_TRUE(TimedListen(listener, ev, MAX_EVENTS, EXPECT_ONE_EVENT,
	TIMEOUT_LONG, &duration));
	EXPECT_EQ(USER_DATA_A, ev[0].user_data);
	EXPECT_EQ(KE_EXPECTED, ev[0].events);
	EXPECT_GT(SCHEDULING_GRANULARITY, duration);

	// Return immediately if Emiiter is already signaled when blocking forever.
	emitter->SetEventStatus(KE_EXPECTED);
	memset(ev, 0, sizeof(ev));
	EXPECT_TRUE(TimedListen(listener, ev, MAX_EVENTS, EXPECT_ONE_EVENT,
	TIMEOUT_NEVER, &duration));
	EXPECT_EQ(USER_DATA_A, ev[0].user_data);
	EXPECT_EQ(KE_EXPECTED, ev[0].events);
	EXPECT_GT(SCHEDULING_GRANULARITY, duration);

	// Return immediately if Emitter is no signaled when not blocking.
	emitter->SetEventStatus(KE_NONE);
	memset(ev, 0, sizeof(ev));
	EXPECT_TRUE(TimedListen(listener, ev, MAX_EVENTS, EXPECT_NO_EVENT,
	TIMEOUT_IMMEDIATE, &duration));
	EXPECT_EQ(0, duration);

	// Wait TIMEOUT_LONG if the emitter is not in a signaled state.
	emitter->SetEventStatus(KE_NONE);
	memset(ev, 0, sizeof(ev));
	EXPECT_TRUE(TimedListen(listener, ev, MAX_EVENTS, EXPECT_NO_EVENT,
	TIMEOUT_LONG, &duration));
	EXPECT_LT(TIMEOUT_LONG - 1, duration);
	EXPECT_GT(TIMEOUT_LONG + SCHEDULING_GRANULARITY, duration);
	}

	struct SignalInfo {
	EventEmitterTester* em;
	unsigned int ms_wait;
	uint32_t events;
	};

	void SignalEmitter(void ptr) {
	SignalInfo* info = (SignalInfo*) ptr;
	struct timespec ts;
	ts.tv_sec = 0;
	ts.tv_nsec = info->ms_wait * 1000000;

	nanosleep(&ts, NULL);

	info->em->RaiseEvent(info->events);
	return NULL;
	}

	TEST(EventTest, EmitterSignalling) {
	ScopedRef<EventEmitterTester> emitter(new EventEmitterTester());
	ScopedEventListener listener(new EventListener);

	SignalInfo siginfo;
	struct timeval start;
	struct timeval end;
	long duration;

	EventData ev[MAX_EVENTS];
	memset(ev, 0, sizeof(ev));
	EXPECT_EQ(0, listener->Track(ID_EMITTER, emitter, KE_EXPECTED, USER_DATA_A));

	// Setup another thread to wait 1/4 of the max time, and signal both
	// an expected, and unexpected value.
	siginfo.em = emitter.get();
	siginfo.ms_wait = TIMEOUT_SHORT;
	siginfo.events = KE_EXPECTED \| KE_FILTERED;
	pthread_t tid;
	pthread_create(&tid, NULL, SignalEmitter, &siginfo);

	// Wait for the signal from the other thread and time it.
	gettimeofday(&start, NULL);
	int cnt = 0;
	EXPECT_EQ(0, listener->Wait(ev, MAX_EVENTS, TIMEOUT_VERY_LONG, &cnt));
	EXPECT_EQ(1, cnt);
	gettimeofday(&end, NULL);

	// Verify the wait duration, and that we only recieved the expected signal.
	duration = Duration(&start, &end);
	EXPECT_GT(TIMEOUT_SHORT + SCHEDULING_GRANULARITY, duration);
	EXPECT_LT(TIMEOUT_SHORT - 1, duration);
	EXPECT_EQ(USER_DATA_A, ev[0].user_data);
	EXPECT_EQ(KE_EXPECTED, ev[0].events);
	}