public void TestGetInst()
{
// Get a not existing transport instance
TransportInst inst = TransportRegistry.Instance.GetInst(nameof(TestGetInst));
Assert.IsNull(inst);
// Create a new transport instance an try to get it
TransportInst created = TransportRegistry.Instance.CreateInst(nameof(TestGetInst), "shmem");
Assert.IsNotNull(created);
inst = TransportRegistry.Instance.GetInst(nameof(TestGetInst));
Assert.IsNotNull(inst);
Assert.AreEqual(created, inst);
// Test name parameter guards
inst = TransportRegistry.Instance.GetInst(null);
Assert.IsNull(inst);
inst = TransportRegistry.Instance.GetInst("");
Assert.IsNull(inst);
inst = TransportRegistry.Instance.GetInst(" ");
Assert.IsNull(inst);
}
public void TestDefaultValues()
{
TransportInst inst = TransportRegistry.Instance.CreateInst(INSTANCE_NAME, TRANSPORT_TYPE);
UdpInst udpi = new UdpInst(inst);
Assert.AreEqual("0.0.0.0:0", udpi.LocalAddress);
Assert.AreEqual(32U, udpi.DatalinkControlChunks);
Assert.AreEqual(10000, udpi.DatalinkReleaseDelay);
Assert.IsFalse(udpi.IsReliable);
Assert.AreEqual(2147481599u, udpi.MaxPacketSize);
Assert.AreEqual(10U, udpi.MaxSamplesPerPacket);
Assert.AreEqual(INSTANCE_NAME, udpi.Name);
Assert.AreEqual(4096u, udpi.OptimumPacketSize);
Assert.AreEqual(5U, udpi.QueueInitialPools);
Assert.AreEqual(10U, udpi.QueueMessagesPerPool);
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
Assert.AreEqual(65536, udpi.RcvBufferSize);
Assert.AreEqual(65536, udpi.SendBufferSize);
}
else
{
Assert.AreEqual(65535, udpi.RcvBufferSize);
Assert.AreEqual(65535, udpi.SendBufferSize);
}
Assert.AreEqual(TRANSPORT_TYPE, udpi.TransportType);
Assert.IsFalse(udpi.ThreadPerConnection);
TransportRegistry.Instance.RemoveInst(udpi);
}
public void TestDefaultValues()
{
TransportInst inst = TransportRegistry.Instance.CreateInst(INSTANCE_NAME, TRANSPORT_TYPE);
TcpInst tcpi = new TcpInst(inst);
Assert.AreEqual(2000, tcpi.PassiveReconnectDuration);
Assert.AreEqual(-1, tcpi.MaxOutputPausePeriod);
Assert.AreEqual(3, tcpi.ConnRetryAttempts);
Assert.AreEqual(2.0, tcpi.ConnRetryBackoffMultiplier);
Assert.AreEqual(500, tcpi.ConnRetryInitialDelay);
Assert.IsFalse(tcpi.EnableNagleAlgorithm);
Assert.IsTrue(tcpi.IsReliable);
Assert.AreEqual(string.Empty, tcpi.PublicAddress);
Assert.AreEqual(string.Empty, tcpi.LocalAddress);
Assert.AreEqual(32U, tcpi.DatalinkControlChunks);
Assert.AreEqual(10000, tcpi.DatalinkReleaseDelay);
Assert.IsTrue(tcpi.IsReliable);
Assert.AreEqual(2147481599u, tcpi.MaxPacketSize);
Assert.AreEqual(10U, tcpi.MaxSamplesPerPacket);
Assert.AreEqual(INSTANCE_NAME, tcpi.Name);
Assert.AreEqual(4096u, tcpi.OptimumPacketSize);
Assert.AreEqual(5U, tcpi.QueueInitialPools);
Assert.AreEqual(10U, tcpi.QueueMessagesPerPool);
Assert.AreEqual(TRANSPORT_TYPE, tcpi.TransportType);
Assert.IsFalse(tcpi.ThreadPerConnection);
TransportRegistry.Instance.RemoveInst(tcpi);
}
public void TestNonDefaultValues()
{
TransportInst inst = TransportRegistry.Instance.CreateInst(INSTANCE_NAME, TRANSPORT_TYPE);
UdpInst udpi = new UdpInst(inst)
{
LocalAddress = "127.0.0.1:",
DatalinkControlChunks = 64U,
DatalinkReleaseDelay = 20000,
MaxPacketSize = 2147481500u,
MaxSamplesPerPacket = 20U,
OptimumPacketSize = 2048u,
QueueInitialPools = 20U,
QueueMessagesPerPool = 20U,
RcvBufferSize = 65530,
SendBufferSize = 65530,
ThreadPerConnection = true,
};
Assert.AreEqual("127.0.0.1:0", udpi.LocalAddress);
Assert.AreEqual(64U, udpi.DatalinkControlChunks);
Assert.AreEqual(20000, udpi.DatalinkReleaseDelay);
Assert.AreEqual(2147481500u, udpi.MaxPacketSize);
Assert.AreEqual(20U, udpi.MaxSamplesPerPacket);
Assert.AreEqual(INSTANCE_NAME, udpi.Name);
Assert.AreEqual(2048u, udpi.OptimumPacketSize);
Assert.AreEqual(20U, udpi.QueueInitialPools);
Assert.AreEqual(20U, udpi.QueueMessagesPerPool);
Assert.AreEqual(65530, udpi.RcvBufferSize);
Assert.AreEqual(65530, udpi.SendBufferSize);
Assert.AreEqual(TRANSPORT_TYPE, udpi.TransportType);
Assert.IsTrue(udpi.ThreadPerConnection);
TransportRegistry.Instance.RemoveInst(udpi);
}
public void TestRemoveInst()
{
// Create a transport instance and remove it later
TransportInst created = TransportRegistry.Instance.CreateInst(nameof(TestRemoveInst), "shmem");
Assert.IsNotNull(created);
TransportInst inst = TransportRegistry.Instance.GetInst(nameof(TestRemoveInst));
Assert.IsNotNull(inst);
Assert.AreEqual(created, inst);
TransportRegistry.Instance.RemoveInst(created);
created = TransportRegistry.Instance.GetInst(nameof(TestRemoveInst));
Assert.IsNull(created);
// Remove a null instance should not throw exception
bool exception = false;
try
{
TransportRegistry.Instance.RemoveInst(null);
}
catch
{
exception = true;
}
Assert.IsFalse(exception);
}
public void TestInsert()
{
// Test successfully insert
TransportConfig config = TransportRegistry.Instance.CreateConfig(nameof(TestInsert));
Assert.IsNotNull(config);
TransportInst inst = TransportRegistry.Instance.CreateInst(nameof(TestInsert), "shmem");
config.Insert(inst);
Assert.IsNotNull(inst);
Assert.IsNotNull(config.Transports);
Assert.AreEqual(1, config.Transports.Count);
Assert.AreEqual(inst.Name, config.Transports.First().Name);
Assert.AreEqual(inst.TransportType, "shmem");
// Test parameter guard
bool exception = false;
try
{
config.Insert(null);
}
catch (Exception ex)
{
exception = true;
Assert.IsTrue(ex.GetType() == typeof(ArgumentNullException));
}
Assert.IsTrue(exception);
TransportRegistry.Instance.RemoveConfig(config);
}
public void TestNonDefaultValues()
{
TransportInst inst = TransportRegistry.Instance.CreateInst(INSTANCE_NAME, TRANSPORT_TYPE);
ShmemInst shmemi = new ShmemInst(inst)
{
PoolSize = 16000000U,
DatalinkControlSize = 2048U,
DatalinkControlChunks = 64U,
DatalinkReleaseDelay = 20000,
MaxPacketSize = 2147481500u,
MaxSamplesPerPacket = 20U,
OptimumPacketSize = 2048u,
QueueInitialPools = 20U,
QueueMessagesPerPool = 20U,
ThreadPerConnection = true
};
Assert.AreEqual(16000000U, shmemi.PoolSize);
Assert.AreEqual(2048U, shmemi.DatalinkControlSize);
Assert.AreEqual(64U, shmemi.DatalinkControlChunks);
Assert.AreEqual(20000, shmemi.DatalinkReleaseDelay);
Assert.AreEqual(2147481500u, shmemi.MaxPacketSize);
Assert.AreEqual(20U, shmemi.MaxSamplesPerPacket);
Assert.AreEqual(INSTANCE_NAME, shmemi.Name);
Assert.AreEqual(2048u, shmemi.OptimumPacketSize);
Assert.AreEqual(20U, shmemi.QueueInitialPools);
Assert.AreEqual(20U, shmemi.QueueMessagesPerPool);
Assert.IsTrue(shmemi.ThreadPerConnection);
TransportRegistry.Instance.RemoveInst(shmemi);
}
public void TestDefaultValues()
{
TransportInst inst = TransportRegistry.Instance.CreateInst(INSTANCE_NAME, TRANSPORT_TYPE);
MulticastInst mi = new MulticastInst(inst);
Assert.IsFalse(mi.DefaultToIpv6);
Assert.AreEqual("224.0.0.128:49152", mi.GroupAddress);
Assert.AreEqual(string.Empty, mi.LocalAddress);
Assert.AreEqual(32U, mi.NakDepth);
Assert.AreEqual(4U, mi.NakDelayIntervals);
Assert.IsNotNull(mi.NakInterval);
Assert.AreEqual(0, mi.NakInterval.Seconds);
Assert.AreEqual(500000, mi.NakInterval.MicroSeconds);
Assert.AreEqual(3U, mi.NakMax);
Assert.IsNotNull(mi.NakTimeout);
Assert.AreEqual(30, mi.NakTimeout.Seconds);
Assert.AreEqual(0, mi.NakTimeout.MicroSeconds);
Assert.AreEqual(49152, mi.PortOffset);
Assert.IsTrue(mi.Reliable);
Assert.AreEqual(2.0, mi.SynBackoff);
Assert.IsNotNull(mi.SynInterval);
Assert.AreEqual(0, mi.SynInterval.Seconds);
Assert.AreEqual(250000, mi.SynInterval.MicroSeconds);
Assert.IsNotNull(mi.SynTimeout);
Assert.AreEqual(30, mi.SynTimeout.Seconds);
Assert.AreEqual(0, mi.SynTimeout.MicroSeconds);
Assert.IsFalse(mi.AsyncSend);
Assert.AreEqual(1, mi.Ttl);
Assert.AreEqual(32U, mi.DatalinkControlChunks);
Assert.AreEqual(10000, mi.DatalinkReleaseDelay);
Assert.IsTrue(mi.IsReliable);
Assert.AreEqual(2147481599u, mi.MaxPacketSize);
Assert.AreEqual(10U, mi.MaxSamplesPerPacket);
Assert.AreEqual(INSTANCE_NAME, mi.Name);
Assert.AreEqual(4096u, mi.OptimumPacketSize);
Assert.AreEqual(5U, mi.QueueInitialPools);
Assert.AreEqual(10U, mi.QueueMessagesPerPool);
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
Assert.AreEqual(65536U, mi.RcvBufferSize);
}
else
{
Assert.AreEqual(65535U, mi.RcvBufferSize);
}
Assert.AreEqual(TRANSPORT_TYPE, mi.TransportType);
Assert.IsFalse(mi.ThreadPerConnection);
TransportRegistry.Instance.RemoveInst(mi);
}
public static void BindTcpTransportConfig(this Entity entity)
{
string guid = Guid.NewGuid().ToString("N");
string configName = "openddsharp_tcp_" + guid;
string instName = "internal_openddsharp_tcp_transport_" + guid;
TransportConfig config = TransportRegistry.Instance.CreateConfig(configName);
TransportInst inst = TransportRegistry.Instance.CreateInst(instName, "tcp");
TcpInst tcpi = new TcpInst(inst);
config.Insert(inst);
TransportRegistry.Instance.BindConfig(config, entity);
}
public static void BindRtpsUdpTransportConfig(this Entity entity)
{
string guid = Guid.NewGuid().ToString("N");
string configName = "openddsharp_rtps_interop_" + guid;
string instName = "internal_openddsharp_rtps_transport_" + guid;
TransportConfig config = TransportRegistry.Instance.CreateConfig(configName);
TransportInst inst = TransportRegistry.Instance.CreateInst(instName, "rtps_udp");
RtpsUdpInst rui = new RtpsUdpInst(inst);
config.Insert(inst);
TransportRegistry.Instance.BindConfig(configName, entity);
}
private static void BindRtpsUdpTransportConfig(DomainParticipant participant)
{
string guid = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
string configName = "openddsharp_rtps_interop_" + guid;
string instName = "internal_openddsharp_rtps_transport_" + guid;
TransportConfig config = TransportRegistry.Instance.CreateConfig(configName);
TransportInst inst = TransportRegistry.Instance.CreateInst(instName, "rtps_udp");
RtpsUdpInst rui = new RtpsUdpInst(inst);
config.Insert(rui);
TransportRegistry.Instance.BindConfig(configName, participant);
}
private static void BindRtpsUdpTransportConfig(DomainParticipant participant)
{
long ticks = DateTime.Now.Ticks;
string configName = "openddsharp_rtps_interop_" + ticks.ToString();
string instName = "internal_openddsharp_rtps_transport_" + ticks.ToString();
TransportConfig config = TransportRegistry.Instance.CreateConfig(configName);
TransportInst inst = TransportRegistry.Instance.CreateInst(instName, "rtps_udp");
RtpsUdpInst rui = new RtpsUdpInst(inst);
config.Insert(inst);
TransportRegistry.Instance.BindConfig(configName, participant);
}
public static void BindTcpTransportConfig(this Entity entity)
{
long ticks = DateTime.Now.Ticks;
string configName = "openddsharp_tcp_" + ticks.ToString();
string instName = "internal_openddsharp_tcp_transport_" + ticks.ToString();
TransportConfig config = TransportRegistry.Instance.CreateConfig(configName);
TransportInst inst = TransportRegistry.Instance.CreateInst(instName, "tcp");
TcpInst tcpi = new TcpInst(inst);
config.Insert(inst);
TransportRegistry.Instance.BindConfig(config, entity);
}
public void TestSortedInsert()
{
// Test successfully insert
TransportConfig config = TransportRegistry.Instance.CreateConfig(nameof(TestSortedInsert));
Assert.IsNotNull(config);
// Create transport instance B
TransportInst instB = TransportRegistry.Instance.CreateInst(nameof(TestSortedInsert) + "B", "shmem");
config.SortedInsert(instB);
Assert.IsNotNull(instB);
Assert.IsNotNull(config.Transports);
Assert.AreEqual(1, config.Transports.Count);
Assert.AreEqual(instB.Name, config.Transports.First().Name);
Assert.AreEqual(instB.TransportType, "shmem");
// Create transport instance A
TransportInst instA = TransportRegistry.Instance.CreateInst(nameof(TestSortedInsert) + "A", "udp");
config.SortedInsert(instA);
Assert.IsNotNull(instA);
// Check the transport list
Assert.IsNotNull(config.Transports);
Assert.AreEqual(2, config.Transports.Count);
Assert.AreEqual(instA.Name, config.Transports.ElementAt(0).Name);
Assert.AreEqual(instA.TransportType, "udp");
Assert.AreEqual(instB.Name, config.Transports.ElementAt(1).Name);
Assert.AreEqual(instB.TransportType, "shmem");
// Test parameter guard
bool exception = false;
try
{
config.SortedInsert(null);
}
catch (Exception ex)
{
exception = true;
Assert.IsTrue(ex.GetType() == typeof(ArgumentNullException));
}
Assert.IsTrue(exception);
TransportRegistry.Instance.RemoveConfig(config);
}
public void TestDefaultValues()
{
TransportInst inst = TransportRegistry.Instance.CreateInst(INSTANCE_NAME, TRANSPORT_TYPE);
RtpsUdpInst rui = new RtpsUdpInst(inst);
Assert.IsTrue(rui.UseMulticast);
Assert.AreEqual("239.255.0.2:7401", rui.MulticastGroupAddress);
Assert.AreEqual(string.Empty, rui.MulticastInterface);
Assert.AreEqual("0.0.0.0:0", rui.LocalAddress);
Assert.AreEqual(0U, rui.NakDepth);
Assert.IsNotNull(rui.NakResponseDelay);
Assert.AreEqual(0, rui.NakResponseDelay.Seconds);
Assert.AreEqual(200000, rui.NakResponseDelay.MicroSeconds);
Assert.IsNotNull(rui.HeartbeatPeriod);
Assert.AreEqual(1, rui.HeartbeatPeriod.Seconds);
Assert.AreEqual(0, rui.HeartbeatPeriod.MicroSeconds);
Assert.AreEqual(1, rui.Ttl);
Assert.AreEqual(32U, rui.DatalinkControlChunks);
Assert.AreEqual(10000, rui.DatalinkReleaseDelay);
Assert.IsTrue(rui.IsReliable);
Assert.AreEqual(2147481599u, rui.MaxPacketSize);
Assert.AreEqual(10U, rui.MaxSamplesPerPacket);
Assert.AreEqual(INSTANCE_NAME, rui.Name);
Assert.AreEqual(4096u, rui.OptimumPacketSize);
Assert.AreEqual(5U, rui.QueueInitialPools);
Assert.AreEqual(10U, rui.QueueMessagesPerPool);
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
Assert.AreEqual(65536, rui.RcvBufferSize);
Assert.AreEqual(65536, rui.SendBufferSize);
}
else
{
Assert.AreEqual(65535, rui.RcvBufferSize);
Assert.AreEqual(65535, rui.SendBufferSize);
}
Assert.AreEqual(TRANSPORT_TYPE, rui.TransportType);
Assert.IsTrue(rui.RequiresCdr);
Assert.IsFalse(rui.ThreadPerConnection);
Assert.AreEqual(5, rui.ReceiveAddressDuration.Seconds);
Assert.AreEqual(0, rui.ReceiveAddressDuration.MicroSeconds);
TransportRegistry.Instance.RemoveInst(rui);
}
public void TestNonDefaultValues()
{
TransportInst inst = TransportRegistry.Instance.CreateInst(INSTANCE_NAME, TRANSPORT_TYPE);
TcpInst tcpi = new TcpInst(inst)
{
PassiveReconnectDuration = 1000,
MaxOutputPausePeriod = 5000,
ConnRetryAttempts = 5,
ConnRetryBackoffMultiplier = 1.5,
ConnRetryInitialDelay = 1000,
EnableNagleAlgorithm = true,
PublicAddress = "127.0.0.1:",
LocalAddress = "127.0.0.1:",
DatalinkControlChunks = 64U,
DatalinkReleaseDelay = 20000,
MaxPacketSize = 2147481500u,
MaxSamplesPerPacket = 20U,
OptimumPacketSize = 2048u,
QueueInitialPools = 10U,
QueueMessagesPerPool = 20U,
ThreadPerConnection = true
};
Assert.AreEqual(1000, tcpi.PassiveReconnectDuration);
Assert.AreEqual(5000, tcpi.MaxOutputPausePeriod);
Assert.AreEqual(5, tcpi.ConnRetryAttempts);
Assert.AreEqual(1.5, tcpi.ConnRetryBackoffMultiplier);
Assert.AreEqual(1000, tcpi.ConnRetryInitialDelay);
Assert.IsTrue(tcpi.EnableNagleAlgorithm);
Assert.IsTrue(tcpi.IsReliable);
Assert.AreEqual("127.0.0.1:", tcpi.PublicAddress);
Assert.AreEqual("127.0.0.1:", tcpi.LocalAddress);
Assert.AreEqual(64U, tcpi.DatalinkControlChunks);
Assert.AreEqual(20000, tcpi.DatalinkReleaseDelay);
Assert.AreEqual(2147481500u, tcpi.MaxPacketSize);
Assert.AreEqual(20U, tcpi.MaxSamplesPerPacket);
Assert.AreEqual(2048u, tcpi.OptimumPacketSize);
Assert.AreEqual(10U, tcpi.QueueInitialPools);
Assert.AreEqual(20U, tcpi.QueueMessagesPerPool);
Assert.IsTrue(tcpi.ThreadPerConnection);
TransportRegistry.Instance.RemoveInst(tcpi);
}
public void TestNonDefaultValue()
{
TransportConfig config = TransportRegistry.Instance.CreateConfig(nameof(TestNonDefaultValue));
Assert.IsNotNull(config);
config.SwapBytes = true;
config.PassiveConnectDuration = 30000u;
TransportInst inst = TransportRegistry.Instance.CreateInst(nameof(TestNonDefaultValue), "shmem");
Assert.IsNotNull(inst);
config.Insert(inst);
Assert.IsNotNull(config);
Assert.AreEqual(nameof(TestNonDefaultValue), config.Name);
Assert.AreEqual(30000u, config.PassiveConnectDuration);
Assert.IsTrue(config.SwapBytes);
Assert.IsNotNull(config.Transports);
Assert.AreEqual(1, config.Transports.Count);
Assert.AreEqual(inst.Name, config.Transports.First().Name);
TransportRegistry.Instance.RemoveConfig(config);
}
public void TestDefaultValues()
{
TransportInst inst = TransportRegistry.Instance.CreateInst(INSTANCE_NAME, TRANSPORT_TYPE);
ShmemInst shmemi = new ShmemInst(inst);
Assert.IsFalse(string.IsNullOrWhiteSpace(shmemi.HostName));
Assert.AreEqual(16777216U, shmemi.PoolSize);
Assert.IsFalse(string.IsNullOrWhiteSpace(shmemi.PoolName));
Assert.AreEqual(4096U, shmemi.DatalinkControlSize);
Assert.AreEqual(32U, shmemi.DatalinkControlChunks);
Assert.AreEqual(10000, shmemi.DatalinkReleaseDelay);
Assert.IsTrue(shmemi.IsReliable);
Assert.AreEqual(2147481599u, shmemi.MaxPacketSize);
Assert.AreEqual(10U, shmemi.MaxSamplesPerPacket);
Assert.AreEqual(INSTANCE_NAME, shmemi.Name);
Assert.AreEqual(4096u, shmemi.OptimumPacketSize);
Assert.AreEqual(5U, shmemi.QueueInitialPools);
Assert.AreEqual(10U, shmemi.QueueMessagesPerPool);
Assert.AreEqual(TRANSPORT_TYPE, shmemi.TransportType);
Assert.IsFalse(shmemi.ThreadPerConnection);
TransportRegistry.Instance.RemoveInst(shmemi);
}
public void Add(IntPtr ptr, TransportInst inst)
{
_insts.AddOrUpdate(ptr, inst, (p, t) => inst);
}
public void TestCreateInst()
{
// Create a RTPS UDP transport instance
TransportInst inst = TransportRegistry.Instance.CreateInst(nameof(TestCreateInst), "rtps_udp");
Assert.IsNotNull(inst);
Assert.AreEqual(nameof(TestCreateInst), inst.Name);
Assert.AreEqual("rtps_udp", inst.TransportType);
RtpsUdpInst rui = new RtpsUdpInst(inst);
Assert.IsNotNull(rui);
TransportRegistry.Instance.RemoveInst(inst);
// Create a UDP transport instance
inst = TransportRegistry.Instance.CreateInst(nameof(TestCreateInst), "udp");
Assert.IsNotNull(inst);
Assert.AreEqual(nameof(TestCreateInst), inst.Name);
Assert.AreEqual("udp", inst.TransportType);
UdpInst udpi = new UdpInst(inst);
Assert.IsNotNull(udpi);
TransportRegistry.Instance.RemoveInst(inst);
// Create a Multicast transport instance
inst = TransportRegistry.Instance.CreateInst(nameof(TestCreateInst), "multicast");
Assert.IsNotNull(inst);
Assert.AreEqual(nameof(TestCreateInst), inst.Name);
Assert.AreEqual("multicast", inst.TransportType);
MulticastInst multicasti = new MulticastInst(inst);
Assert.IsNotNull(multicasti);
TransportRegistry.Instance.RemoveInst(inst);
// Create a Multicast transport instance
inst = TransportRegistry.Instance.CreateInst(nameof(TestCreateInst), "tcp");
Assert.IsNotNull(inst);
Assert.AreEqual(nameof(TestCreateInst), inst.Name);
Assert.AreEqual("tcp", inst.TransportType);
MulticastInst tcpi = new MulticastInst(inst);
Assert.IsNotNull(tcpi);
TransportRegistry.Instance.RemoveInst(inst);
// Create a SharedMemory transport instance
inst = TransportRegistry.Instance.CreateInst(nameof(TestCreateInst), "shmem");
Assert.IsNotNull(inst);
Assert.AreEqual(nameof(TestCreateInst), inst.Name);
Assert.AreEqual("shmem", inst.TransportType);
ShmemInst shmemi = new ShmemInst(inst);
Assert.IsNotNull(shmemi);
TransportRegistry.Instance.RemoveInst(inst);
// Create a instance with an invalid transport type
inst = TransportRegistry.Instance.CreateInst(nameof(TestCreateInst), "quantic_teletransport");
Assert.IsNull(inst);
// Try to create a transport instance with empty name
bool exception = false;
try
{
inst = TransportRegistry.Instance.CreateInst(null, "shmem");
}
catch (Exception ex)
{
exception = true;
Assert.IsTrue(ex.GetType() == typeof(ArgumentNullException));
}
Assert.IsTrue(exception);
exception = false;
try
{
inst = TransportRegistry.Instance.CreateInst(string.Empty, "shmem");
}
catch (Exception ex)
{
exception = true;
Assert.IsTrue(ex.GetType() == typeof(ArgumentNullException));
}
Assert.IsTrue(exception);
exception = false;
try
{
inst = TransportRegistry.Instance.CreateInst(" ", "shmem");
}
catch (Exception ex)
{
exception = true;
Assert.IsTrue(ex.GetType() == typeof(ArgumentNullException));
}
Assert.IsTrue(exception);
}
public OpenDDSharpService()
{
_config = ServiceLocator.Current.GetInstance <IConfigurationService>();
_disc = new RtpsDiscovery(RTPS_DISCOVERY)
{
ResendPeriod = new TimeValue {
Seconds = 1
},
SedpMulticast = true
};
ParticipantService.Instance.AddDiscovery(_disc);
ParticipantService.Instance.DefaultDiscovery = RTPS_DISCOVERY;
long ticks = DateTime.Now.Ticks;
string configName = "openddsharp_rtps_interop_" + ticks.ToString();;
string instName = "internal_openddsharp_rtps_transport_" + ticks.ToString();;
_tConfig = TransportRegistry.Instance.CreateConfig(configName);
_inst = TransportRegistry.Instance.CreateInst(instName, "rtps_udp");
_rui = new RtpsUdpInst(_inst);
_tConfig.Insert(_inst);
TransportRegistry.Instance.GlobalConfig = _tConfig;
ParticipantService.Instance.SetRepoDomain(0, RTPS_DISCOVERY);
_domainFactory = ParticipantService.Instance.GetDomainParticipantFactory("-DCPSDebugLevel", "10", "-ORBLogFile", "LogFile.log", "-ORBDebugLevel", "10");
_participant = _domainFactory.CreateParticipant(0);
if (_participant == null)
{
throw new Exception("Could not create the participant");
}
ShapeTypeTypeSupport support = new ShapeTypeTypeSupport();
ReturnCode result = support.RegisterType(_participant, TYPE_NAME);
if (result != ReturnCode.Ok)
{
throw new Exception("Could not register type: " + result.ToString());
}
_squareTopic = _participant.CreateTopic(SQUARE_TOPIC_NAME, TYPE_NAME);
if (_squareTopic == null)
{
throw new Exception("Could not create square topic");
}
_circleTopic = _participant.CreateTopic(CIRCLE_TOPIC_NAME, TYPE_NAME);
if (_circleTopic == null)
{
throw new Exception("Could not create circle topic");
}
_triangleTopic = _participant.CreateTopic(TRIANGLE_TOPIC_NAME, TYPE_NAME);
if (_triangleTopic == null)
{
throw new Exception("Could not create triangle topic");
}
_publisher = _participant.CreatePublisher();
if (_publisher == null)
{
throw new Exception("Could not create publisher");
}
_subscriber = _participant.CreateSubscriber();
if (_subscriber == null)
{
throw new Exception("Could not create subscriber");
}
_shapeWaitSets = new List <ShapeWaitSet>();
_shapeDynamics = new List <ShapeDynamic>();
_cfCircleCount = 0;
_cfSquareCount = 0;
_cfTriangleCount = 0;
}
public void TestNonDefaultValues()
{
TransportInst inst = TransportRegistry.Instance.CreateInst(INSTANCE_NAME, TRANSPORT_TYPE);
MulticastInst mi = new MulticastInst(inst)
{
DefaultToIpv6 = true,
GroupAddress = "224.0.0.64:49150",
LocalAddress = "127.0.0.1:",
NakDepth = 64U,
NakDelayIntervals = 8U,
NakInterval = new TimeValue
{
Seconds = 1,
MicroSeconds = 0,
},
NakMax = 6U,
NakTimeout = new TimeValue
{
Seconds = 10,
MicroSeconds = 500000,
},
PortOffset = 49150,
Reliable = false,
SynBackoff = 1.5,
SynInterval = new TimeValue
{
Seconds = 10,
MicroSeconds = 500000,
},
SynTimeout = new TimeValue
{
Seconds = 10,
MicroSeconds = 500000,
},
AsyncSend = true,
Ttl = 2,
DatalinkControlChunks = 64U,
DatalinkReleaseDelay = 20000,
MaxPacketSize = 2147481500u,
MaxSamplesPerPacket = 20U,
OptimumPacketSize = 2048u,
QueueInitialPools = 10U,
QueueMessagesPerPool = 20U,
RcvBufferSize = 65530U,
ThreadPerConnection = true,
};
Assert.IsTrue(mi.DefaultToIpv6);
Assert.AreEqual("224.0.0.64:49150", mi.GroupAddress);
Assert.AreEqual("127.0.0.1:", mi.LocalAddress);
Assert.AreEqual(64U, mi.NakDepth);
Assert.AreEqual(8U, mi.NakDelayIntervals);
Assert.IsNotNull(mi.NakInterval);
Assert.AreEqual(1, mi.NakInterval.Seconds);
Assert.AreEqual(0, mi.NakInterval.MicroSeconds);
Assert.AreEqual(6U, mi.NakMax);
Assert.IsNotNull(mi.NakTimeout);
Assert.AreEqual(10, mi.NakTimeout.Seconds);
Assert.AreEqual(500000, mi.NakTimeout.MicroSeconds);
Assert.AreEqual(49150, mi.PortOffset);
Assert.IsFalse(mi.Reliable);
Assert.AreEqual(1.5, mi.SynBackoff);
Assert.IsNotNull(mi.SynInterval);
Assert.AreEqual(10, mi.SynInterval.Seconds);
Assert.AreEqual(500000, mi.SynInterval.MicroSeconds);
Assert.IsNotNull(mi.SynTimeout);
Assert.AreEqual(10, mi.SynTimeout.Seconds);
Assert.AreEqual(500000, mi.SynTimeout.MicroSeconds);
Assert.IsTrue(mi.AsyncSend);
Assert.AreEqual(2, mi.Ttl);
Assert.AreEqual(64U, mi.DatalinkControlChunks);
Assert.AreEqual(20000, mi.DatalinkReleaseDelay);
Assert.IsFalse(mi.IsReliable);
Assert.AreEqual(2147481500u, mi.MaxPacketSize);
Assert.AreEqual(20U, mi.MaxSamplesPerPacket);
Assert.AreEqual(INSTANCE_NAME, mi.Name);
Assert.AreEqual(2048u, mi.OptimumPacketSize);
Assert.AreEqual(10U, mi.QueueInitialPools);
Assert.AreEqual(20U, mi.QueueMessagesPerPool);
Assert.AreEqual(65530U, mi.RcvBufferSize);
Assert.AreEqual(TRANSPORT_TYPE, mi.TransportType);
Assert.IsTrue(mi.ThreadPerConnection);
TransportRegistry.Instance.RemoveInst(mi);
}
public void TestNonDefaultValues()
{
TransportInst inst = TransportRegistry.Instance.CreateInst(INSTANCE_NAME, TRANSPORT_TYPE);
RtpsUdpInst rui = new RtpsUdpInst(inst)
{
UseMulticast = false,
MulticastGroupAddress = "239.255.0.1:7402",
LocalAddress = "127.0.0.1:",
MulticastInterface = "eth0",
NakDepth = 64U,
NakResponseDelay = new TimeValue
{
Seconds = 1,
MicroSeconds = 400000
},
HeartbeatPeriod = new TimeValue
{
Seconds = 2,
MicroSeconds = 100000
},
HeartbeatResponseDelay = new TimeValue
{
Seconds = 2,
MicroSeconds = 100000
},
HandshakeTimeout = new TimeValue
{
Seconds = 60,
MicroSeconds = 100000
},
Ttl = 2,
DatalinkControlChunks = 64U,
DatalinkReleaseDelay = 20000,
DurableDataTimeout = new TimeValue
{
Seconds = 20,
MicroSeconds = 100000
},
MaxPacketSize = 2147481500u,
MaxSamplesPerPacket = 20U,
OptimumPacketSize = 2048u,
QueueInitialPools = 20U,
QueueMessagesPerPool = 20U,
RcvBufferSize = 65530,
SendBufferSize = 65530,
ThreadPerConnection = true
};
Assert.IsFalse(rui.UseMulticast);
Assert.AreEqual("239.255.0.1:7402", rui.MulticastGroupAddress);
Assert.AreEqual("eth0", rui.MulticastInterface);
Assert.AreEqual("127.0.0.1:", rui.LocalAddress);
Assert.AreEqual(64U, rui.NakDepth);
Assert.IsNotNull(rui.NakResponseDelay);
Assert.AreEqual(1, rui.NakResponseDelay.Seconds);
Assert.AreEqual(400000, rui.NakResponseDelay.MicroSeconds);
Assert.IsNotNull(rui.HeartbeatPeriod);
Assert.AreEqual(2, rui.HeartbeatPeriod.Seconds);
Assert.AreEqual(100000, rui.HeartbeatPeriod.MicroSeconds);
Assert.IsNotNull(rui.HeartbeatResponseDelay);
Assert.AreEqual(2, rui.HeartbeatResponseDelay.Seconds);
Assert.AreEqual(100000, rui.HeartbeatResponseDelay.MicroSeconds);
Assert.IsNotNull(rui.HandshakeTimeout);
Assert.AreEqual(60, rui.HandshakeTimeout.Seconds);
Assert.AreEqual(100000, rui.HandshakeTimeout.MicroSeconds);
Assert.AreEqual(2, rui.Ttl);
Assert.AreEqual(64U, rui.DatalinkControlChunks);
Assert.AreEqual(20000, rui.DatalinkReleaseDelay);
Assert.IsNotNull(rui.DurableDataTimeout);
Assert.AreEqual(20, rui.DurableDataTimeout.Seconds);
Assert.AreEqual(100000, rui.DurableDataTimeout.MicroSeconds);
Assert.IsTrue(rui.IsReliable);
Assert.AreEqual(2147481500u, rui.MaxPacketSize);
Assert.AreEqual(20U, rui.MaxSamplesPerPacket);
Assert.AreEqual(INSTANCE_NAME, rui.Name);
Assert.AreEqual(2048u, rui.OptimumPacketSize);
Assert.AreEqual(20U, rui.QueueInitialPools);
Assert.AreEqual(20U, rui.QueueMessagesPerPool);
Assert.AreEqual(65530, rui.RcvBufferSize);
Assert.AreEqual(65530, rui.SendBufferSize);
Assert.AreEqual(TRANSPORT_TYPE, rui.TransportType);
Assert.IsTrue(rui.RequiresCdr);
Assert.IsTrue(rui.ThreadPerConnection);
TransportRegistry.Instance.RemoveInst(rui);
}
