F5/unison
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

doxygen: Fix documentation of traffic-control tests

Browse Source
This commit is contained in:
Robert Ammon
2017-02-16 15:32:20 +01:00
parent ba433f9a20
commit edfd090ff8
4 changed files with 262 additions and 18 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src/traffic-control/test/adaptive-red-queue-disc-test-suite.cc
View File

@@ -30,8 +30,27 @@
using namespace ns3;
/**
* \ingroup traffic-control-test
* \defgroup traffic-control-test traffic-control module tests
*/
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Ared Queue Disc Test Item
*/
class AredQueueDiscTestItem : public QueueDiscItem {
public:
/**
* Constructor
*
* \param p packet
* \param addr address
* \param protocol protocol
*/
AredQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol);
virtual ~AredQueueDiscTestItem ();
virtual void AddHeader (void);
@@ -39,7 +58,9 @@ public:
private:
AredQueueDiscTestItem ();
/// copy constructor
AredQueueDiscTestItem (const AredQueueDiscTestItem &);
/// assignment operator
AredQueueDiscTestItem &operator = (const AredQueueDiscTestItem &);
};
@@ -63,15 +84,36 @@ AredQueueDiscTestItem::Mark (void)
return false;
}
// Tests to verify the working of ARED
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Ared Queue Disc Test Case
*/
class AredQueueDiscTestCase : public TestCase
{
public:
AredQueueDiscTestCase ();
virtual void DoRun (void);
private:
/**
* Enqueue function
* \param queue the queue disc
* \param size the size
* \param nPkt the number of packets
*/
void Enqueue (Ptr<RedQueueDisc> queue, uint32_t size, uint32_t nPkt);
/**
* Enqueue with delay function
* \param queue the queue disc
* \param size the size
* \param nPkt the number of packets
*/
void EnqueueWithDelay (Ptr<RedQueueDisc> queue, uint32_t size, uint32_t nPkt);
/**
* Run ARED queue disc test function
* \param mode the test mode
*/
void RunAredDiscTest (StringValue mode);
};
@@ -323,6 +365,12 @@ AredQueueDiscTestCase::DoRun (void)
Simulator::Destroy ();
}
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Ared Queue Disc Test Suite
*/
static class AredQueueDiscTestSuite : public TestSuite
{
public:
@@ -331,4 +379,4 @@ public:
{
AddTestCase (new AredQueueDiscTestCase (), TestCase::QUICK);
}
} g_aredQueueDiscTestSuite;
} g_aredQueueDiscTestSuite; ///< the test suite

129
src/traffic-control/test/codel-queue-disc-test-suite.cc
View File

