dadada/ns-3-leo
dadada/ns-3-leo
1
0
Fork 0
mirror of https://gitlab.ibr.cs.tu-bs.de/tschuber/ns-3-leo.git synced 2025-06-08 01:53:58 +02:00
Code Issues Releases Wiki Activity

Fix address generation in tests

Browse source
This commit is contained in:
Tim Schubert 2020-08-07 20:30:18 +02:00
parent 42f5bac245
commit 4f41cb04af
5 changed files with 143 additions and 189 deletions
Download patch file Download diff file Expand all files Collapse all files

5
model/isl-mock-channel.cc
View file

@ -62,6 +62,11 @@ IslMockChannel::TransmitStart (
NS_LOG_FUNCTION (this << p << srcId << destAddr << txTime); NS_LOG_FUNCTION (this << p << srcId << destAddr << txTime);
NS_LOG_LOGIC ("UID is " << p->GetUid () << ")"); NS_LOG_LOGIC ("UID is " << p->GetUid () << ")");
if (srcId >= GetNDevices ())
{
NS_LOG_ERROR ("Source device unknown");
return false;
}
Ptr<MockNetDevice> src = DynamicCast<MockNetDevice> (GetDevice (srcId)); Ptr<MockNetDevice> src = DynamicCast<MockNetDevice> (GetDevice (srcId));
Ptr<MockNetDevice> dst = DynamicCast<MockNetDevice> (GetDevice (destAddr)); Ptr<MockNetDevice> dst = DynamicCast<MockNetDevice> (GetDevice (destAddr));

6
model/leo-mock-channel.cc
View file

@ -44,6 +44,12 @@ LeoMockChannel::TransmitStart (Ptr<const Packet> p,
NS_LOG_FUNCTION (this << p << devId << dst << txTime); NS_LOG_FUNCTION (this << p << devId << dst << txTime);
// Find devices joined to channel // Find devices joined to channel
if (devId >= GetNDevices ())
{
NS_LOG_ERROR ("Source device unknown");
return false;
}
Ptr<MockNetDevice> srcDev = DynamicCast<MockNetDevice> (GetDevice (devId)); Ptr<MockNetDevice> srcDev = DynamicCast<MockNetDevice> (GetDevice (devId));
if (srcDev == 0) if (srcDev == 0)
{ {

238
model/mock-channel.cc
View file

@ -31,30 +31,30 @@ NS_LOG_COMPONENT_DEFINE ("MockChannel");
NS_OBJECT_ENSURE_REGISTERED (MockChannel); NS_OBJECT_ENSURE_REGISTERED (MockChannel);
TypeId TypeId
MockChannel::GetTypeId (void) MockChannel::GetTypeId (void)
{ {
static TypeId tid = TypeId ("ns3::MockChannel") static TypeId tid = TypeId ("ns3::MockChannel")
.SetParent<Channel> () .SetParent<Channel> ()
.SetGroupName ("Leo") .SetGroupName ("Leo")
.AddAttribute ("PropagationDelay", .AddAttribute ("PropagationDelay",
"A propagation delay model for the channel.", "A propagation delay model for the channel.",
PointerValue (), PointerValue (),
MakePointerAccessor (&MockChannel::m_propagationDelay), MakePointerAccessor (&MockChannel::m_propagationDelay),
MakePointerChecker<PropagationDelayModel> ()) MakePointerChecker<PropagationDelayModel> ())
.AddAttribute ("PropagationLoss", .AddAttribute ("PropagationLoss",
"A propagation loss model for the channel.", "A propagation loss model for the channel.",
PointerValue (), PointerValue (),
MakePointerAccessor (&MockChannel::m_propagationLoss), MakePointerAccessor (&MockChannel::m_propagationLoss),
MakePointerChecker<PropagationLossModel> ()) MakePointerChecker<PropagationLossModel> ())
.AddTraceSource ("TxRxMockChannel", .AddTraceSource ("TxRxMockChannel",
"Trace source indicating transmission of packet " "Trace source indicating transmission of packet "
"from the MockChannel, used by the Animation " "from the MockChannel, used by the Animation "
"interface.", "interface.",
MakeTraceSourceAccessor (&MockChannel::m_txrxMock), MakeTraceSourceAccessor (&MockChannel::m_txrxMock),
"ns3::MockChannel::TxRxAnimationCallback") "ns3::MockChannel::TxRxAnimationCallback")
; ;
return tid; return tid;
} }
// //
// By default, you get a channel that // By default, you get a channel that
@ -65,132 +65,132 @@ MockChannel::MockChannel() : Channel (), m_link (0)
} }
MockChannel::~MockChannel() MockChannel::~MockChannel()
{ {
} }
bool bool
MockChannel::Detach (uint32_t deviceId) MockChannel::Detach (uint32_t deviceId)
{
NS_LOG_FUNCTION (this << deviceId);
if (deviceId < m_link.size ())
{ {
NS_LOG_FUNCTION (this << deviceId); if (!m_link[deviceId]->IsLinkUp ())
if (deviceId < m_link.size ()) {
{ NS_LOG_WARN ("MockChannel::Detach(): Device is already detached (" << deviceId << ")");
if (!m_link[deviceId]->IsLinkUp ()) return false;
{ }
NS_LOG_WARN ("MockChannel::Detach(): Device is already detached (" << deviceId << ")");
return false;
}
m_link[deviceId]->NotifyLinkDown (); m_link[deviceId]->NotifyLinkDown ();
}
else
{
return false;
}
return true;
} }
else
{
return false;
}
return true;
}
int32_t int32_t
MockChannel::Attach (Ptr<MockNetDevice> device) MockChannel::Attach (Ptr<MockNetDevice> device)
{ {
NS_LOG_FUNCTION (this << device); NS_LOG_FUNCTION (this << device);
NS_ASSERT (device != 0); NS_ASSERT (device != 0);
m_link.push_back(device); m_link.push_back(device);
return m_link.size() - 1; return m_link.size() - 1;
} }
std::size_t std::size_t
MockChannel::GetNDevices (void) const MockChannel::GetNDevices (void) const
{ {
NS_LOG_FUNCTION_NOARGS (); NS_LOG_FUNCTION_NOARGS ();
return m_link.size (); return m_link.size ();
} }
Ptr<NetDevice> Ptr<NetDevice>
MockChannel::GetDevice (std::size_t i) const MockChannel::GetDevice (std::size_t i) const
{ {
NS_LOG_FUNCTION_NOARGS (); NS_LOG_FUNCTION_NOARGS ();
return m_link[i]; return m_link[i];
} }
Time Time
MockChannel::GetPropagationDelay (Ptr<MobilityModel> srcMob, Ptr<MobilityModel> dstMob, Time txTime) const MockChannel::GetPropagationDelay (Ptr<MobilityModel> srcMob, Ptr<MobilityModel> dstMob, Time txTime) const
{ {
NS_LOG_FUNCTION (this << srcMob << dstMob << txTime); NS_LOG_FUNCTION (this << srcMob << dstMob << txTime);
if (GetPropagationDelay ()) if (GetPropagationDelay ())
{ {
Time propagationDelay = m_propagationDelay->GetDelay (srcMob, dstMob); Time propagationDelay = m_propagationDelay->GetDelay (srcMob, dstMob);
return propagationDelay; return propagationDelay;
}
else
{
return Time (0);
}
} }
else
{
return Time (0);
}
}
// TODO optimize // TODO optimize
Ptr<MockNetDevice> Ptr<MockNetDevice>
MockChannel::GetDevice (Address &addr) const MockChannel::GetDevice (Address &addr) const
{
for (Ptr<MockNetDevice> dev : m_link)
{ {
for (Ptr<MockNetDevice> dev : m_link) if (dev->GetAddress () == addr)
{ {
if (dev->GetAddress () == addr) return dev;
{ }
return dev;
}
}
return 0;
} }
return 0;
}
Ptr<PropagationDelayModel> Ptr<PropagationDelayModel>
MockChannel::GetPropagationDelay () const MockChannel::GetPropagationDelay () const
{ {
return m_propagationDelay; return m_propagationDelay;
} }
Ptr<PropagationLossModel> Ptr<PropagationLossModel>
MockChannel::GetPropagationLoss () const MockChannel::GetPropagationLoss () const
{ {
return m_propagationLoss; return m_propagationLoss;
} }
bool bool
MockChannel::Deliver ( MockChannel::Deliver (
Ptr<const Packet> p, Ptr<const Packet> p,
Ptr<MockNetDevice> src, Ptr<MockNetDevice> src,
Ptr<MockNetDevice> dst, Ptr<MockNetDevice> dst,
Time txTime) Time txTime)
{
NS_LOG_FUNCTION (this << p << src->GetAddress () << dst->GetAddress () << txTime);
Time delay = txTime;
Ptr<MobilityModel> srcMob = src->GetObject<MobilityModel> ();
Ptr<MobilityModel> dstMob = dst->GetObject<MobilityModel> ();
if (srcMob != 0 && dstMob != 0)
{ {
NS_LOG_FUNCTION (this << p << src->GetAddress () << dst->GetAddress () << txTime); Ptr<PropagationLossModel> pLoss = GetPropagationLoss ();
Time delay = txTime; if (pLoss != 0)
Ptr<MobilityModel> srcMob = src->GetObject<MobilityModel> ();
Ptr<MobilityModel> dstMob = dst->GetObject<MobilityModel> ();
if (srcMob != 0 && dstMob != 0)
{ {
Ptr<PropagationLossModel> pLoss = GetPropagationLoss (); if (pLoss->CalcRxPower (1.0, srcMob, dstMob) == 0.0)
if (pLoss != 0)
{ {
if (pLoss->CalcRxPower (1.0, srcMob, dstMob) == 0.0) return false;
{
return false;
}
} }
delay += GetPropagationDelay (srcMob, dstMob, txTime);
} }
delay += GetPropagationDelay (srcMob, dstMob, txTime);
Simulator::ScheduleWithContext (dst->GetNode ()->GetId (),
delay,
&MockNetDevice::Receive,
dst,
p->Copy (),
src);
// Call the tx anim callback on the net device
m_txrxMock (p, src, dst, txTime, delay);
return true;
} }
Simulator::ScheduleWithContext (dst->GetNode ()->GetId (),
delay,
&MockNetDevice::Receive,
dst,
p->Copy (),
src);
// Call the tx anim callback on the net device
m_txrxMock (p, src, dst, txTime, delay);
return true;
}
} // namespace ns3 } // namespace ns3

11
test/isl-mock-channel-test-suite.cc
View file

@ -22,7 +22,7 @@ private:
}; };
IslMockChannelTransmitUnknownTestCase::IslMockChannelTransmitUnknownTestCase () IslMockChannelTransmitUnknownTestCase::IslMockChannelTransmitUnknownTestCase ()
: TestCase ("Test transmission to unkown destination") : TestCase ("Test transmission to broadcast address")
{ {
} }
@ -37,14 +37,13 @@ IslMockChannelTransmitUnknownTestCase::DoRun (void)
Packet *packet = new Packet (); Packet *packet = new Packet ();
Ptr<Packet> p = Ptr<Packet>(packet); Ptr<Packet> p = Ptr<Packet>(packet);
Ptr<MockNetDevice> dev = CreateObject<MockNetDevice> (); Ptr<MockNetDevice> dev = CreateObject<MockNetDevice> ();
dev->SetAddress (Mac48Address::Allocate ());
int32_t srcId = channel->Attach (dev); int32_t srcId = channel->Attach (dev);
Address destAddr; Address destAddr = Mac48Address::GetBroadcast ();
Time txTime; Time txTime;
channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel"));
channel->SetAttribute ("PropagationLoss", StringValue ("ns3::IslPropagationLossModel"));
bool result = channel->TransmitStart (p, srcId, destAddr, txTime); bool result = channel->TransmitStart (p, srcId, destAddr, txTime);
NS_TEST_ASSERT_MSG_EQ (result, false, "Unknown destination fails to deliver"); NS_TEST_ASSERT_MSG_EQ (result, true, "Broadcast address delivers to all");
} }
class IslMockChannelTransmitKnownTestCase : public TestCase class IslMockChannelTransmitKnownTestCase : public TestCase
@ -81,6 +80,7 @@ IslMockChannelTransmitKnownTestCase::DoRun (void)
srcNode->AggregateObject (loc); srcNode->AggregateObject (loc);
Ptr<MockNetDevice> srcDev = CreateObject<MockNetDevice> (); Ptr<MockNetDevice> srcDev = CreateObject<MockNetDevice> ();
srcDev->SetNode (srcNode); srcDev->SetNode (srcNode);
srcDev->SetAddress (Mac48Address::Allocate ());
int32_t srcId = channel->Attach (srcDev); int32_t srcId = channel->Attach (srcDev);
Ptr<Node> dstNode = CreateObject<Node> (); Ptr<Node> dstNode = CreateObject<Node> ();
@ -88,6 +88,7 @@ IslMockChannelTransmitKnownTestCase::DoRun (void)
dstNode->AggregateObject (loc); dstNode->AggregateObject (loc);
Ptr<MockNetDevice> dstDev = CreateObject<MockNetDevice> (); Ptr<MockNetDevice> dstDev = CreateObject<MockNetDevice> ();
dstDev->SetNode (dstNode); dstDev->SetNode (dstNode);
dstDev->SetAddress (Mac48Address::Allocate ());
channel->Attach (dstDev); channel->Attach (dstDev);
Address destAddr = dstDev->GetAddress (); Address destAddr = dstDev->GetAddress ();

