public void TestSetListener()
{
// Create a new DataWriter without listener
DataWriter dataWriter = _publisher.CreateDataWriter(_topic);
Assert.IsNotNull(dataWriter);
MyDataWriterListener listener = (MyDataWriterListener)dataWriter.Listener;
Assert.IsNull(listener);
// Create a listener, set it and check that is correctly setted
listener = new MyDataWriterListener();
ReturnCode result = dataWriter.SetListener(listener, StatusMask.AllStatusMask);
Assert.AreEqual(ReturnCode.Ok, result);
MyDataWriterListener received = (MyDataWriterListener)dataWriter.Listener;
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
// Remove the listener calling SetListener with null and check it
result = dataWriter.SetListener(null, StatusMask.NoStatusMask);
Assert.AreEqual(ReturnCode.Ok, result);
received = (MyDataWriterListener)dataWriter.Listener;
Assert.IsNull(received);
}
public void TestGetListener()
{
// Create a new DataWriter with a listener
MyDataWriterListener listener = new MyDataWriterListener();
DataWriter dataWriter = _publisher.CreateDataWriter(_topic, listener);
Assert.IsNotNull(dataWriter);
// Call to GetListener and check the listener received
MyDataWriterListener received = (MyDataWriterListener)dataWriter.GetListener();
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
}
public void TestGetListener()
{
// Create a new DataWriter with a listener
MyDataWriterListener listener = new MyDataWriterListener();
DataWriter dataWriter = _publisher.CreateDataWriter(_topic, null, listener);
Assert.IsNotNull(dataWriter);
// Call to GetListener and check the listener received
#pragma warning disable CS0618 // Type or member is obsolete
MyDataWriterListener received = (MyDataWriterListener)dataWriter.GetListener();
#pragma warning restore CS0618 // Type or member is obsolete
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
}
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);
_listener = new MyDataWriterListener();
_writer = _publisher.CreateDataWriter(_topic, _listener);
Assert.IsNotNull(_writer);
_dataWriter = new TestStructDataWriter(_writer);
DataReaderQos qos = new DataReaderQos();
qos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
_reader = _subscriber.CreateDataReader(_topic, qos);
Assert.IsNotNull(_reader);
}
public void TestOnPublicationLost()
{
ManualResetEventSlim evt = new ManualResetEventSlim(false);
DomainParticipant domainParticipant = AssemblyInitializer.Factory.CreateParticipant(AssemblyInitializer.INFOREPO_DOMAIN);
Assert.IsNotNull(domainParticipant);
domainParticipant.BindTcpTransportConfig();
Publisher publisher = domainParticipant.CreatePublisher();
Assert.IsNotNull(publisher);
TestStructTypeSupport support = new TestStructTypeSupport();
string typeName = support.GetTypeName();
ReturnCode result = support.RegisterType(domainParticipant, typeName);
Assert.AreEqual(ReturnCode.Ok, result);
Topic topic = domainParticipant.CreateTopic("TestOnPublicationLostDisconnected", typeName);
Assert.IsNotNull(topic);
MyDataWriterListener listener = new MyDataWriterListener();
DataWriter writer = publisher.CreateDataWriter(topic, listener);
int count = 0;
listener.PublicationLost += (w, s) =>
{
Assert.AreEqual(writer, w);
Assert.AreEqual(1, s.SubscriptionHandles.Count());
Assert.AreNotEqual(InstanceHandle.HandleNil, s.SubscriptionHandles.First());
count++;
evt.Set();
};
SupportProcessHelper supportProcess = new SupportProcessHelper(TestContext);
Process process = supportProcess.SpawnSupportProcess(SupportTestKind.PublicationLostTest);
try
{
// Wait for discovery
bool found = writer.WaitForSubscriptions(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 = writer.SetListener(null);
Assert.AreEqual(ReturnCode.Ok, result);
domainParticipant.DeleteContainedEntities();
AssemblyInitializer.Factory.DeleteParticipant(domainParticipant);
evt.Dispose();
}
public void TestCreateDataWriter()
{
// 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(TestCreateDataWriter), typeName);
Assert.IsNotNull(topic);
Assert.IsNull(topic.GetListener());
Assert.AreEqual(nameof(TestCreateDataWriter), topic.Name);
Assert.AreEqual(typeName, topic.TypeName);
Publisher publisher = _participant.CreatePublisher();
Assert.IsNotNull(publisher);
// Test simplest overload
DataWriter datawriter1 = publisher.CreateDataWriter(topic);
Assert.IsNotNull(datawriter1);
Assert.AreEqual(publisher, datawriter1.Publisher);
Assert.IsNull(datawriter1.GetListener());
DataWriterQos qos = new DataWriterQos();
result = datawriter1.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestDefaultDataWriterQos(qos);
// Test overload with QoS parameter
qos = TestHelper.CreateNonDefaultDataWriterQos();
DataWriter datawriter2 = publisher.CreateDataWriter(topic, qos);
Assert.IsNotNull(datawriter2);
Assert.AreEqual(publisher, datawriter2.Publisher);
Assert.IsNull(datawriter2.GetListener());
qos = new DataWriterQos();
result = datawriter2.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestNonDefaultDataWriterQos(qos);
// Test overload with listener parameter
MyDataWriterListener listener = new MyDataWriterListener();
DataWriter datawriter3 = publisher.CreateDataWriter(topic, listener);
Assert.IsNotNull(datawriter3);
Assert.AreEqual(publisher, datawriter3.Publisher);
MyDataWriterListener received = (MyDataWriterListener)datawriter3.GetListener();
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
qos = new DataWriterQos();
result = datawriter3.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestDefaultDataWriterQos(qos);
// Test overload with listener and StatusMask parameters
listener = new MyDataWriterListener();
DataWriter datawriter4 = publisher.CreateDataWriter(topic, listener, StatusMask.AllStatusMask);
Assert.IsNotNull(datawriter4);
Assert.AreEqual(publisher, datawriter4.Publisher);
received = (MyDataWriterListener)datawriter4.GetListener();
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
qos = new DataWriterQos();
result = datawriter4.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestDefaultDataWriterQos(qos);
// Test overload with QoS and listener parameters
qos = TestHelper.CreateNonDefaultDataWriterQos();
listener = new MyDataWriterListener();
DataWriter datawriter5 = publisher.CreateDataWriter(topic, qos, listener);
Assert.IsNotNull(datawriter5);
Assert.AreEqual(publisher, datawriter5.Publisher);
received = (MyDataWriterListener)datawriter5.GetListener();
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
qos = new DataWriterQos();
result = datawriter5.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestNonDefaultDataWriterQos(qos);
// Test full call overload
qos = TestHelper.CreateNonDefaultDataWriterQos();
listener = new MyDataWriterListener();
DataWriter datawriter6 = publisher.CreateDataWriter(topic, qos, listener, StatusMask.AllStatusMask);
Assert.IsNotNull(datawriter6);
Assert.AreEqual(publisher, datawriter6.Publisher);
received = (MyDataWriterListener)datawriter6.GetListener();
Assert.IsNotNull(received);
Assert.AreEqual(listener, received);
qos = new DataWriterQos();
result = datawriter6.GetQos(qos);
Assert.AreEqual(ReturnCode.Ok, result);
TestHelper.TestNonDefaultDataWriterQos(qos);
// Test with null parameter
DataWriter nullDataWriter = publisher.CreateDataWriter(null);
Assert.IsNull(nullDataWriter);
// Test with wrong qos
DataWriterQos dwQos = new DataWriterQos();
dwQos.ResourceLimits.MaxSamples = 1;
dwQos.ResourceLimits.MaxSamplesPerInstance = 2;
nullDataWriter = publisher.CreateDataWriter(topic, dwQos);
Assert.IsNull(nullDataWriter);
}
