public void TestInitialize()
{
_participant = AssemblyInitializer.Factory.CreateParticipant(AssemblyInitializer.RTPS_DOMAIN);
Assert.IsNotNull(_participant);
_participant.BindRtpsUdpTransportConfig();
TestStructTypeSupport support = new TestStructTypeSupport();
string typeName = support.GetTypeName();
ReturnCode result = support.RegisterType(_participant, typeName);
Assert.AreEqual(ReturnCode.Ok, result);
_topic = _participant.CreateTopic(TestContext.TestName, typeName);
Assert.IsNotNull(_topic);
Assert.IsNull(_topic.GetListener());
Assert.AreEqual(TestContext.TestName, _topic.Name);
Assert.AreEqual(typeName, _topic.TypeName);
SubscriberQos sQos = new SubscriberQos();
sQos.EntityFactory.AutoenableCreatedEntities = false;
sQos.Presentation.OrderedAccess = true;
sQos.Presentation.CoherentAccess = true;
sQos.Presentation.AccessScope = PresentationQosPolicyAccessScopeKind.InstancePresentationQos;
_subscriber = _participant.CreateSubscriber(sQos);
Assert.IsNotNull(_subscriber);
PublisherQos pQos = new PublisherQos();
pQos.EntityFactory.AutoenableCreatedEntities = false;
pQos.Presentation.OrderedAccess = true;
pQos.Presentation.CoherentAccess = true;
pQos.Presentation.AccessScope = PresentationQosPolicyAccessScopeKind.InstancePresentationQos;
_publisher = _participant.CreatePublisher(pQos);
Assert.IsNotNull(_publisher);
_writer = _publisher.CreateDataWriter(_topic);
Assert.IsNotNull(_writer);
_dataWriter = new TestStructDataWriter(_writer);
_listener = new MyDataReaderListener();
DataReaderQos qos = new DataReaderQos();
qos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
_reader = _subscriber.CreateDataReader(_topic, qos, _listener);
Assert.IsNotNull(_reader);
}
public void TestNotifyDataReaders()
{
// Initialize entities
TestStructTypeSupport support = new TestStructTypeSupport();
string typeName = support.GetTypeName();
ReturnCode result = support.RegisterType(_participant, typeName);
Assert.AreEqual(ReturnCode.Ok, result);
Topic topic = _participant.CreateTopic(nameof(TestNotifyDataReaders), typeName);
Assert.IsNotNull(topic);
Assert.IsNull(topic.GetListener());
Assert.AreEqual(nameof(TestNotifyDataReaders), topic.Name);
Assert.AreEqual(typeName, topic.TypeName);
Publisher publisher = _participant.CreatePublisher();
Assert.IsNotNull(publisher);
DataWriter writer = publisher.CreateDataWriter(topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
int subscriberReceived = 0;
int readerReceived = 0;
// Create the Subscriber and the DataReader with the corresponding listeners
MySubscriberListener subListener = new MySubscriberListener();
subListener.DataOnReaders += (sub) =>
{
subscriberReceived++;
if (subscriberReceived % 2 == 0)
{
sub.NotifyDataReaders();
}
};
Subscriber subscriber = _participant.CreateSubscriber(subListener);
Assert.IsNotNull(subscriber);
MyDataReaderListener readListener = new MyDataReaderListener();
readListener.DataAvailable += (read) =>
{
readerReceived++;
};
DataReader reader = subscriber.CreateDataReader(topic, readListener);
Assert.IsNotNull(reader);
System.Threading.Thread.Sleep(100);
// Publish instances
for (int i = 0; i < 10; i++)
{
dataWriter.Write(new TestStruct
{
Id = i,
ShortType = (short)i
});
System.Threading.Thread.Sleep(100);
}
System.Threading.Thread.Sleep(100);
// Check the received instances
Assert.AreEqual(10, subscriberReceived);
Assert.AreEqual(5, readerReceived);
}
public void TestCreateDataReaderr()
{
// Initialize entities
TestStructTypeSupport support = new TestStructTypeSupport();
string typeName = support.GetTypeName();
ReturnCode result = support.RegisterType(_participant, typeName);
Assert.AreEqual(ReturnCode.Ok, result);
Topic topic = _participant.CreateTopic(nameof(TestCreateDataReaderr), typeName);
Assert.IsNotNull(topic);
Assert.IsNull(topic.GetListener());
Assert.AreEqual(nameof(TestCreateDataReaderr), topic.Name);
Assert.AreEqual(typeName, topic.TypeName);
Subscriber subscriber = _participant.CreateSubscriber();
Assert.IsNotNull(subscriber);
// Test simplest overload
DataReader datareader1 = subscriber.CreateDataReader(topic);
Assert.IsNotNull(datareader1);
Assert.AreEqual(subscriber, datareader1.Subscriber);
Assert.IsNull(datareader1.GetListener());
DataReaderQos qos = new DataReaderQos();
result = datareader1.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestDefaultDataReaderQos(qos);
// Test overload with QoS parameter
qos = TestHelper.CreateNonDefaultDataReaderQos();
DataReader datareader2 = subscriber.CreateDataReader(topic, qos);
Assert.IsNotNull(datareader2);
Assert.AreEqual(subscriber, datareader2.Subscriber);
Assert.IsNull(datareader2.GetListener());
qos = new DataReaderQos();
result = datareader2.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestNonDefaultDataReaderQos(qos);
// Test overload with listener parameter
MyDataReaderListener listener = new MyDataReaderListener();
DataReader datareader3 = subscriber.CreateDataReader(topic, listener);
Assert.IsNotNull(datareader3);
Assert.AreEqual(subscriber, datareader3.Subscriber);
MyDataReaderListener received = (MyDataReaderListener)datareader3.GetListener();
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
qos = new DataReaderQos();
result = datareader3.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestDefaultDataReaderQos(qos);
// Test overload with listener and StatusMask parameters
listener = new MyDataReaderListener();
DataReader datareader4 = subscriber.CreateDataReader(topic, listener, StatusMask.AllStatusMask);
Assert.IsNotNull(datareader4);
Assert.AreEqual(subscriber, datareader4.Subscriber);
received = (MyDataReaderListener)datareader4.GetListener();
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
qos = new DataReaderQos();
result = datareader4.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestDefaultDataReaderQos(qos);
// Test overload with QoS and listener parameters
qos = TestHelper.CreateNonDefaultDataReaderQos();
listener = new MyDataReaderListener();
DataReader datareader5 = subscriber.CreateDataReader(topic, qos, listener);
Assert.IsNotNull(datareader5);
Assert.AreEqual(subscriber, datareader5.Subscriber);
received = (MyDataReaderListener)datareader5.GetListener();
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
qos = new DataReaderQos();
result = datareader5.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestNonDefaultDataReaderQos(qos);
// Test full call overload
qos = TestHelper.CreateNonDefaultDataReaderQos();
listener = new MyDataReaderListener();
DataReader datareader6 = subscriber.CreateDataReader(topic, qos, listener, StatusMask.AllStatusMask);
Assert.IsNotNull(datareader6);
Assert.AreEqual(subscriber, datareader6.Subscriber);
received = (MyDataReaderListener)datareader6.GetListener();
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
qos = new DataReaderQos();
result = datareader6.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestNonDefaultDataReaderQos(qos);
}
public void TestOnSubscriptionLost()
{
ManualResetEventSlim evt = new ManualResetEventSlim(false);
DomainParticipant domainParticipant = AssemblyInitializer.Factory.CreateParticipant(AssemblyInitializer.INFOREPO_DOMAIN);
Assert.IsNotNull(domainParticipant);
domainParticipant.BindTcpTransportConfig();
Subscriber subscriber = domainParticipant.CreateSubscriber();
Assert.IsNotNull(subscriber);
TestStructTypeSupport support = new TestStructTypeSupport();
string typeName = support.GetTypeName();
ReturnCode result = support.RegisterType(domainParticipant, typeName);
Assert.AreEqual(ReturnCode.Ok, result);
Topic topic = domainParticipant.CreateTopic("TestOnSubscriptionLostDisconnected", typeName);
Assert.IsNotNull(topic);
MyDataReaderListener listener = new MyDataReaderListener();
DataReader reader = subscriber.CreateDataReader(topic, listener);
int count = 0;
listener.SubscriptionLost += (r, s) =>
{
Assert.AreEqual(reader, r);
Assert.AreEqual(1, s.PublicationHandles.Count());
Assert.AreNotEqual(InstanceHandle.HandleNil, s.PublicationHandles.First());
count++;
evt.Set();
};
SupportProcessHelper supportProcess = new SupportProcessHelper(TestContext);
Process process = supportProcess.SpawnSupportProcess(SupportTestKind.SubscriptionLostTest);
try
{
// Wait for discovery
bool found = reader.WaitForPublications(1, 20000);
Assert.IsTrue(found);
}
finally
{
supportProcess.KillProcess(process);
}
bool resp = evt.Wait(20000);
Assert.IsTrue(resp);
Assert.AreEqual(1, count);
// Remove the listener to avoid extra messages
result = reader.SetListener(null);
Assert.AreEqual(ReturnCode.Ok, result);
domainParticipant.DeleteContainedEntities();
AssemblyInitializer.Factory.DeleteParticipant(domainParticipant);
}
public void TestDispose()
{
// Initialize entities
Duration duration = new Duration {
Seconds = 5
};
DataWriterQos qos = new DataWriterQos();
qos.WriterDataLifecycle.AutodisposeUnregisteredInstances = false;
DataWriter writer = _publisher.CreateDataWriter(_topic, qos);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
Subscriber subscriber = _participant.CreateSubscriber();
Assert.IsNotNull(subscriber);
DataReaderQos drQos = new DataReaderQos();
qos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
MyDataReaderListener listener = new MyDataReaderListener();
DataReader dataReader = subscriber.CreateDataReader(_topic, drQos, listener);
Assert.IsNotNull(dataReader);
int count = 0;
Timestamp timestamp = default;
listener.DataAvailable += (reader) =>
{
List <TestStruct> samples = new List <TestStruct>();
List <SampleInfo> infos = new List <SampleInfo>();
TestStructDataReader dr = new TestStructDataReader(reader);
ReturnCode ret = dr.Take(samples, infos);
if (ret == ReturnCode.Ok)
{
foreach (var info in infos)
{
if (info.InstanceState == InstanceStateKind.NotAliveDisposedInstanceState)
{
count++;
if (count == 3)
{
timestamp = infos.First().SourceTimestamp;
}
}
}
}
};
// Wait for discovery
writer.WaitForSubscriptions(1, 1000);
dataReader.WaitForPublications(1, 1000);
// Dispose an instance that does not exist
ReturnCode result = dataWriter.Dispose(new TestStruct {
Id = 1
}, InstanceHandle.HandleNil);
Assert.AreEqual(ReturnCode.Error, result);
// Call dispose with the simplest overload
TestStruct instance1 = new TestStruct {
Id = 1
};
result = dataWriter.Write(instance1);
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(duration);
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(100);
Assert.AreEqual(0, count);
result = dataWriter.Dispose(instance1);
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(duration);
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(100);
Assert.AreEqual(1, count);
// Call dispose with the handle parameter
TestStruct instance2 = new TestStruct {
Id = 2
};
InstanceHandle handle2 = dataWriter.RegisterInstance(instance2);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle2);
result = dataWriter.Write(instance2, handle2);
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(duration);
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(100);
Assert.AreEqual(1, count);
result = dataWriter.Dispose(instance2, handle2);
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(duration);
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(100);
Assert.AreEqual(2, count);
// Call dispose with the handle parameter and specific timestamp
Timestamp now = DateTime.Now.ToTimestamp();
TestStruct instance3 = new TestStruct {
Id = 3
};
InstanceHandle handle3 = dataWriter.RegisterInstance(instance3);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle3);
result = dataWriter.Write(instance3, handle3);
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(duration);
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(100);
Assert.AreEqual(2, count);
result = dataWriter.Dispose(instance3, handle3, now);
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(duration);
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(100);
Assert.AreEqual(3, count);
Assert.AreEqual(now.Seconds, timestamp.Seconds);
Assert.AreEqual(now.NanoSeconds, timestamp.NanoSeconds);
}
public void TestWrite()
{
// Initialize entities
Duration duration = new Duration {
Seconds = 5
};
DataWriter writer = _publisher.CreateDataWriter(_topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
Subscriber subscriber = _participant.CreateSubscriber();
Assert.IsNotNull(subscriber);
DataReaderQos qos = new DataReaderQos();
qos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
MyDataReaderListener listener = new MyDataReaderListener();
DataReader dataReader = subscriber.CreateDataReader(_topic, qos, listener);
Assert.IsNotNull(dataReader);
int count = 0;
Timestamp timestamp = default;
ReturnCode retReadInstance = ReturnCode.Error;
InstanceHandle lookupHandle = InstanceHandle.HandleNil;
List <TestStruct> samples = new List <TestStruct>();
List <SampleInfo> infos = new List <SampleInfo>();
listener.DataAvailable += (reader) =>
{
count++;
if (count == 4)
{
TestStructDataReader dr = new TestStructDataReader(reader);
lookupHandle = dr.LookupInstance(new TestStruct {
Id = count
});
retReadInstance = dr.ReadInstance(samples, infos, lookupHandle);
if (retReadInstance == ReturnCode.Ok && infos != null && infos.Count == 1)
{
timestamp = infos.First().SourceTimestamp;
}
}
};
// Wait for discovery
writer.WaitForSubscriptions(1, 1000);
// Write an instance with the simplest overload
ReturnCode result = dataWriter.Write(new TestStruct {
Id = 1
});
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(duration);
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(10);
Assert.AreEqual(1, count);
// Write an instance with the handle parameter as HandleNil
result = dataWriter.Write(new TestStruct {
Id = 2
}, InstanceHandle.HandleNil);
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(duration);
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(10);
Assert.AreEqual(2, count);
// Write an instance with the handle parameter with a previously registered instance
TestStruct instance = new TestStruct {
Id = 3
};
InstanceHandle handle = dataWriter.RegisterInstance(instance);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle);
result = dataWriter.Write(instance, handle);
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(duration);
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(10);
Assert.AreEqual(3, count);
// Write an instance with the handle parameter and the timestamp
Timestamp now = DateTime.Now.ToTimestamp();
TestStruct instance1 = new TestStruct {
Id = 4
};
InstanceHandle handle1 = dataWriter.RegisterInstance(instance1);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle1);
result = dataWriter.Write(instance1, handle1, now);
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(duration);
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(10);
Assert.AreEqual(4, count);
Assert.AreNotEqual(InstanceHandle.HandleNil, lookupHandle);
Assert.AreEqual(ReturnCode.Ok, retReadInstance);
Assert.IsNotNull(infos);
Assert.AreEqual(1, infos.Count);
Assert.AreEqual(now.Seconds, timestamp.Seconds);
Assert.AreEqual(now.NanoSeconds, timestamp.NanoSeconds);
}