@@ -53,9 +53,21 @@ static uint32_t _reciprocal_scale (uint32_t val, uint32_t ep_ro)
}
// End Linux borrow
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Codel Queue Disc Test Item
*/
class CodelQueueDiscTestItem : public QueueDiscItem {
public:
/**
* Constructor
*
* \param p packet
* \param addr address
* \param protocol
*/
CodelQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol);
virtual ~CodelQueueDiscTestItem ();
virtual void AddHeader (void);
@@ -63,7 +75,9 @@ public:
private:
CodelQueueDiscTestItem ();
/// copy constructor
CodelQueueDiscTestItem (const CodelQueueDiscTestItem &);
/// assignment operator
CodelQueueDiscTestItem &operator = (const CodelQueueDiscTestItem &);
};
@@ -87,13 +101,29 @@ CodelQueueDiscTestItem::Mark (void)
return false;
}
// Test 1: simple enqueue/dequeue with no drops
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Test 1: simple enqueue/dequeue with no drops
*/
class CoDelQueueDiscBasicEnqueueDequeue : public TestCase
{
public:
/**
* Constructor
*
* \param mode the mode
*/
CoDelQueueDiscBasicEnqueueDequeue (std::string mode);
virtual void DoRun (void);
/**
* Queue test size function
* \param queue the queue disc
* \param size the size
* \param error the error string
*/
void QueueTestSize (Ptr<CoDelQueueDisc> queue, uint32_t size, std::string error)
{
if (queue->GetMode () == Queue::QUEUE_MODE_BYTES)
@@ -109,7 +139,7 @@ public:
}
private:
StringValue m_mode;
StringValue m_mode; ///< mode
};
CoDelQueueDiscBasicEnqueueDequeue::CoDelQueueDiscBasicEnqueueDequeue (std::string mode)
@@ -213,13 +243,29 @@ CoDelQueueDiscBasicEnqueueDequeue::DoRun (void)
NS_TEST_EXPECT_MSG_EQ (queue->GetDropCount (), 0, "There should be no packet drops according to CoDel algorithm");
}
// Test 2: enqueue with drops due to queue overflow
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Test 2: enqueue with drops due to queue overflow
*/
class CoDelQueueDiscBasicOverflow : public TestCase
{
public:
/**
* Constructor
*
* \param mode the mode
*/
CoDelQueueDiscBasicOverflow (std::string mode);
virtual void DoRun (void);
/**
* Queue test size function
* \param queue the queue disc
* \param size the size
* \param error the error string
*/
void QueueTestSize (Ptr<CoDelQueueDisc> queue, uint32_t size, std::string error)
{
if (queue->GetMode () == Queue::QUEUE_MODE_BYTES)
@@ -235,8 +281,14 @@ public:
}
private:
/**
* Enqueue function
* \param queue the queue disc
* \param size the size
* \param nPkt the number of packets
*/
void Enqueue (Ptr<CoDelQueueDisc> queue, uint32_t size, uint32_t nPkt);
StringValue m_mode;
StringValue m_mode; ///< mode
};
CoDelQueueDiscBasicOverflow::CoDelQueueDiscBasicOverflow (std::string mode)
@@ -299,8 +351,12 @@ CoDelQueueDiscBasicOverflow::Enqueue (Ptr<CoDelQueueDisc> queue, uint32_t size,
}
}
// Test 3: NewtonStep unit test
// test against explicit port of Linux implementation
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Test 3: NewtonStep unit test - test against explicit port of Linux implementation
*/
class CoDelQueueDiscNewtonStepTest : public TestCase
{
public:
@@ -339,13 +395,23 @@ CoDelQueueDiscNewtonStepTest::DoRun (void)
"ns-3 NewtonStep() fails to match Linux equivalent");
}
// Test 4: ControlLaw unit test
// test against explicit port of Linux implementation
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Test 4: ControlLaw unit test - test against explicit port of Linux implementation
*/
class CoDelQueueDiscControlLawTest : public TestCase
{
public:
CoDelQueueDiscControlLawTest ();
virtual void DoRun (void);
/**
* Codel control law function
* \param queue the queue disc
* \param t
* \returns the codel control law
*/
uint32_t _codel_control_law (Ptr<CoDelQueueDisc> queue, uint32_t t);
};
@@ -385,13 +451,29 @@ CoDelQueueDiscControlLawTest::DoRun (void)
}
}
// Test 5: enqueue/dequeue with drops according to CoDel algorithm
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Test 5: enqueue/dequeue with drops according to CoDel algorithm
*/
class CoDelQueueDiscBasicDrop : public TestCase
{
public:
/**
* Constructor
*
* \param mode the mode
*/
CoDelQueueDiscBasicDrop (std::string mode);
virtual void DoRun (void);
/**
* Queue test size function
* \param queue the queue disc
* \param size the size
* \param error the error string
*/
void QueueTestSize (Ptr<CoDelQueueDisc> queue, uint32_t size, std::string error)
{
if (queue->GetMode () == Queue::QUEUE_MODE_BYTES)
@@ -407,11 +489,26 @@ public:
}
private:
/**
* Enqueue function
* \param queue the queue disc
* \param size the size
* \param nPkt the number of packets
*/
void Enqueue (Ptr<CoDelQueueDisc> queue, uint32_t size, uint32_t nPkt);
/** Dequeue function
* \param queue the queue disc
* \param modeSize the mode size
*/
void Dequeue (Ptr<CoDelQueueDisc> queue, uint32_t modeSize);
/**
* Drop next tracer function
* \param oldVal the old value
* \param newVal the new value
*/
void DropNextTracer (uint32_t oldVal, uint32_t newVal);
StringValue m_mode;
uint32_t m_dropNextCount; //count the number of times m_dropNext is recalculated
StringValue m_mode; ///< mode
uint32_t m_dropNextCount; ///< count the number of times m_dropNext is recalculated
};
CoDelQueueDiscBasicDrop::CoDelQueueDiscBasicDrop (std::string mode)
@@ -543,6 +640,12 @@ CoDelQueueDiscBasicDrop::Dequeue (Ptr<CoDelQueueDisc> queue, uint32_t modeSize)
}
}
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief CoDel Queue Disc Test Suite
*/
static class CoDelQueueDiscTestSuite : public TestSuite
{
public:
@@ -563,4 +666,4 @@ public:
AddTestCase (new CoDelQueueDiscBasicDrop ("QUEUE_MODE_PACKETS"), TestCase::QUICK);
AddTestCase (new CoDelQueueDiscBasicDrop ("QUEUE_MODE_BYTES"), TestCase::QUICK);
}
} g_coDelQueueTestSuite;
} g_coDelQueueTestSuite; ///< the test suite

56
src/traffic-control/test/pie-queue-disc-test-suite.cc
View File

