TORC: torc/physical/NetUnitTest.cpp Source File

00001 // Torc - Copyright 2011 University of Southern California.  All Rights Reserved.
00002 // $HeadURL: https://torc-isi.svn.sourceforge.net/svnroot/torc-isi/branches/staging/0.9/src/torc/physical/NetUnitTest.cpp $
00003 // $Id: NetUnitTest.cpp 10 2011-10-12 18:40:16Z nsteiner $
00004 
00005 // This program is free software: you can redistribute it and/or modify it under the terms of the 
00006 // GNU General Public License as published by the Free Software Foundation, either version 3 of the 
00007 // License, or (at your option) any later version.
00008 // 
00009 // This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
00010 // without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See 
00011 // the GNU General Public License for more details.
00012 // 
00013 // You should have received a copy of the GNU General Public License along with this program.  If 
00014 // not, see <http://www.gnu.org/licenses/>.
00015 
00016 /// \file
00017 /// \brief Unit test for the Net class.
00018 
00019 #include <boost/test/unit_test.hpp>
00020 #include "torc/physical/Factory.hpp"
00021 #include "torc/physical/Net.hpp"
00022 
00023 namespace torc {
00024 namespace physical {
00025 
00026 BOOST_AUTO_TEST_SUITE(physical)
00027 
00028 /// \brief Unit test for the Net class.
00029 BOOST_AUTO_TEST_CASE(NetUnitTest) {
00030     // accessory instance and pins
00031     std::string name = "name";
00032     // create accessory instance, pins, and pips
00033     InstanceSharedPtr instancePtr = Factory::newInstancePtr("name", "type", "tile", "site");
00034     InstancePinSharedPtr pin1Ptr = Factory::newInstancePinPtr(instancePtr, "pin1");
00035     InstancePinSharedPtr pin2Ptr = Factory::newInstancePinPtr(instancePtr, "pin2");
00036     InstancePinSharedPtr pin3Ptr = Factory::newInstancePinPtr(instancePtr, "pin3");
00037     InstancePinSharedPtr pin4Ptr = Factory::newInstancePinPtr(instancePtr, "pin4");
00038     Pip pip1 = Factory::newPip("tile", "source1", "sink1", ePipUnidirectionalBuffered);
00039     Pip pip2 = Factory::newPip("tile", "source2", "sink2", ePipUnidirectionalBuffered);
00040     Pip pip3 = Factory::newPip("tile", "source3", "sink3", ePipUnidirectionalBuffered);
00041 
00042     // functions tested:
00043     //      Net(const string& inName, ENetType inNetType);
00044     ENetType normal = eNetTypeNormal;
00045     ENetType power = eNetTypePower;
00046     ENetType ground = eNetTypeGround;
00047     NetSharedPtr net1Ptr = Factory::newNetPtr(name);
00048     NetSharedPtr net2Ptr = Factory::newNetPtr(name, power);
00049     BOOST_REQUIRE(net1Ptr != 0);
00050     BOOST_REQUIRE(net2Ptr != 0);
00051 
00052     // functions tested:
00053     //      ENetType getNetType(void) const;
00054     //      void setNetType(ENetType inNetType);
00055     BOOST_CHECK(net1Ptr->getNetType() == normal);
00056     BOOST_CHECK(net2Ptr->getNetType() == power);
00057     net2Ptr->setNetType(ground);
00058     BOOST_CHECK(net2Ptr->getNetType() == ground);
00059 
00060     // functions tested:
00061     //      void addSource(const InstancePin& inInstancePin);
00062     //      void addSink(const InstancePin& inInstancePin);
00063     //      bool containsSource(const InstancePin& inInstancePin) const;
00064     //      bool containsSink(const InstancePin& inInstancePin) const;
00065     //      bool hasAnySources(void) const;
00066     //      bool hasOneSource(void) const;
00067     //      bool hasMultipleSources(void) const;
00068     //      size_t getSourceCount(void) const;
00069     //      bool hasAnySinks(void) const;
00070     //      bool hasOneSink(void) const;
00071     //      bool hasMultipleSinks(void) const;
00072     //      size_t getSinkCount(void) const;
00073     net1Ptr->addSource(pin1Ptr);
00074     net1Ptr->addSink(pin2Ptr);
00075     net1Ptr->addSink(pin3Ptr);
00076     net1Ptr->addSink(pin4Ptr);
00077     BOOST_CHECK_EQUAL(net1Ptr->containsSource(pin1Ptr), true);
00078     BOOST_CHECK_EQUAL(net1Ptr->containsSink(pin1Ptr), false);
00079     BOOST_CHECK_EQUAL(net1Ptr->containsSink(pin2Ptr), true);
00080     BOOST_CHECK_EQUAL(net1Ptr->containsSink(pin3Ptr), true);
00081     BOOST_CHECK_EQUAL(net1Ptr->containsSink(pin4Ptr), true);
00082     BOOST_CHECK_EQUAL(net1Ptr->hasAnySources(), true);
00083     BOOST_CHECK_EQUAL(net1Ptr->hasOneSource(), true);
00084     BOOST_CHECK_EQUAL(net1Ptr->hasMultipleSources(), false);
00085     BOOST_CHECK(net1Ptr->getSourceCount() == 1);
00086     BOOST_CHECK_EQUAL(net1Ptr->hasAnySinks(), true);
00087     BOOST_CHECK_EQUAL(net1Ptr->hasOneSink(), false);
00088     BOOST_CHECK_EQUAL(net1Ptr->hasMultipleSinks(), true);
00089     BOOST_CHECK(net1Ptr->getSinkCount() == 3);
00090 
00091     // functions tested:
00092     //      bool removeSource(const InstancePin& inInstancePin);
00093     //      bool removeSink(const InstancePin& inInstancePin);
00094     //      InstancePinConstIterator sourcesBegin(void) const;
00095     //      InstancePinConstIterator sourcesEnd(void) const;
00096     //      InstancePinConstIterator sinksBegin(void) const;
00097     //      InstancePinConstIterator sinksEnd(void) const;
00098     Net::InstancePinSharedPtrConstIterator op = net1Ptr->sourcesBegin();
00099     Net::InstancePinSharedPtrConstIterator oe = net1Ptr->sourcesEnd();
00100     BOOST_CHECK(*op++ == pin1Ptr);
00101     BOOST_CHECK(op == oe);
00102     BOOST_CHECK_EQUAL(net1Ptr->removeSource(pin1Ptr), true);
00103     BOOST_CHECK_EQUAL(net1Ptr->removeSource(pin2Ptr), false);
00104     BOOST_CHECK(net1Ptr->getSourceCount() == 0);
00105     Net::InstancePinSharedPtrConstIterator ip = net1Ptr->sinksBegin();
00106     Net::InstancePinSharedPtrConstIterator ie = net1Ptr->sinksEnd();
00107     BOOST_CHECK(*ip++ == pin2Ptr);
00108     BOOST_CHECK(*ip++ == pin3Ptr);
00109     BOOST_CHECK(*ip++ == pin4Ptr);
00110     BOOST_CHECK(ip == ie);
00111     BOOST_CHECK_EQUAL(net1Ptr->removeSink(pin1Ptr), false);
00112     BOOST_CHECK_EQUAL(net1Ptr->removeSink(pin2Ptr), true);
00113     BOOST_CHECK_EQUAL(net1Ptr->removeSink(pin3Ptr), true);
00114     BOOST_CHECK_EQUAL(net1Ptr->removeSink(pin4Ptr), true);
00115     BOOST_CHECK(net1Ptr->getSinkCount() == 0);
00116 
00117     // functions tested:
00118     //      void addPip(const Pip& inPip);
00119     //      bool containsPip(const Pip& inPip) const;
00120     //      bool hasAnyPips(void) const;
00121     //      size_t getPipCount(void) const;
00122     //      bool isRouted(void) const;
00123     //      bool isUnrouted(void) const;
00124     net1Ptr->addPip(pip1);
00125     net1Ptr->addPip(pip2);
00126     net1Ptr->addPip(pip3);
00127     BOOST_CHECK_EQUAL(net1Ptr->containsPip(pip1), true);
00128     BOOST_CHECK_EQUAL(net1Ptr->containsPip(pip2), true);
00129     BOOST_CHECK_EQUAL(net1Ptr->containsPip(pip3), true);
00130     BOOST_CHECK_EQUAL(net1Ptr->hasAnyPips(), true);
00131     BOOST_CHECK_EQUAL(net1Ptr->isRouted(), true);
00132     BOOST_CHECK_EQUAL(net1Ptr->isUnrouted(), false);
00133     BOOST_CHECK(net1Ptr->getPipCount() == 3);
00134 
00135     // functions tested:
00136     //      bool removePip(const Pip& inPip);
00137     //      void unroute(void);
00138     //      PipConstIterator pipsBegin(void) const;
00139     //      PipConstIterator pipsEnd(void) const;
00140     //      size_t getPipCount(void) const;
00141     //      bool isRouted(void) const;
00142     //      bool isUnrouted(void) const;
00143     Net::PipConstIterator pp = net1Ptr->pipsBegin();
00144     Net::PipConstIterator pe = net1Ptr->pipsEnd();
00145     BOOST_CHECK(*pp++ == pip1);
00146     BOOST_CHECK(*pp++ == pip2);
00147     BOOST_CHECK(*pp++ == pip3);
00148     BOOST_CHECK(pp == pe);
00149     BOOST_CHECK_EQUAL(net1Ptr->removePip(pip1), true);
00150     BOOST_CHECK_EQUAL(net1Ptr->removePip(pip1), false);
00151     BOOST_CHECK_EQUAL(net1Ptr->isRouted(), true);
00152     BOOST_CHECK_EQUAL(net1Ptr->isUnrouted(), false);
00153     BOOST_CHECK(net1Ptr->getPipCount() == 2);
00154     net1Ptr->unroute();
00155     BOOST_CHECK_EQUAL(net1Ptr->isRouted(), false);
00156     BOOST_CHECK_EQUAL(net1Ptr->isUnrouted(), true);
00157     BOOST_CHECK(net1Ptr->getPipCount() == 0);
00158 }
00159 
00160 BOOST_AUTO_TEST_SUITE_END()
00161 
00162 } // namespace physical
00163 } // namespace torc