public void TestGetConditions()
{
// Initialize
WaitSet waitSet = new WaitSet();
GuardCondition guardCondition = new GuardCondition();
GuardCondition otherGuardCondition = new GuardCondition();
ReturnCode result = waitSet.AttachCondition(guardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
result = waitSet.AttachCondition(otherGuardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
// Test with null parameter
result = waitSet.GetConditions(null);
Assert.AreEqual(ReturnCode.BadParameter, result);
// Test with correct parameter
List <Condition> conditions = new List <Condition>()
{
null
};
result = waitSet.GetConditions(conditions);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.IsNotNull(conditions);
Assert.AreEqual(2, conditions.Count);
Assert.IsNotNull(conditions[0]);
Assert.IsNotNull(conditions[1]);
Assert.IsTrue(conditions[0] != conditions[1]);
Assert.IsTrue(guardCondition == conditions[0] || guardCondition == conditions[1]);
Assert.IsTrue(otherGuardCondition == conditions[0] || otherGuardCondition == conditions[1]);
}
public void TestDetachCondition()
{
// Initialize
WaitSet waitSet = new WaitSet();
GuardCondition guardCondition = new GuardCondition();
ReturnCode result = waitSet.AttachCondition(guardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
// Test with null parameter
result = waitSet.DetachCondition(null);
Assert.AreEqual(ReturnCode.BadParameter, result);
// Test with correct parameter
result = waitSet.DetachCondition(guardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
// Test again the same condition
result = waitSet.DetachCondition(guardCondition);
Assert.AreEqual(ReturnCode.PreconditionNotMet, result);
// Detach a not attached condition
GuardCondition notAttachedCondition = new GuardCondition();
result = waitSet.DetachCondition(notAttachedCondition);
Assert.AreEqual(ReturnCode.PreconditionNotMet, result);
}
public void TestAttachCondition()
{
// Initialize
WaitSet waitSet = new WaitSet();
GuardCondition guardCondition = new GuardCondition();
// Test with null parameter
ReturnCode result = waitSet.AttachCondition(null);
Assert.AreEqual(ReturnCode.BadParameter, result);
// Test with correct parameter
result = waitSet.AttachCondition(guardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
// Attach again should return OK but not actually add another condition to the WaitSet
result = waitSet.AttachCondition(guardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
List <Condition> conditions = new List <Condition>();
result = waitSet.GetConditions(conditions);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.IsNotNull(conditions);
Assert.AreEqual(1, conditions.Count);
Assert.AreEqual(guardCondition, conditions[0]);
}
public ShapeWaitSet(ShapeTypeDataReader dataReader, Action <ShapeTypeDataReader> dataAvailableFunc)
{
_dataAvailableFunc = dataAvailableFunc;
_dataReader = dataReader;
_waitSet = new WaitSet();
_thread = new Thread(DoThreadActivity)
{
IsBackground = true
};
_cancelCondition = new GuardCondition();
_statusCondition = dataReader.StatusCondition;
_waitSet.AttachCondition(_statusCondition);
_waitSet.AttachCondition(_cancelCondition);
_statusCondition.EnabledStatuses = StatusKind.DataAvailableStatus;
_thread.Start();
}
static void Main(string[] args)
{
int domain = DDS.DomainId.Default;
/* Create a DomainParticipant */
DomainParticipantFactory dpf = DomainParticipantFactory.Instance;
IDomainParticipant participant = dpf.CreateParticipant(
domain,
null,
StatusKind.Any);
ErrorHandler.checkHandle(
participant, "DDS.DomainParticipantFactory.CreateParticipant");
/* Register the required datatype for ChatMessage. */
ChatMessageTypeSupport chatMessageTS = new ChatMessageTypeSupport();
string chatMessageTypeName = chatMessageTS.TypeName;
ReturnCode status = chatMessageTS.RegisterType(
participant, chatMessageTypeName);
ErrorHandler.checkStatus(
status, "Chat.ChatMessageTypeSupport.RegisterType");
/* Register the required datatype for NameService. */
NameServiceTypeSupport nameServiceTS = new NameServiceTypeSupport();
ErrorHandler.checkHandle(
nameServiceTS, "new NameServiceTypeSupport");
string nameServiceTypeName = nameServiceTS.TypeName;
status = nameServiceTS.RegisterType(
participant, nameServiceTypeName);
ErrorHandler.checkStatus(
status, "Chat.NameServiceTypeSupport.RegisterType");
/* Set the ReliabilityQosPolicy to RELIABLE. */
TopicQos reliableTopicQos = new TopicQos();
status = participant.GetDefaultTopicQos(ref reliableTopicQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.get_DefaultTopicQos");
reliableTopicQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
/* Make the tailored QoS the new default. */
status = participant.SetDefaultTopicQos(reliableTopicQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.SetDefaultTopicQos");
/* Use the changed policy when defining the ChatMessage topic */
ITopic chatMessageTopic = participant.CreateTopic(
"Chat_ChatMessage",
chatMessageTypeName,
reliableTopicQos);
ErrorHandler.checkHandle(
chatMessageTopic,
"DDS.DomainParticipant.CreateTopic (ChatMessage)");
/* Set the DurabilityQosPolicy to TRANSIENT. */
TopicQos settingTopicQos = new TopicQos();
status = participant.GetDefaultTopicQos(ref settingTopicQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.GetDefaultTopicQos");
settingTopicQos.Durability.Kind = DurabilityQosPolicyKind.TransientDurabilityQos;
/* Create the NameService Topic. */
ITopic nameServiceTopic = participant.CreateTopic(
"Chat_NameService",
nameServiceTypeName,
settingTopicQos);
ErrorHandler.checkHandle(
nameServiceTopic, "DDS.DomainParticipant.CreateTopic");
/* Adapt the default SubscriberQos to read from the
* "ChatRoom" Partition. */
SubscriberQos subQos = new SubscriberQos();
status = participant.GetDefaultSubscriberQos(ref subQos);
ErrorHandler.checkStatus(
status, "DDS.DomainParticipant.GetDefaultSubscriberQos");
subQos.Partition.Name = new string[1];
subQos.Partition.Name[0] = "ChatRoom";
/* Create a Subscriber for the UserLoad application. */
ISubscriber chatSubscriber = participant.CreateSubscriber(subQos);
ErrorHandler.checkHandle(
chatSubscriber, "DDS.DomainParticipant.CreateSubscriber");
/* Create a DataReader for the NameService Topic
* (using the appropriate QoS). */
DataReaderQos nsQos = null;
status = chatSubscriber.GetDefaultDataReaderQos(ref nsQos);
ErrorHandler.checkStatus(
status, "DDS.Subscriber.GetDefaultDataReaderQos");
status = chatSubscriber.CopyFromTopicQos(ref nsQos, settingTopicQos);
ErrorHandler.checkStatus(
status, "DDS.Subscriber.CopyFromTopicQos");
IDataReader parentReader = chatSubscriber.CreateDataReader(
nameServiceTopic,
nsQos,
null,
StatusKind.Any);
ErrorHandler.checkHandle(
parentReader, "DDS.Subscriber.CreateDatareader (NameService)");
NameServiceDataReader nameServer = parentReader as NameServiceDataReader;
/* Adapt the DataReaderQos for the ChatMessageDataReader to
* keep track of all messages. */
DataReaderQos messageQos = new DataReaderQos();
status = chatSubscriber.GetDefaultDataReaderQos(ref messageQos);
ErrorHandler.checkStatus(
status, "DDS.Subscriber.GetDefaultDataReaderQos");
status = chatSubscriber.CopyFromTopicQos(
ref messageQos, reliableTopicQos);
ErrorHandler.checkStatus(
status, "DDS.Subscriber.CopyFromTopicQos");
messageQos.History.Kind = HistoryQosPolicyKind.KeepAllHistoryQos;
/* Create a DataReader for the ChatMessage Topic
* (using the appropriate QoS). */
parentReader = chatSubscriber.CreateDataReader(
chatMessageTopic,
messageQos);
ErrorHandler.checkHandle(
parentReader, "DDS.Subscriber.CreateDataReader (ChatMessage)");
/* Narrow the abstract parent into its typed representative. */
ChatMessageDataReader loadAdmin = parentReader as ChatMessageDataReader;
/* Initialize the Query Arguments. */
string[] parameters = { "0" };
/* Create a QueryCondition that will contain all messages
* with userID=ownID */
IQueryCondition singleUser = loadAdmin.CreateQueryCondition("userID=%0", parameters);
ErrorHandler.checkHandle(singleUser, "DDS.DataReader.CreateQuerycondition");
/* Create a ReadCondition that will contain new users only */
IReadCondition newUser = nameServer.CreateReadCondition(SampleStateKind.NotRead, ViewStateKind.New, InstanceStateKind.Alive);
ErrorHandler.checkHandle(newUser, "DDS.DataReader.create_readcondition");
/* Obtain a StatusCondition that triggers only when a Writer
* changes Liveliness */
IStatusCondition leftUser = loadAdmin.StatusCondition;
ErrorHandler.checkHandle(leftUser, "DDS.DataReader.GetStatusCondition");
status = leftUser.SetEnabledStatuses(StatusKind.LivelinessChanged);
ErrorHandler.checkStatus(status, "DDS.StatusCondition.SetEnabledStatuses");
/* Create a bare guard which will be used to close the room */
escape = new GuardCondition();
/* Create a waitset and add the ReadConditions */
WaitSet userLoadWS = new WaitSet();
status = userLoadWS.AttachCondition(newUser);
ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (newUser)");
status = userLoadWS.AttachCondition(leftUser);
ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (leftUser)");
status = userLoadWS.AttachCondition(escape);
ErrorHandler.checkStatus(status, "DDS.WaitSet.AttachCondition (escape)");
/* Initialize and pre-allocate the GuardList used to obtain
* the triggered Conditions. */
ICondition[] guardList = new ICondition[3];
/* Remove all known Users that are not currently active. */
NameService[] nsMsgs = null;
SampleInfo[] nsInfos = null;
status = nameServer.Take(ref nsMsgs,
ref nsInfos,
Length.Unlimited,
SampleStateKind.Any,
ViewStateKind.Any,
InstanceStateKind.NotAlive);
ErrorHandler.checkStatus(
status, "Chat.NameServiceDataReader.Take");
status = nameServer.ReturnLoan(ref nsMsgs, ref nsInfos);
ErrorHandler.checkStatus(
status, "Chat.NameServiceDataReader.ReturnLoan");
/* Start the sleeper thread. */
new Thread(new UserLoad().doWait).Start();
bool closed = false;
int prevCount = 0;
ChatMessage[] msgs = null;
SampleInfo[] msgInfos = null;
while (!closed)
{
/* Wait until at least one of the Conditions in the
* waitset triggers. */
status = userLoadWS.Wait(ref guardList, Duration.Infinite);
ErrorHandler.checkStatus(status, "DDS.WaitSet.Wait");
/* Walk over all guards to display information */
foreach (ICondition guard in guardList)
{
if (guard == newUser)
{
/* The newUser ReadCondition contains data */
status = nameServer.ReadWithCondition(ref nsMsgs, ref nsInfos, newUser);
ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.read_w_condition");
foreach (NameService ns in nsMsgs)
{
Console.WriteLine("New user: "******"Chat.NameServiceDataReader.ReturnLoan");
}
else if (guard == leftUser)
{
// Some liveliness has changed (either a DataWriter
// joined or a DataWriter left)
LivelinessChangedStatus livelinessStatus = new LivelinessChangedStatus();
status = loadAdmin.GetLivelinessChangedStatus(ref livelinessStatus);
ErrorHandler.checkStatus(status, "DDS.DataReader.getLivelinessChangedStatus");
if (livelinessStatus.AliveCount < prevCount)
{
/* A user has left the ChatRoom, since a DataWriter
* lost its liveliness. Take the effected users
* so they will not appear in the list later on. */
status = nameServer.Take(
ref nsMsgs,
ref nsInfos,
Length.Unlimited,
SampleStateKind.Any,
ViewStateKind.Any,
InstanceStateKind.NotAliveNoWriters);
ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.Take");
foreach (NameService nsMsg in nsMsgs)
{
/* re-apply query arguments */
parameters[0] = nsMsg.userID.ToString();
status = singleUser.SetQueryParameters(parameters);
ErrorHandler.checkStatus(status, "DDS.QueryCondition.SetQueryParameters");
/* Read this user's history */
status = loadAdmin.TakeWithCondition(
ref msgs,
ref msgInfos,
singleUser);
ErrorHandler.checkStatus(
status,
"Chat.ChatMessageDataReader.TakeWithCondition");
/* Display the user and his history */
Console.WriteLine("Departed user {0} has sent {1} messages ", nsMsg.name, msgs.Length);
status = loadAdmin.ReturnLoan(ref msgs, ref msgInfos);
ErrorHandler.checkStatus(status, "Chat.ChatMessageDataReader.ReturnLoan");
}
status = nameServer.ReturnLoan(ref nsMsgs, ref nsInfos);
ErrorHandler.checkStatus(status, "Chat.NameServiceDataReader.ReturnLoan");
}
prevCount = livelinessStatus.AliveCount;
}
else if (guard == escape)
{
Console.WriteLine("UserLoad has terminated.");
closed = true;
}
else
{
//System.Diagnostics.Debug.Fail("Unknown Condition");
}
} /* for */
} /* while (!closed) */
/* Remove all Conditions from the WaitSet. */
status = userLoadWS.DetachCondition(escape);
ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (escape)");
status = userLoadWS.DetachCondition(leftUser);
ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (leftUser)");
status = userLoadWS.DetachCondition(newUser);
ErrorHandler.checkStatus(status, "DDS.WaitSet.DetachCondition (newUser)");
/* Free all resources */
status = participant.DeleteContainedEntities();
ErrorHandler.checkStatus(status, "DDS.DomainParticipant.DeleteContainedEntities");
status = dpf.DeleteParticipant(participant);
ErrorHandler.checkStatus(status, "DDS.DomainParticipantFactory.DeleteParticipant");
}
static void Main(string[] args)
{
DDSEntityManager mgr = new DDSEntityManager("WaitSet");
String partitionName = "WaitSet example";
// create Domain Participant
mgr.createParticipant(partitionName);
// create Type
MsgTypeSupport msgTS = new MsgTypeSupport();
mgr.registerType(msgTS);
// create Topic
mgr.createTopic("WaitSetData_Msg");
// create Subscriber
mgr.createSubscriber();
// create DataReader
mgr.createReader(false);
// Read Events
IDataReader dreader = mgr.getReader();
MsgDataReader WaitSetReader = dreader as MsgDataReader;
// Create a WaitSet
WaitSet w = new WaitSet();
// Create a ReadCondition
IReadCondition readCond = WaitSetReader.CreateReadCondition(SampleStateKind.NotRead, ViewStateKind.New, InstanceStateKind.Alive);
ErrorHandler.checkHandle(readCond, "DataReader.CreateReadCondition");
// Create a QueryCondition
String[] queryStr = { "Hello again" };
Console.WriteLine("=== [WaitSetDataSubscriber] Query : message = \"Hello again");
IQueryCondition queryCond = WaitSetReader.CreateQueryCondition("message=%0", queryStr);
ErrorHandler.checkHandle(queryCond, "DataReader.CreateQueryCondition");
// Obtain a StatusCondition
IStatusCondition statusCond;
statusCond = dreader.StatusCondition;
statusCond.SetEnabledStatuses(StatusKind.LivelinessChanged);
ErrorHandler.checkHandle(statusCond, "DataReader.StatusCondition");
GuardCondition escape;
escape = new GuardCondition();
ReturnCode result;
result = w.AttachCondition(statusCond);
ErrorHandler.checkStatus(result, "WaitSet.AttachCondition (status)");
result = w.AttachCondition(readCond);
ErrorHandler.checkStatus(result, "WaitSet.AttachCondition (read)");
result = w.AttachCondition(queryCond);
ErrorHandler.checkStatus(result, "WaitSet.AttachCondition (query)");
result = w.AttachCondition(escape);
ErrorHandler.checkStatus(result, "WaitSet.AttachCondition (guard)");
/* Initialize and pre-allocate the GuardList used to obtain
* the triggered Conditions. */
ICondition[] guardList = new ICondition[4];
DDS.SampleInfo[] infoSeq = null;
Msg[] msgSeq = null;
bool escaped = false;
bool writerLeft = false;
int prevCount = 0;
int count = 0;
Console.WriteLine("=== [WaitSetDataSubscriber] Ready ...");
while (!escaped && count < 20)
{
/**
* Wait until data will be available
*/
Duration wait_timeout = new Duration(Duration.InfiniteSec, Duration.InfiniteNanoSec);
result = w.Wait(ref guardList, wait_timeout);
ErrorHandler.checkStatus(result, "WaitSet.Wait");
/* Walk over all guards to display information */
foreach (ICondition guard in guardList)
{
if (guard == readCond)
{
result = WaitSetReader.ReadWithCondition(ref msgSeq, ref infoSeq,
Length.Unlimited, readCond);
ErrorHandler.checkStatus(result, "WaitSetReader.ReadWithCondition");
foreach (Msg msg in msgSeq)
{
Console.WriteLine(" --- New message received --- ");
Console.WriteLine(" userID: {0}", msg.userID);
Console.WriteLine(" Message : \"{0}", msg.message);
}
result = WaitSetReader.ReturnLoan(ref msgSeq, ref infoSeq);
ErrorHandler.checkStatus(result, "WaitSet.ReturnLoan");
}
else if (guard == queryCond)
{
result = WaitSetReader.TakeWithCondition(ref msgSeq, ref infoSeq,
Length.Unlimited, queryCond);
ErrorHandler.checkStatus(result, "WaitSetReader.TakeWithCondition");
foreach (Msg msg in msgSeq)
{
Console.WriteLine(" --- New message received with QueryCondition --- ");
Console.WriteLine(" userID: {0}", msg.userID);
Console.WriteLine(" Message : \" {0}", msg.message);
}
result = WaitSetReader.ReturnLoan(ref msgSeq, ref infoSeq);
ErrorHandler.checkStatus(result, "WaitSet.ReturnLoan");
}
else if (guard == statusCond)
{
LivelinessChangedStatus livelinessStatus = new LivelinessChangedStatus();
result = WaitSetReader.GetLivelinessChangedStatus(ref livelinessStatus);
ErrorHandler.checkStatus(result, "DataReader.getLivelinessChangedStatus");
if (livelinessStatus.AliveCount < prevCount)
{
Console.WriteLine("!!! A WaitSetDataWriter lost its liveliness");
writerLeft = true;
Console.WriteLine("Triggering escape condition.");
ReturnCode status = escape.SetTriggerValue(true);
}
else
{
Console.WriteLine("!!! A WaitSetDataWriter joined");
}
prevCount = livelinessStatus.AliveCount;
}
else if (guard == escape)
{
Console.WriteLine("WaitSetSubscriber has terminated.");
escaped = true;
ReturnCode status = escape.SetTriggerValue(false);
}
else
{
// Unknown Condition
}
}
++count;
}
// Detach all Conditions from the WaitSet
result = w.DetachCondition(escape);
ErrorHandler.checkStatus(result, "WaitSet.DetachCondition (escape)");
result = w.DetachCondition(readCond);
ErrorHandler.checkStatus(result, "WaitSet.DetachCondition (readCond)");
result = w.DetachCondition(queryCond);
ErrorHandler.checkStatus(result, "WaitSet.DetachCondition (queryCond)");
result = w.DetachCondition(statusCond);
ErrorHandler.checkStatus(result, "WaitSet.DetachCondition (statusCond)");
Console.WriteLine("=== [Subscriber] Closed");
// clean up
WaitSetReader.DeleteReadCondition(readCond);
WaitSetReader.DeleteReadCondition(queryCond);
mgr.getSubscriber().DeleteDataReader(WaitSetReader);
mgr.deleteSubscriber();
mgr.deleteTopic();
mgr.deleteParticipant();
}
public void TestDetachConditions()
{
// Initialize
WaitSet waitSet = new WaitSet();
GuardCondition guardCondition = new GuardCondition();
GuardCondition otherGuardCondition = new GuardCondition();
GuardCondition anotherGuardCondition = new GuardCondition();
ReturnCode result = waitSet.AttachCondition(guardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
result = waitSet.AttachCondition(otherGuardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
result = waitSet.AttachCondition(anotherGuardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
// Test with null parameter
result = waitSet.DetachConditions(null);
Assert.AreEqual(ReturnCode.Ok, result);
// Test with empty list parameter
List <Condition> conditions = new List <Condition>();
result = waitSet.DetachConditions(conditions);
Assert.AreEqual(ReturnCode.Ok, result);
// Test with single element list parameter
conditions = new List <Condition>()
{
guardCondition
};
result = waitSet.DetachConditions(conditions);
Assert.AreEqual(ReturnCode.Ok, result);
conditions = new List <Condition>()
{
null
};
result = waitSet.GetConditions(conditions);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.IsNotNull(conditions);
Assert.AreEqual(2, conditions.Count);
Assert.IsNotNull(conditions[0]);
Assert.IsNotNull(conditions[1]);
Assert.IsTrue(conditions[0] != conditions[1]);
Assert.IsTrue(anotherGuardCondition == conditions[0] || anotherGuardCondition == conditions[1]);
Assert.IsTrue(otherGuardCondition == conditions[0] || otherGuardCondition == conditions[1]);
// Detach the other conditions
conditions = new List <Condition>()
{
otherGuardCondition, anotherGuardCondition
};
result = waitSet.DetachConditions(conditions);
Assert.AreEqual(ReturnCode.Ok, result);
conditions = new List <Condition>()
{
null
};
result = waitSet.GetConditions(conditions);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.IsNotNull(conditions);
Assert.AreEqual(0, conditions.Count);
// Detach a not attached conditions
GuardCondition notAttachedCondition = new GuardCondition();
conditions = new List <Condition>()
{
notAttachedCondition
};
result = waitSet.DetachConditions(conditions);
Assert.AreEqual(ReturnCode.PreconditionNotMet, result);
}
public void TestWait()
{
// Initialize
WaitSet waitSet = new WaitSet();
GuardCondition guardCondition = new GuardCondition();
ReturnCode result = waitSet.AttachCondition(guardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
// Test with null conditions
result = waitSet.Wait(null);
Assert.AreEqual(ReturnCode.BadParameter, result);
// Attach again should return OK but not actually add another condition to the WaitSet
result = waitSet.AttachCondition(guardCondition);
Assert.AreEqual(ReturnCode.Ok, result);
List <Condition> conditions = new List <Condition>();
result = waitSet.GetConditions(conditions);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.IsNotNull(conditions);
Assert.AreEqual(1, conditions.Count);
Assert.AreEqual(guardCondition, conditions[0]);
// Test thread wait infinite
int count = 0;
Thread thread = new Thread(() =>
{
result = waitSet.Wait(conditions);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.IsNotNull(conditions);
Assert.AreEqual(1, conditions.Count);
Assert.AreEqual(guardCondition, conditions[0]);
guardCondition.TriggerValue = false;
count++;
});
thread.Start();
guardCondition.TriggerValue = true;
thread.Join();
Assert.AreEqual(1, count);
// Test timeout
count = 0;
thread = new Thread(() =>
{
result = waitSet.Wait(conditions, new Duration {
Seconds = 0, NanoSeconds = 100000000
});
Assert.AreEqual(ReturnCode.Timeout, result);
Assert.IsNotNull(conditions);
Assert.AreEqual(0, conditions.Count);
count++;
});
thread.Start();
thread.Join();
Assert.AreEqual(1, count);
// Test exit before timeout
count = 0;
thread = new Thread(() =>
{
result = waitSet.Wait(conditions, new Duration {
Seconds = 5
});
Assert.AreEqual(ReturnCode.Ok, result);
Assert.IsNotNull(conditions);
Assert.AreEqual(1, conditions.Count);
Assert.AreEqual(guardCondition, conditions[0]);
Assert.IsTrue(guardCondition.TriggerValue);
guardCondition.TriggerValue = false;
count++;
});
thread.Start();
guardCondition.TriggerValue = true;
thread.Join();
Assert.AreEqual(1, count);
}