@@ -31,9 +31,22 @@
using namespace ns3;
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Pie Queue Disc Test Item
*/
class PieQueueDiscTestItem : public QueueDiscItem
{
public:
/**
* Constructor
*
* \param p the packet
* \param addr the address
* \param protocol the protocol
*/
PieQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol);
virtual ~PieQueueDiscTestItem ();
virtual void AddHeader (void);
@@ -41,7 +54,9 @@ public:
private:
PieQueueDiscTestItem ();
/// copy constructor
PieQueueDiscTestItem (const PieQueueDiscTestItem &);
/// assignment operator
PieQueueDiscTestItem &operator = (const PieQueueDiscTestItem &);
};
@@ -65,16 +80,49 @@ PieQueueDiscTestItem::Mark (void)
return false;
}
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Pie Queue Disc Test Case
*/
class PieQueueDiscTestCase : public TestCase
{
public:
PieQueueDiscTestCase ();
virtual void DoRun (void);
private:
/**
* Enqueue function
* \param queue the queue disc
* \param size the size
* \param nPkt the number of packets
*/
void Enqueue (Ptr<PieQueueDisc> queue, uint32_t size, uint32_t nPkt);
/**
* Enqueue with delay function
* \param queue the queue disc
* \param size the size
* \param nPkt the number of packets
*/
void EnqueueWithDelay (Ptr<PieQueueDisc> queue, uint32_t size, uint32_t nPkt);
/**
* Dequeue function
* \param queue the queue disc
* \param nPkt the number of packets
*/
void Dequeue (Ptr<PieQueueDisc> queue, uint32_t nPkt);
/**
* Dequeue with delay function
* \param queue the queue disc
* \param delay the delay
* \param nPkt the number of packets
*/
void DequeueWithDelay (Ptr<PieQueueDisc> queue, double delay, uint32_t nPkt);
/**
* Run test function
* \param mode the test mode
*/
void RunPieTest (StringValue mode);
};
@@ -335,6 +383,12 @@ PieQueueDiscTestCase::DoRun (void)
Simulator::Destroy ();
}
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Pie Queue Disc Test Suite
*/
static class PieQueueDiscTestSuite : public TestSuite
{
public:
@@ -343,4 +397,4 @@ public:
{
AddTestCase (new PieQueueDiscTestCase (), TestCase::QUICK);
}
} g_pieQueueTestSuite;
} g_pieQueueTestSuite; ///< the test suite

43
src/traffic-control/test/red-queue-disc-test-suite.cc
View File

@@ -31,8 +31,22 @@
using namespace ns3;
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Red Queue Disc Test Item
*/
class RedQueueDiscTestItem : public QueueDiscItem {
public:
/**
* Constructor
*
* \param p packet
* \param addr address
* \param protocol protocol
* \param ecnCapable ECN capable flag
*/
RedQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol, bool ecnCapable);
virtual ~RedQueueDiscTestItem ();
virtual void AddHeader (void);
@@ -40,9 +54,11 @@ public:
private:
RedQueueDiscTestItem ();
/// copy constructor
RedQueueDiscTestItem (const RedQueueDiscTestItem &);
/// assignment operator
RedQueueDiscTestItem &operator = (const RedQueueDiscTestItem &);
bool m_ecnCapablePacket;
bool m_ecnCapablePacket; ///< ECN capable packet?
};
RedQueueDiscTestItem::RedQueueDiscTestItem (Ptr<Packet> p, const Address & addr, uint16_t protocol, bool ecnCapable)
@@ -70,13 +86,30 @@ RedQueueDiscTestItem::Mark (void)
return false;
}
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Red Queue Disc Test Case
*/
class RedQueueDiscTestCase : public TestCase
{
public:
RedQueueDiscTestCase ();
virtual void DoRun (void);
private:
/**
* Enqueue function
* \param queue the queue disc
* \param size the size
* \param nPkt the number of packets
* \param ecnCapable ECN capable flag
*/
void Enqueue (Ptr<RedQueueDisc> queue, uint32_t size, uint32_t nPkt, bool ecnCapable);
/**
* Run RED test function
* \param mode the mode
*/
void RunRedTest (StringValue mode);
};
@@ -402,6 +435,12 @@ RedQueueDiscTestCase::DoRun (void)
}
/**
* \ingroup traffic-control-test
* \ingroup tests
*
* \brief Red Queue Disc Test Suite
*/
static class RedQueueDiscTestSuite : public TestSuite
{
public:
@@ -410,4 +449,4 @@ public:
{
AddTestCase (new RedQueueDiscTestCase (), TestCase::QUICK);
}
} g_redQueueTestSuite;
} g_redQueueTestSuite; ///< the test suite