72
test/leo-mock-channel-test-suite.cc
View file

@ -36,16 +36,13 @@ LeoMockChannelTransmitUnknownTestCase::DoRun (void)
Ptr<LeoMockChannel> channel = CreateObject<LeoMockChannel> (); Ptr<LeoMockChannel> channel = CreateObject<LeoMockChannel> ();
Packet *packet = new Packet (); Packet *packet = new Packet ();
Ptr<Packet> p = Ptr<Packet>(packet); Ptr<Packet> p = Ptr<Packet>(packet);
Ptr<LeoMockNetDevice> dev = CreateObject<LeoMockNetDevice> ();
dev->SetDeviceType (LeoMockNetDevice::GND);
int32_t srcId = channel->Attach (dev);
Address destAddr; Address destAddr;
Time txTime; Time txTime;
channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel")); channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel"));
channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel")); channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel"));
bool result = channel->TransmitStart (p, srcId, destAddr, txTime); bool result = channel->TransmitStart (p, 10000, destAddr, txTime);
NS_TEST_ASSERT_MSG_EQ (result, false, "Unknown destination fails to deliver"); NS_TEST_ASSERT_MSG_EQ (result, false, "Unknown source fails to deliver");
} }
class LeoMockChannelTransmitKnownTestCase : public TestCase class LeoMockChannelTransmitKnownTestCase : public TestCase
@ -78,28 +75,24 @@ LeoMockChannelTransmitKnownTestCase::DoRun (void)
Ptr<Packet> p = Ptr<Packet>(packet); Ptr<Packet> p = Ptr<Packet>(packet);
Ptr<Node> srcNode = CreateObject<Node> (); Ptr<Node> srcNode = CreateObject<Node> ();
Ptr<ConstantPositionMobilityModel> loc = CreateObject<ConstantPositionMobilityModel> ();
srcNode->AggregateObject (loc);
Ptr<LeoMockNetDevice> srcDev = CreateObject<LeoMockNetDevice> (); Ptr<LeoMockNetDevice> srcDev = CreateObject<LeoMockNetDevice> ();
srcDev->SetNode (srcNode); srcDev->SetNode (srcNode);
srcDev->SetAttribute ("MobilityModel", StringValue ("ns3::ConstantPositionMobilityModel"));
srcDev->SetDeviceType (LeoMockNetDevice::GND); srcDev->SetDeviceType (LeoMockNetDevice::GND);
srcDev->SetAddress (Mac48Address::Allocate ());
int32_t srcId = channel->Attach (srcDev); int32_t srcId = channel->Attach (srcDev);
Ptr<Node> dstNode = CreateObject<Node> (); Ptr<Node> dstNode = CreateObject<Node> ();
loc = CreateObject<ConstantPositionMobilityModel> ();
dstNode->AggregateObject (loc);
Ptr<LeoMockNetDevice> dstDev = CreateObject<LeoMockNetDevice> (); Ptr<LeoMockNetDevice> dstDev = CreateObject<LeoMockNetDevice> ();
dstDev->SetNode (dstNode); dstDev->SetNode (dstNode);
dstDev->SetAttribute ("MobilityModel", StringValue ("ns3::WaypointMobilityModel"));
dstDev->SetDeviceType (LeoMockNetDevice::SAT); dstDev->SetDeviceType (LeoMockNetDevice::SAT);
dstDev->SetAddress (Mac48Address::Allocate ());
channel->Attach (dstDev); channel->Attach (dstDev);
Address destAddr = dstDev->GetAddress (); Address destAddr = dstDev->GetAddress ();
Time txTime; Time txTime;
bool result = channel->TransmitStart (p, srcId, destAddr, txTime); bool result = channel->TransmitStart (p, srcId, destAddr, txTime);
NS_TEST_ASSERT_MSG_EQ (result, true, "Known destination delivers"); NS_TEST_ASSERT_MSG_EQ (result, true, "Known source delivers");
} }
class LeoMockChannelTransmitSpaceGroundTestCase : public TestCase class LeoMockChannelTransmitSpaceGroundTestCase : public TestCase
@ -134,15 +127,15 @@ LeoMockChannelTransmitSpaceGroundTestCase::DoRun (void)
Ptr<Node> srcNode = CreateObject<Node> (); Ptr<Node> srcNode = CreateObject<Node> ();
Ptr<LeoMockNetDevice> srcDev = CreateObject<LeoMockNetDevice> (); Ptr<LeoMockNetDevice> srcDev = CreateObject<LeoMockNetDevice> ();
srcDev->SetNode (srcNode); srcDev->SetNode (srcNode);
srcDev->SetAttribute ("MobilityModel", StringValue ("ns3::WaypointMobilityModel"));
srcDev->SetDeviceType (LeoMockNetDevice::SAT); srcDev->SetDeviceType (LeoMockNetDevice::SAT);
srcDev->SetAddress (Mac48Address::Allocate ());
int32_t srcId = channel->Attach (srcDev); int32_t srcId = channel->Attach (srcDev);
Ptr<Node> dstNode = CreateObject<Node> (); Ptr<Node> dstNode = CreateObject<Node> ();
Ptr<LeoMockNetDevice> dstDev = CreateObject<LeoMockNetDevice> (); Ptr<LeoMockNetDevice> dstDev = CreateObject<LeoMockNetDevice> ();
dstDev->SetNode (dstNode); dstDev->SetNode (dstNode);
dstDev->SetAttribute ("MobilityModel", StringValue ("ns3::ConstantPositionMobilityModel"));
dstDev->SetDeviceType (LeoMockNetDevice::GND); dstDev->SetDeviceType (LeoMockNetDevice::GND);
dstDev->SetAddress (Mac48Address::Allocate ());
channel->Attach (dstDev); channel->Attach (dstDev);
Address destAddr = dstDev->GetAddress (); Address destAddr = dstDev->GetAddress ();
@ -152,56 +145,6 @@ LeoMockChannelTransmitSpaceGroundTestCase::DoRun (void)
NS_TEST_ASSERT_MSG_EQ (result, true, "Space to ground destination delivers"); NS_TEST_ASSERT_MSG_EQ (result, true, "Space to ground destination delivers");
} }
class LeoMockChannelTransmitSpaceSpaceTestCase : public TestCase
{
public:
LeoMockChannelTransmitSpaceSpaceTestCase ();
virtual ~LeoMockChannelTransmitSpaceSpaceTestCase ();
private:
virtual void DoRun (void);
};
LeoMockChannelTransmitSpaceSpaceTestCase::LeoMockChannelTransmitSpaceSpaceTestCase ()
: TestCase ("Test transmission to known destination")
{
}
LeoMockChannelTransmitSpaceSpaceTestCase::~LeoMockChannelTransmitSpaceSpaceTestCase ()
{
}
void
LeoMockChannelTransmitSpaceSpaceTestCase::DoRun (void)
{
Ptr<LeoMockChannel> channel = CreateObject<LeoMockChannel> ();
channel->SetAttribute ("PropagationDelay", StringValue ("ns3::ConstantSpeedPropagationDelayModel"));
channel->SetAttribute ("PropagationLoss", StringValue ("ns3::LeoPropagationLossModel"));
Packet *packet = new Packet ();
Ptr<Packet> p = Ptr<Packet>(packet);
Ptr<Node> srcNode = CreateObject<Node> ();
Ptr<LeoMockNetDevice> srcDev = CreateObject<LeoMockNetDevice> ();
srcDev->SetNode (srcNode);
srcDev->SetAttribute ("MobilityModel", StringValue ("ns3::WaypointMobilityModel"));
srcDev->SetDeviceType (LeoMockNetDevice::SAT);
int32_t srcId = channel->Attach (srcDev);
Ptr<Node> dstNode = CreateObject<Node> ();
Ptr<LeoMockNetDevice> dstDev = CreateObject<LeoMockNetDevice> ();
dstDev->SetNode (dstNode);
dstDev->SetAttribute ("MobilityModel", StringValue ("ns3::WaypointMobilityModel"));
dstDev->SetDeviceType (LeoMockNetDevice::SAT);
channel->Attach (dstDev);
Address destAddr = dstDev->GetAddress ();
Time txTime;
bool result = channel->TransmitStart (p, srcId, destAddr, txTime);
NS_TEST_ASSERT_MSG_EQ (result, false, "Space to space gets dropped");
}
class LeoMockChannelTestSuite : public TestSuite class LeoMockChannelTestSuite : public TestSuite
{ {
public: public:
@ -215,7 +158,6 @@ LeoMockChannelTestSuite::LeoMockChannelTestSuite ()
AddTestCase (new LeoMockChannelTransmitUnknownTestCase, TestCase::QUICK); AddTestCase (new LeoMockChannelTransmitUnknownTestCase, TestCase::QUICK);
AddTestCase (new LeoMockChannelTransmitKnownTestCase, TestCase::QUICK); AddTestCase (new LeoMockChannelTransmitKnownTestCase, TestCase::QUICK);
AddTestCase (new LeoMockChannelTransmitSpaceGroundTestCase, TestCase::QUICK); AddTestCase (new LeoMockChannelTransmitSpaceGroundTestCase, TestCase::QUICK);
AddTestCase (new LeoMockChannelTransmitSpaceSpaceTestCase, TestCase::QUICK);
} }
// Do not forget to allocate an instance of this TestSuite // Do not forget to allocate an instance of this TestSuite