From edfd090ff894cdb27c640f191fc22adf6746f01c Mon Sep 17 00:00:00 2001 From: Robert Ammon Date: Thu, 16 Feb 2017 15:32:20 +0100 Subject: [PATCH] doxygen: Fix documentation of traffic-control tests --- .../adaptive-red-queue-disc-test-suite.cc | 52 ++++++- .../test/codel-queue-disc-test-suite.cc | 129 ++++++++++++++++-- .../test/pie-queue-disc-test-suite.cc | 56 +++++++- .../test/red-queue-disc-test-suite.cc | 43 +++++- 4 files changed, 262 insertions(+), 18 deletions(-) diff --git a/src/traffic-control/test/adaptive-red-queue-disc-test-suite.cc b/src/traffic-control/test/adaptive-red-queue-disc-test-suite.cc index 382e74afb..946edcae0 100644 --- a/src/traffic-control/test/adaptive-red-queue-disc-test-suite.cc +++ b/src/traffic-control/test/adaptive-red-queue-disc-test-suite.cc @@ -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 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 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 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 diff --git a/src/traffic-control/test/codel-queue-disc-test-suite.cc b/src/traffic-control/test/codel-queue-disc-test-suite.cc index cbaea8bf5..4161e72e6 100644 --- a/src/traffic-control/test/codel-queue-disc-test-suite.cc +++ b/src/traffic-control/test/codel-queue-disc-test-suite.cc @@ -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 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 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 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 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 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 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 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 queue, uint32_t size, uint32_t nPkt); + /** Dequeue function + * \param queue the queue disc + * \param modeSize the mode size + */ void Dequeue (Ptr 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 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 diff --git a/src/traffic-control/test/pie-queue-disc-test-suite.cc b/src/traffic-control/test/pie-queue-disc-test-suite.cc index 8806b8543..ef96efc48 100644 --- a/src/traffic-control/test/pie-queue-disc-test-suite.cc +++ b/src/traffic-control/test/pie-queue-disc-test-suite.cc @@ -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 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 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 queue, uint32_t size, uint32_t nPkt); + /** + * Dequeue function + * \param queue the queue disc + * \param nPkt the number of packets + */ void Dequeue (Ptr 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 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 diff --git a/src/traffic-control/test/red-queue-disc-test-suite.cc b/src/traffic-control/test/red-queue-disc-test-suite.cc index 3d0e669df..06ffb6039 100644 --- a/src/traffic-control/test/red-queue-disc-test-suite.cc +++ b/src/traffic-control/test/red-queue-disc-test-suite.cc @@ -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 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 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 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