public void TestGetKeyValue()
{
// Initialize entities
DataWriter writer = _publisher.CreateDataWriter(_topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
// Call GetKeyValue with HandleNil
TestStruct data = new TestStruct();
ReturnCode result = dataWriter.GetKeyValue(data, InstanceHandle.HandleNil);
Assert.AreEqual(ReturnCode.BadParameter, result);
// Register an instance
TestStruct instance = new TestStruct {
Id = 1
};
InstanceHandle handle = dataWriter.RegisterInstance(instance);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle);
// Call GetKeyValue
data = new TestStruct();
result = dataWriter.GetKeyValue(data, handle);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.AreEqual(1, data.Id);
}
public void TestWaitForAcknowledgments()
{
// Initialize entities
DataWriter writer = _publisher.CreateDataWriter(_topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
Subscriber subscriber = _participant.CreateSubscriber();
Assert.IsNotNull(subscriber);
DataReaderQos drQos = new DataReaderQos();
drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
DataReader reader = subscriber.CreateDataReader(_topic);
Assert.IsNotNull(reader);
// Write some instances and wait for acknowledgments
for (int i = 0; i < 10; i++)
{
ReturnCode result = dataWriter.Write(new TestStruct
{
Id = i,
});
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.WaitForAcknowledgments(new Duration {
Seconds = 5
});
Assert.AreEqual(ReturnCode.Ok, result);
}
}
public void TestLookupInstance()
{
// Initialize entities
DataWriter writer = _publisher.CreateDataWriter(_topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
// Lookup for a non-existing instance
InstanceHandle handle = dataWriter.LookupInstance(new TestStruct {
Id = 1
});
Assert.AreEqual(InstanceHandle.HandleNil, handle);
// Register an instance
InstanceHandle handle1 = dataWriter.RegisterInstance(new TestStruct {
Id = 1
});
Assert.AreNotEqual(InstanceHandle.HandleNil, handle1);
// Lookup for an existing instance
handle = dataWriter.LookupInstance(new TestStruct {
Id = 1
});
Assert.AreNotEqual(InstanceHandle.HandleNil, handle);
Assert.AreEqual(handle1, handle);
}
public void TestGetLivelinessLostStatus()
{
// Initialize entities
DataWriterQos dwQos = new DataWriterQos();
dwQos.Liveliness.Kind = LivelinessQosPolicyKind.ManualByTopicLivelinessQos;
dwQos.Liveliness.LeaseDuration = new Duration
{
Seconds = 1,
};
DataWriter writer = _publisher.CreateDataWriter(_topic, dwQos);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
Assert.IsNotNull(dataWriter);
// After half second liveliness should not be lost yet
System.Threading.Thread.Sleep(500);
LivelinessLostStatus status = default;
ReturnCode result = writer.GetLivelinessLostStatus(ref status);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.AreEqual(0, status.TotalCount);
Assert.AreEqual(0, status.TotalCountChange);
// After one second and a half one liveliness should be lost
System.Threading.Thread.Sleep(1000);
result = writer.GetLivelinessLostStatus(ref status);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.AreEqual(1, status.TotalCount);
Assert.AreEqual(1, status.TotalCountChange);
}
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.Listener);
Assert.AreEqual(TestContext.TestName, _topic.Name);
Assert.AreEqual(typeName, _topic.TypeName);
_subscriber = _participant.CreateSubscriber();
Assert.IsNotNull(_subscriber);
_publisher = _participant.CreatePublisher();
Assert.IsNotNull(_publisher);
_writer = _publisher.CreateDataWriter(_topic);
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 TestUnregisterInstance()
{
// Initialize entities
DataWriter writer = _publisher.CreateDataWriter(_topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
// Unregister not registered instance
ReturnCode result = dataWriter.UnregisterInstance(new TestStruct {
Id = 1
});
Assert.AreEqual(ReturnCode.PreconditionNotMet, result);
// Register an instance
TestStruct instance1 = new TestStruct {
Id = 1
};
InstanceHandle handle1 = dataWriter.RegisterInstance(instance1);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle1);
// Unregister the previous registered instance with the simplest overload
result = dataWriter.UnregisterInstance(new TestStruct {
Id = 1
});
Assert.AreEqual(ReturnCode.Ok, result);
// Register a new instance
TestStruct instance2 = new TestStruct {
Id = 2
};
InstanceHandle handle2 = dataWriter.RegisterInstance(instance2);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle2);
// Unregister the previous registered instance with the handle
result = dataWriter.UnregisterInstance(new TestStruct {
Id = 2
}, handle2);
Assert.AreEqual(ReturnCode.Ok, result);
// Register a new instance
TestStruct instance3 = new TestStruct {
Id = 3
};
InstanceHandle handle3 = dataWriter.RegisterInstance(instance3);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle3);
// Unregister the previous registered instance with the handle and the timestamp
result = dataWriter.UnregisterInstance(new TestStruct {
Id = 3
}, handle3, DateTime.Now.ToTimestamp());
Assert.AreEqual(ReturnCode.Ok, result);
}
public void TestGetOfferedDeadlineMissedStatus()
{
// Initialize entities
DataWriterQos qos = new DataWriterQos();
qos.Deadline.Period = new Duration
{
Seconds = 1,
};
DataWriter writer = _publisher.CreateDataWriter(_topic, qos);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
Subscriber subscriber = _participant.CreateSubscriber();
Assert.IsNotNull(subscriber);
DataReader reader = subscriber.CreateDataReader(_topic);
Assert.IsNotNull(reader);
// Wait for discovery and write an instance
bool found = writer.WaitForSubscriptions(1, 1000);
Assert.IsTrue(found);
dataWriter.Write(new TestStruct
{
Id = 1,
});
// After half second deadline should not be lost yet
System.Threading.Thread.Sleep(500);
OfferedDeadlineMissedStatus status = default;
ReturnCode result = writer.GetOfferedDeadlineMissedStatus(ref status);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.AreEqual(0, status.TotalCount);
Assert.AreEqual(0, status.TotalCountChange);
Assert.AreEqual(InstanceHandle.HandleNil, status.LastInstanceHandle);
// After one second and a half one deadline should be lost
System.Threading.Thread.Sleep(1000);
result = writer.GetOfferedDeadlineMissedStatus(ref status);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.AreEqual(1, status.TotalCount);
Assert.AreEqual(1, status.TotalCountChange);
Assert.AreNotEqual(InstanceHandle.HandleNil, status.LastInstanceHandle);
}
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 TestCleanup()
{
if (_participant != null)
{
ReturnCode result = _participant.DeleteContainedEntities();
Assert.AreEqual(ReturnCode.Ok, result);
}
if (AssemblyInitializer.Factory != null)
{
ReturnCode result = AssemblyInitializer.Factory.DeleteParticipant(_participant);
Assert.AreEqual(ReturnCode.Ok, result);
}
_participant = null;
_publisher = null;
_subscriber = null;
_topic = null;
_writer = null;
_dataWriter = null;
_reader = null;
}
public void TestRegisterInstance()
{
// Initialize entities
DataWriter writer = _publisher.CreateDataWriter(_topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
// Register an instance
InstanceHandle handle = dataWriter.RegisterInstance(new TestStruct {
Id = 1
});
Assert.AreNotEqual(InstanceHandle.HandleNil, handle);
// Register an instance with timestamp
InstanceHandle otherHandle = dataWriter.RegisterInstance(new TestStruct {
Id = 2
}, DateTime.Now.ToTimestamp());
Assert.AreNotEqual(InstanceHandle.HandleNil, otherHandle);
Assert.AreNotEqual(handle, otherHandle);
}
public void TestBeginEndAccess()
{
// OpenDDS Issue: Coherent sets for PRESENTATION QoS not Currently implemented on RTPS.
// Just prepare the unit test for the moment.
// 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);
Topic otherTopic = _participant.CreateTopic("Other" + nameof(TestNotifyDataReaders), typeName);
Assert.IsNotNull(otherTopic);
Assert.IsNull(otherTopic.GetListener());
Assert.AreEqual("Other" + nameof(TestNotifyDataReaders), otherTopic.Name);
Assert.AreEqual(typeName, otherTopic.TypeName);
PublisherQos pubQos = new PublisherQos();
pubQos.Presentation.AccessScope = PresentationQosPolicyAccessScopeKind.GroupPresentationQos;
pubQos.Presentation.CoherentAccess = true;
pubQos.Presentation.OrderedAccess = true;
Publisher publisher = _participant.CreatePublisher(pubQos);
Assert.IsNotNull(publisher);
DataWriter writer = publisher.CreateDataWriter(topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
DataWriter otherWriter = publisher.CreateDataWriter(otherTopic);
Assert.IsNotNull(otherWriter);
TestStructDataWriter otherDataWriter = new TestStructDataWriter(otherWriter);
SubscriberQos subQos = new SubscriberQos();
subQos.Presentation.AccessScope = PresentationQosPolicyAccessScopeKind.GroupPresentationQos;
subQos.Presentation.CoherentAccess = true;
subQos.Presentation.OrderedAccess = true;
MySubscriberListener listener = new MySubscriberListener();
listener.DataOnReaders += (sub) =>
{
result = sub.BeginAccess();
Assert.AreEqual(ReturnCode.Ok, result);
List <DataReader> list = new List <DataReader>();
result = sub.GetDataReaders(list);
// Here we should check that we received two DataReader
// read the data of each one and confirm tha the group coherent access
// is working as expected.
result = sub.EndAccess();
Assert.AreEqual(ReturnCode.Ok, result);
};
Subscriber subscriber = _participant.CreateSubscriber(subQos, listener);
Assert.IsNotNull(subscriber);
DataReader reader = subscriber.CreateDataReader(topic);
Assert.IsNotNull(reader);
TestStructDataReader dataReader = new TestStructDataReader(reader);
DataReader otherReader = subscriber.CreateDataReader(otherTopic);
Assert.IsNotNull(otherReader);
TestStructDataReader otherDataReader = new TestStructDataReader(otherReader);
// Call EndAccess without calling first BeginAccess
result = subscriber.EndAccess();
Assert.AreEqual(ReturnCode.PreconditionNotMet, result);
// Publish a samples in both topics
result = publisher.BeginCoherentChanges();
Assert.AreEqual(ReturnCode.Ok, result);
result = dataWriter.Write(new TestStruct
{
Id = 1
});
Assert.AreEqual(ReturnCode.Ok, result);
result = otherDataWriter.Write(new TestStruct
{
Id = 1
});
Assert.AreEqual(ReturnCode.Ok, result);
result = publisher.EndCoherentChanges();
Assert.AreEqual(ReturnCode.Ok, result);
// Give some time to the subscriber to process the messages
System.Threading.Thread.Sleep(500);
}
public void TestGetDataReaders()
{
// 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);
Topic otherTopic = _participant.CreateTopic("Other" + nameof(TestNotifyDataReaders), typeName);
Assert.IsNotNull(otherTopic);
Assert.IsNull(otherTopic.GetListener());
Assert.AreEqual("Other" + nameof(TestNotifyDataReaders), otherTopic.Name);
Assert.AreEqual(typeName, otherTopic.TypeName);
Publisher publisher = _participant.CreatePublisher();
Assert.IsNotNull(publisher);
DataWriter writer = publisher.CreateDataWriter(topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
DataWriter otherWriter = publisher.CreateDataWriter(otherTopic);
Assert.IsNotNull(otherWriter);
TestStructDataWriter otherDataWriter = new TestStructDataWriter(otherWriter);
Subscriber subscriber = _participant.CreateSubscriber();
Assert.IsNotNull(subscriber);
DataReader reader = subscriber.CreateDataReader(topic);
Assert.IsNotNull(reader);
TestStructDataReader dataReader = new TestStructDataReader(reader);
DataReader otherReader = subscriber.CreateDataReader(otherTopic);
Assert.IsNotNull(otherReader);
TestStructDataReader otherDataReader = new TestStructDataReader(otherReader);
// Check that the GetDataReaders without sending any sample
List <DataReader> list = new List <DataReader>();
result = subscriber.GetDataReaders(list);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.AreEqual(0, list.Count);
// Publish in the topic and check again
result = dataWriter.Write(new TestStruct
{
Id = 1
});
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(100);
result = subscriber.GetDataReaders(list);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.AreEqual(1, list.Count);
// Publish in the otherTopic and check again
result = otherDataWriter.Write(new TestStruct
{
Id = 1
});
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(100);
result = subscriber.GetDataReaders(list, SampleStateKind.NotReadSampleState | SampleStateKind.ReadSampleState, ViewStateMask.AnyViewState, InstanceStateMask.AnyInstanceState);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.AreEqual(2, list.Count);
// Take from both DataReaders and check again
List <TestStruct> received = new List <TestStruct>();
List <SampleInfo> sampleInfos = new List <SampleInfo>();
result = dataReader.Take(received, sampleInfos);
Assert.AreEqual(ReturnCode.Ok, result);
result = otherDataReader.Take(received, sampleInfos);
Assert.AreEqual(ReturnCode.Ok, result);
result = subscriber.GetDataReaders(list);
Assert.AreEqual(ReturnCode.Ok, result);
Assert.AreEqual(0, list.Count);
// Test GetDataReaders with null parameter
result = subscriber.GetDataReaders(null);
Assert.AreEqual(ReturnCode.BadParameter, result);
}
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);
}
static void Main(string[] args)
{
bool useListener = true;
OpenDDSharp.Ace.Init();
ParticipantService participantService = ParticipantService.Instance;
DomainParticipantFactory domainFactory = participantService.GetDomainParticipantFactory(args);
DomainParticipantQos qos = new DomainParticipantQos();
qos.EntityFactory.AutoenableCreatedEntities = false;
qos.UserData.Value = Encoding.UTF8.GetBytes("sometext");
DomainParticipant participant = domainFactory.CreateParticipant(42, qos);
if (participant == null)
{
throw new Exception("Could not create the participant");
}
DomainParticipantQos aux = new DomainParticipantQos();
ReturnCode ret = participant.GetQos(aux);
aux.EntityFactory.AutoenableCreatedEntities = true;
ret = participant.SetQos(aux);
if (participant != null)
{
TestStructTypeSupport support = new TestStructTypeSupport();
string typeName = support.GetTypeName();
ReturnCode result = support.RegisterType(participant, typeName);
if (result != ReturnCode.Ok)
{
throw new Exception("Could not register the type");
}
Topic topic = participant.CreateTopic("TopicName", typeName);
Publisher publisher = participant.CreatePublisher();
if (publisher == null)
{
throw new Exception("Could not create the publisher");
}
DataWriter dw = publisher.CreateDataWriter(topic);
if (dw == null)
{
throw new Exception("Could not create the datawriter");
}
TestStructDataWriter dataWriter = new TestStructDataWriter(dw);
Subscriber subscriber = participant.CreateSubscriber();
if (subscriber == null)
{
throw new Exception("Could not create the subscribre");
}
MyDataListener listener = null;
if (useListener)
{
listener = new MyDataListener();
}
DataReader dataReader = subscriber.CreateDataReader(topic, listener, StatusKind.DataAvailableStatus);
if (dataReader == null)
{
throw new Exception("Could not create the datareader");
}
WaitSet waitSet = null;
StatusCondition statusCondition = null;
if (!useListener)
{
waitSet = new WaitSet();
statusCondition = dataReader.StatusCondition;
waitSet.AttachCondition(statusCondition);
statusCondition.EnabledStatuses = StatusKind.DataAvailableStatus;
new System.Threading.Thread(delegate()
{
ICollection <Condition> conditions = new List <Condition>();
Duration duration = new Duration
{
Seconds = Duration.InfiniteSeconds
};
waitSet.Wait(conditions, duration);
foreach (Condition cond in conditions)
{
if (cond == statusCondition && cond.TriggerValue)
{
StatusCondition sCond = (StatusCondition)cond;
StatusMask mask = sCond.EnabledStatuses;
if ((mask & StatusKind.DataAvailableStatus) != 0)
{
DataAvailable(dataReader);
}
}
}
}).Start();
}
TestStruct test = new TestStruct
{
RawData = "Hello, I love you, won't you tell me your name?"
};
test.LongSequence.Add(20);
test.LongSequence.Add(10);
test.LongSequence.Add(0);
test.StringSequence.Add("Hello,");
test.StringSequence.Add("I love you");
test.StringSequence.Add("won't you tell me your name?");
test.LongDoubleType = 1.1;
test.LongDoubleSequence.Add(1.1);
test.LongDoubleSequence.Add(2.2);
test.LongDoubleSequence.Add(3.3);
test.LongArray[0, 0] = 1;
test.LongArray[0, 1] = 2;
test.LongArray[0, 2] = 3;
test.LongArray[0, 3] = 4;
test.LongArray[1, 0] = 1;
test.LongArray[1, 1] = 2;
test.LongArray[1, 2] = 3;
test.LongArray[1, 3] = 4;
test.LongArray[2, 0] = 1;
test.LongArray[2, 1] = 2;
test.LongArray[2, 2] = 3;
test.LongArray[2, 3] = 4;
test.StringArray[0, 0] = "Hello,";
test.StringArray[0, 1] = "I love you,";
test.StringArray[1, 0] = "won't you tell me";
test.StringArray[1, 1] = "your name?";
test.StructArray[0, 0] = new BasicTestStruct()
{
Id = 0
};
test.StructArray[0, 1] = new BasicTestStruct()
{
Id = 1
};
test.StructArray[1, 0] = new BasicTestStruct()
{
Id = 2
};
test.StructArray[1, 1] = new BasicTestStruct()
{
Id = 3
};
test.LongDoubleArray[0, 0] = 1.1;
test.LongDoubleArray[0, 1] = 2.2;
test.LongDoubleArray[1, 0] = 3.3;
test.LongDoubleArray[1, 1] = 4.4;
test.StructSequence.Add(new BasicTestStruct()
{
Id = 1
});
test.StructSequence.Add(new BasicTestStruct()
{
Id = 2
});
test.StructSequence.Add(new BasicTestStruct()
{
Id = 3
});
result = dataWriter.Write(test);
System.Threading.Thread.Sleep(1000);
if (!useListener)
{
waitSet.DetachCondition(statusCondition);
}
participant.DeleteContainedEntities();
domainFactory.DeleteParticipant(participant);
}
participantService.Shutdown();
OpenDDSharp.Ace.Fini();
Console.WriteLine("Press ENTER to finish the test.");
Console.ReadLine();
}
private static void TestPublisher(DomainParticipant participant)
{
Console.WriteLine("Starting applicattion as Publisher...");
Publisher publisher = participant.CreatePublisher();
if (publisher == null)
{
throw new ApplicationException("Publisher could not be created.");
}
Topic topic = CreateTestTopic(participant);
DataWriterQos qos = new DataWriterQos();
qos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
DataWriter dw = publisher.CreateDataWriter(topic, qos);
if (dw == null)
{
throw new ApplicationException("DataWriter could not be created.");
}
TestStructDataWriter dataWriter = new TestStructDataWriter(dw);
Console.WriteLine("Waiting for the subscriber...");
bool wait = WaitForSubscriptions(dw, 1, 60000);
if (wait)
{
Console.WriteLine("Subscription found. Sending test data with default values...");
TestStruct data = new TestStruct();
dataWriter.Write(data);
ReturnCode ret = dataWriter.WaitForAcknowledgments(new Duration
{
Seconds = 60,
NanoSeconds = 0,
});
if (ret == ReturnCode.Ok)
{
Console.WriteLine("Data sent and acknowledged.");
}
else
{
Console.WriteLine("No acknowledge received: " + ret.ToString());
return;
}
Console.WriteLine("Subscription found. Sending test data with custom values...");
data = new TestStruct
{
ShortField = -1,
LongField = -2,
LongLongField = -3,
UnsignedShortField = 1,
UnsignedLongField = 2,
UnsignedLongLongField = 3,
BooleanField = true,
CharField = 'C',
WCharField = 'W',
FloatField = 42.42f,
DoubleField = 0.42,
//LongDoubleField = 0.4242m,
OctetField = 0x42,
UnboundedStringField = "Unbounded string field.",
UnboundedWStringField = "Unbounded WString field.",
BoundedStringField = "Bounded string field.",
BoundedWStringField = "Bounded WString field.",
BoundedBooleanSequenceField = { true, true, false },
UnboundedBooleanSequenceField = { true, true, false, true, true, false },
BoundedCharSequenceField = { '1', '2', '3', '4', '5' },
UnboundedCharSequenceField = { '1', '2', '3', '4', '5', '6' },
BoundedWCharSequenceField = { '1', '2', '3', '4', '5' },
UnboundedWCharSequenceField = { '1', '2', '3', '4', '5', '6' },
BoundedOctetSequenceField = { 0x42, 0x69 },
UnboundedOctetSequenceField = { 0x42, 0x69, 0x42, 0x69, 0x42, 0x69 },
BoundedShortSequenceField = { 1, 2, 3, 4, 5 },
UnboundedShortSequenceField = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5 },
BoundedUShortSequenceField = { 1, 2, 3, 4, 5 },
UnboundedUShortSequenceField = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5 },
BoundedLongSequenceField = { 1, 2, 3, 4, 5 },
UnboundedLongSequenceField = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5 },
BoundedULongSequenceField = { 1, 2, 3, 4, 5 },
UnboundedULongSequenceField = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5 },
BoundedLongLongSequenceField = { 1, 2, 3, 4, 5 },
UnboundedLongLongSequenceField = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5 },
BoundedULongLongSequenceField = { 1, 2, 3, 4, 5 },
UnboundedULongLongSequenceField = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5 },
BoundedFloatSequenceField = { 0.42f, 42.42f, 1f, 2f, 3f },
UnboundedFloatSequenceField = { 0.42f, 42.42f, 1f, 2f, 3f, 0.42f, 42.42f, 1f, 2f, 3f },
BoundedDoubleSequenceField = { 0.42, 42.42, 1, 2, 3 },
UnboundedDoubleSequenceField = { 0.42, 42.42, 1, 2, 3, 0.42, 42.42, 1, 2, 3 },
BoundedStringSequenceField = { "This", "is", "the", "end." },
BoundedWStringSequenceField = { "This", "is", "the", "end." },
UnboundedStringSequenceField = { "This", "is", "the", "end.", "This", "is", "the", "end." },
UnboundedWStringSequenceField = { "This", "is", "the", "end.", "This", "is", "the", "end." },
NestedStructField = { Id = 1, Message = "This is the end." },
BoundedStructSequenceField = { new NestedStruct {
Id = 1, Message = "This is the end."
}, new NestedStruct {
Id = 2, Message = "my only friend, the end."
} },
UnboundedStructSequenceField = { new NestedStruct {
Id = 1, Message = "This is the end."
}, new NestedStruct{
Id = 2, Message = "my only friend, the end."
} },
TestEnumField = TestEnum.ENUM12,
BoundedEnumSequenceField = { TestEnum.ENUM1, TestEnum.ENUM2, TestEnum.ENUM3, TestEnum.ENUM4, TestEnum.ENUM5 },
UnboundedEnumSequenceField = { TestEnum.ENUM1, TestEnum.ENUM2, TestEnum.ENUM3, TestEnum.ENUM4, TestEnum.ENUM5, TestEnum.ENUM6, TestEnum.ENUM7, TestEnum.ENUM8, TestEnum.ENUM9, TestEnum.ENUM10, TestEnum.ENUM11, TestEnum.ENUM12 },
ShortArrayField = new short[] { 1, -2, 3, -4, 5 },
UnsignedShortArrayField = new ushort[] { 1, 2, 3, 4, 5 },
LongArrayField = new int[] { 1, -2, 3, -4, 5 },
UnsignedLongArrayField = new uint[] { 1, 2, 3, 4, 5 },
LongLongArrayField = new long[] { 1, -2, 3, -4, 5 },
UnsignedLongLongArrayField = new ulong[] { 1, 2, 3, 4, 5 },
CharArrayField = new char[] { 'A', 'B', 'C', 'D', 'E' },
WCharArrayField = new char[] { 'A', 'B', 'C', 'D', 'E' },
BooleanArrayField = new bool[] { true, true, false, true, true },
OctetArrayField = new byte[] { 0x42, 0x42, 0x69, 0x42, 0x42 },
FloatArrayField = new float[] { 0.42f, 0.4242f, 1f, 2f, 3f },
DoubleArrayField = new double[] { 0.42, 0.4242, 1, 2, 3 },
StringArrayField = new string[] { "This", "is", "the", "end", "my only friend, the end." },
WStringArrayField = new string[] { "This", "is", "the", "end", "my only friend, the end." },
EnumArrayField = new TestEnum[] { TestEnum.ENUM1, TestEnum.ENUM2, TestEnum.ENUM3, TestEnum.ENUM4, TestEnum.ENUM5 },
StructArrayField = new NestedStruct[]
{
new NestedStruct {
Id = 1, Message = "This is the end."
},
new NestedStruct {
Id = 2, Message = "This is the end."
},
new NestedStruct {
Id = 3, Message = "This is the end."
},
new NestedStruct {
Id = 4, Message = "This is the end."
},
new NestedStruct {
Id = 5, Message = "This is the end."
},
},
ShortMultiArrayField = new short[, , ]
{
{
{ -01, -02 },
{ -03, -04 },
{ -05, -06 },
{ -07, -08 },
},
{
{ -09, -10 },
{ -11, -12 },
{ -13, -14 },
{ -15, -16 },
},
{
{ -17, -18 },
{ -19, -20 },
{ -21, -22 },
{ -23, -24 },
}
},
UnsignedShortMultiArrayField = new ushort[, , ]
{
{
{ 01, 02 },
{ 03, 04 },
{ 05, 06 },
{ 07, 08 },
},
{
{ 09, 10 },
{ 11, 12 },
{ 13, 14 },
{ 15, 16 },
},
{
{ 17, 18 },
{ 19, 20 },
{ 21, 22 },
{ 23, 24 },
}
},
LongMultiArrayField = new[, , ]
{
{
{ -01, 02 },
{ -03, 04 },
{ -05, 06 },
{ -07, 08 },
},
{
{ -09, 10 },
{ -11, 12 },
{ -13, 14 },
{ -15, 16 },
},
{
{ -17, 18 },
{ -19, 20 },
{ -21, 22 },
{ -23, 24 },
}
},
UnsignedLongMultiArrayField = new[, , ]
{
{
{ 25U, 26U },
{ 27U, 28U },
{ 29U, 30U },
{ 31U, 32U },
},
{
{ 33U, 34U },
{ 35U, 36U },
{ 37U, 38U },
{ 39U, 40U },
},
{
{ 41U, 42U },
{ 43U, 44U },
{ 45U, 46U },
{ 47U, 48U },
}
},
LongLongMultiArrayField = new[, , ]
{
{
{ -25L, -26L },
{ -27L, -28L },
{ -29L, -30L },
{ -31L, -32L },
},
{
{ -33L, -34L },
{ -35L, -36L },
{ -37L, -38L },
{ -39L, -40L },
},
{
{ -41L, -42L },
{ -43L, -44L },
{ -45L, -46L },
{ -47L, -48L },
}
},
UnsignedLongLongMultiArrayField = new[, , ]
{
{
{ 49UL, 50UL },
{ 51UL, 52UL },
{ 53UL, 54UL },
{ 55UL, 56UL },
},
{
{ 57UL, 58UL },
{ 59UL, 60UL },
{ 61UL, 62UL },
{ 63UL, 64UL },
},
{
{ 65UL, 66UL },
{ 67UL, 68UL },
{ 69UL, 70UL },
{ 71UL, 72UL },
}
},
FloatMultiArrayField = new[, , ]
{
{
{ 01.01f, 02.02f },
{ 03.03f, 04.04f },
{ 05.05f, 06.06f },
{ 07.07f, 08.08f }
},
{
{ 09.09f, 10.10f },
{ 11.11f, 12.12f },
{ 13.13f, 14.14f },
{ 15.15f, 16.16f },
},
{
{ 17.17f, 18.18f },
{ 19.19f, 20.20f },
{ 21.21f, 22.22f },
{ 23.23f, 24.24f },
}
},
DoubleMultiArrayField = new[, , ]
{
{
{ 01.01, 02.02 },
{ 03.03, 04.04 },
{ 05.05, 06.06 },
{ 07.07, 08.08 },
},
{
{ 09.09, 10.10 },
{ 11.11, 12.12 },
{ 13.13, 14.14 },
{ 15.15, 16.16 },
},
{
{ 17.17, 18.18 },
{ 19.19, 20.20 },
{ 21.21, 22.22 },
{ 23.23, 24.24 },
}
},
BooleanMultiArrayField = new[, , ]
{
{
{ true, false },
{ true, false },
{ true, false },
{ true, false },
},
{
{ true, false },
{ true, false },
{ true, false },
{ true, false },
},
{
{ true, false },
{ true, false },
{ true, false },
{ true, false },
}
},
OctetMultiArrayField = new byte[, , ]
{
{
{ 01, 02 },
{ 03, 04 },
{ 05, 06 },
{ 07, 08 },
},
{
{ 09, 10 },
{ 11, 12 },
{ 13, 14 },
{ 15, 16 },
},
{
{ 17, 18 },
{ 19, 20 },
{ 21, 22 },
{ 23, 24 },
}
},
EnumMultiArrayField = new TestEnum[, , ]
{
{
{ TestEnum.ENUM1, TestEnum.ENUM2 },
{ TestEnum.ENUM3, TestEnum.ENUM4 },
{ TestEnum.ENUM5, TestEnum.ENUM6 },
{ TestEnum.ENUM7, TestEnum.ENUM8 },
},
{
{ TestEnum.ENUM9, TestEnum.ENUM10 },
{ TestEnum.ENUM11, TestEnum.ENUM12 },
{ TestEnum.ENUM1, TestEnum.ENUM2 },
{ TestEnum.ENUM3, TestEnum.ENUM4 },
},
{
{ TestEnum.ENUM5, TestEnum.ENUM6 },
{ TestEnum.ENUM7, TestEnum.ENUM8 },
{ TestEnum.ENUM9, TestEnum.ENUM10 },
{ TestEnum.ENUM11, TestEnum.ENUM12 },
},
},
StructMultiArrayField = new NestedStruct[, , ]
{
{
{ new NestedStruct {
Id = 1, Message = "01"
}, new NestedStruct {
Id = 2, Message = "02"
} },
{ new NestedStruct {
Id = 3, Message = "03"
}, new NestedStruct {
Id = 4, Message = "04"
} },
{ new NestedStruct {
Id = 5, Message = "05"
}, new NestedStruct {
Id = 6, Message = "06"
} },
{ new NestedStruct {
Id = 7, Message = "07"
}, new NestedStruct {
Id = 8, Message = "08"
} },
},
{
{ new NestedStruct {
Id = 9, Message = "09"
}, new NestedStruct {
Id = 10, Message = "10"
} },
{ new NestedStruct {
Id = 11, Message = "11"
}, new NestedStruct {
Id = 12, Message = "12"
} },
{ new NestedStruct {
Id = 13, Message = "13"
}, new NestedStruct {
Id = 14, Message = "14"
} },
{ new NestedStruct {
Id = 15, Message = "15"
}, new NestedStruct {
Id = 16, Message = "16"
} },
},
{
{ new NestedStruct {
Id = 17, Message = "17"
}, new NestedStruct {
Id = 18, Message = "18"
} },
{ new NestedStruct {
Id = 19, Message = "19"
}, new NestedStruct {
Id = 20, Message = "20"
} },
{ new NestedStruct {
Id = 21, Message = "21"
}, new NestedStruct {
Id = 22, Message = "22"
} },
{ new NestedStruct {
Id = 23, Message = "23"
}, new NestedStruct {
Id = 24, Message = "24"
} },
},
},
StringMultiArrayField = new[, , ]
{
{
{ "01", "02" },
{ "03", "04" },
{ "05", "06" },
{ "07", "08" },
},
{
{ "09", "10" },
{ "11", "12" },
{ "13", "14" },
{ "15", "16" },
},
{
{ "17", "18" },
{ "19", "20" },
{ "21", "22" },
{ "23", "24" },
},
},
WStringMultiArrayField = new[, , ]
{
{
{ "01", "02" },
{ "03", "04" },
{ "05", "06" },
{ "07", "08" },
},
{
{ "09", "10" },
{ "11", "12" },
{ "13", "14" },
{ "15", "16" },
},
{
{ "17", "18" },
{ "19", "20" },
{ "21", "22" },
{ "23", "24" },
},
},
CharMultiArrayField = new[, , ]
{
{
{ '1', '2' },
{ '3', '4' },
{ '5', '6' },
{ '7', '8' },
},
{
{ '9', '0' },
{ '1', '2' },
{ '3', '4' },
{ '5', '6' },
},
{
{ '7', '8' },
{ '9', '0' },
{ '1', '2' },
{ '3', '4' },
}
},
WCharMultiArrayField = new[, , ]
{
{
{ '1', '2' },
{ '3', '4' },
{ '5', '6' },
{ '7', '8' }
},
{
{ '9', '0' },
{ '1', '2' },
{ '3', '4' },
{ '5', '6' },
},
{
{ '7', '8' },
{ '9', '0' },
{ '1', '2' },
{ '3', '4' },
}
},
};
dataWriter.Write(data);
ret = dataWriter.WaitForAcknowledgments(new Duration
{
Seconds = 60,
NanoSeconds = 0,
});
if (ret == ReturnCode.Ok)
{
Console.WriteLine("Data sent and acknowledged.");
}
else
{
Console.WriteLine("No acknowledge received: " + ret.ToString());
}
}
else
{
Console.WriteLine("Subscription not found.");
}
}
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);
}
public void TestWaitForAcknowledgments()
{
// 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(TestWaitForAcknowledgments), typeName);
Assert.IsNotNull(topic);
Assert.IsNull(topic.GetListener());
Assert.AreEqual(nameof(TestWaitForAcknowledgments), topic.Name);
Assert.AreEqual(typeName, topic.TypeName);
Publisher publisher = _participant.CreatePublisher();
Assert.IsNotNull(publisher);
Subscriber subscriber = _participant.CreateSubscriber();
Assert.IsNotNull(subscriber);
DataWriter writer = publisher.CreateDataWriter(topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
// Call WaitForAcknowledgments without DataReaders
result = dataWriter.Write(new TestStruct
{
Id = 1
});
Assert.AreEqual(ReturnCode.Ok, result);
result = publisher.WaitForAcknowledgments(new Duration
{
Seconds = 5
});
Assert.AreEqual(ReturnCode.Ok, result);
// Create a Reliable DataReader, write a new sample and Call WaitForAcknowledgments
DataReaderQos drQos = new DataReaderQos();
drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
DataReader reader = subscriber.CreateDataReader(topic, drQos);
Assert.IsNotNull(reader);
System.Threading.Thread.Sleep(500);
result = dataWriter.Write(new TestStruct
{
Id = 2
});
Assert.AreEqual(ReturnCode.Ok, result);
result = publisher.WaitForAcknowledgments(new Duration
{
Seconds = 5
});
Assert.AreEqual(ReturnCode.Ok, result);
}
public void TestSuspendResumePublications()
{
// 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(TestSuspendResumePublications), typeName);
Assert.IsNotNull(topic);
Assert.IsNull(topic.GetListener());
Assert.AreEqual(nameof(TestSuspendResumePublications), topic.Name);
Assert.AreEqual(typeName, topic.TypeName);
Publisher publisher = _participant.CreatePublisher();
Assert.IsNotNull(publisher);
Subscriber subscriber = _participant.CreateSubscriber();
Assert.IsNotNull(subscriber);
DataWriter writer = publisher.CreateDataWriter(topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
DataReaderQos drQos = new DataReaderQos();
drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
drQos.History.Kind = HistoryQosPolicyKind.KeepAllHistoryQos;
DataReader reader = subscriber.CreateDataReader(topic, drQos);
Assert.IsNotNull(reader);
TestStructDataReader dataReader = new TestStructDataReader(reader);
// Call ResumePublications without calling first SuspendPublications
result = publisher.ResumePublications();
Assert.AreEqual(ReturnCode.PreconditionNotMet, result);
// Suspend publications and write samples
result = publisher.SuspendPublications();
Assert.AreEqual(ReturnCode.Ok, result);
for (int i = 1; i <= 5; i++)
{
// OpenDDS issue: cannot register more than one instance during SuspendPublications.
// Looks like that the control messages are never delivered and the controlTracker never get free during delete_datawriter
TestStruct sample = new TestStruct
{
Id = 1,
ShortType = (short)i
};
InstanceHandle handle = dataWriter.RegisterInstance(sample);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle);
result = dataWriter.Write(sample, handle);
Assert.AreEqual(ReturnCode.Ok, result);
}
System.Threading.Thread.Sleep(500);
// Check that not samples arrived
List <TestStruct> data = new List <TestStruct>();
List <SampleInfo> sampleInfos = new List <SampleInfo>();
result = dataReader.Read(data, sampleInfos);
Assert.AreEqual(ReturnCode.NoData, result);
// Resume publication and check the samples
result = publisher.ResumePublications();
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(500);
data = new List <TestStruct>();
sampleInfos = new List <SampleInfo>();
result = dataReader.Read(data, sampleInfos);
Assert.AreEqual(ReturnCode.Ok, result);
for (int i = 0; i < data.Count; i++)
{
Assert.IsTrue(sampleInfos[i].ValidData);
Assert.AreEqual(i + 1, data[i].ShortType);
}
}
public void TestBeginEndCoherentChanges()
{
// 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(TestBeginEndCoherentChanges), typeName);
Assert.IsNotNull(topic);
Assert.IsNull(topic.GetListener());
Assert.AreEqual(nameof(TestBeginEndCoherentChanges), topic.Name);
Assert.AreEqual(typeName, topic.TypeName);
PublisherQos pQos = new PublisherQos();
pQos.Presentation.CoherentAccess = true;
pQos.Presentation.OrderedAccess = true;
pQos.Presentation.AccessScope = PresentationQosPolicyAccessScopeKind.TopicPresentationQos;
Publisher publisher = _participant.CreatePublisher(pQos);
Assert.IsNotNull(publisher);
SubscriberQos sQos = new SubscriberQos();
sQos.Presentation.CoherentAccess = true;
sQos.Presentation.OrderedAccess = true;
sQos.Presentation.AccessScope = PresentationQosPolicyAccessScopeKind.TopicPresentationQos;
Subscriber subscriber = _participant.CreateSubscriber(sQos);
Assert.IsNotNull(subscriber);
DataWriter writer = publisher.CreateDataWriter(topic);
Assert.IsNotNull(writer);
TestStructDataWriter dataWriter = new TestStructDataWriter(writer);
DataReaderQos drQos = new DataReaderQos();
drQos.Reliability.Kind = ReliabilityQosPolicyKind.ReliableReliabilityQos;
drQos.History.Kind = HistoryQosPolicyKind.KeepAllHistoryQos;
DataReader reader = subscriber.CreateDataReader(topic, drQos);
Assert.IsNotNull(reader);
TestStructDataReader dataReader = new TestStructDataReader(reader);
// Call EndCoherentChanges without calling first SuspendPublications
result = publisher.EndCoherentChanges();
Assert.AreEqual(ReturnCode.PreconditionNotMet, result);
// Begin coherent access and write samples
result = publisher.BeginCoherentChanges();
Assert.AreEqual(ReturnCode.Ok, result);
for (int i = 1; i <= 5; i++)
{
TestStruct sample = new TestStruct
{
Id = i,
ShortType = (short)i
};
InstanceHandle handle = dataWriter.RegisterInstance(sample);
Assert.AreNotEqual(InstanceHandle.HandleNil, handle);
result = dataWriter.Write(sample, handle);
Assert.AreEqual(ReturnCode.Ok, result);
}
System.Threading.Thread.Sleep(500);
// Check that not samples arrived
List <TestStruct> data = new List <TestStruct>();
List <SampleInfo> sampleInfos = new List <SampleInfo>();
#region OpenDDS Issue
// Coherent sets for PRESENTATION QoS not Currently implemented on RTPS
//result = dataReader.Read(data, sampleInfos);
//Assert.AreEqual(ReturnCode.NoData, result);
#endregion
// End coherent access and check the samples
result = publisher.EndCoherentChanges();
Assert.AreEqual(ReturnCode.Ok, result);
System.Threading.Thread.Sleep(500);
data = new List <TestStruct>();
sampleInfos = new List <SampleInfo>();
result = dataReader.Read(data, sampleInfos);
Assert.AreEqual(ReturnCode.Ok, result);
for (int i = 0; i < data.Count; i++)
{
Assert.IsTrue(sampleInfos[i].ValidData);
Assert.AreEqual(i + 1, data[i].Id);
Assert.AreEqual(i + 1, data[i].ShortType);
}
}
