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);
}
