TORC: torc/bitstream/Virtex6UnitTest.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/bitstream/Virtex6UnitTest.cpp $
00003 // $Id: Virtex6UnitTest.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 Virtex6 class.
00018 
00019 #include <boost/test/unit_test.hpp>
00020 #include "torc/bitstream/Virtex6.hpp"
00021 #include "torc/common/DirectoryTree.hpp"
00022 #include "torc/common/Devices.hpp"
00023 #include "torc/architecture/DDB.hpp"
00024 #include "torc/common/DeviceDesignator.hpp"
00025 #include "torc/bitstream/OutputStreamHelpers.hpp"
00026 #include "torc/bitstream/build/DeviceInfoHelper.hpp"
00027 #include "torc/common/TestHelpers.hpp"
00028 #include <fstream>
00029 #include <iostream>
00030 #include <boost/filesystem.hpp>
00031 
00032 namespace torc {
00033 namespace bitstream {
00034 
00035 BOOST_AUTO_TEST_SUITE(bitstream)
00036 
00037 /// \brief Unit test for the Virtex6 CRC
00038 BOOST_AUTO_TEST_CASE(Virtex6CrcUnitTest) {
00039     std::fstream fileStream("Virtex6UnitTest.reference.bit", std::ios::binary | std::ios::in);
00040     Virtex6 bitstream;
00041     bitstream.read(fileStream, false);
00042     std::cout << bitstream << std::endl;
00043     bitstream.preflightPackets();
00044     BOOST_REQUIRE(true);
00045 }
00046 
00047 /// \brief Unit test for the Virtex6 class.
00048 BOOST_AUTO_TEST_CASE(Virtex6UnitTest) {
00049 
00050     // enums tested:
00051     //      EPacket
00052     //      EFar
00053     boost::uint32_t mask;
00054     // type 1 packet subfield masks
00055     mask = Virtex6::ePacketMaskType + Virtex6::ePacketMaskOpcode 
00056         + Virtex6::ePacketMaskType1Address + Virtex6::ePacketMaskType1Reserved 
00057         + Virtex6::ePacketMaskType1Count;
00058     BOOST_CHECK_EQUAL(mask, 0xFFFFFFFFu);
00059     // type 2 packet subfield masks
00060     mask = Virtex6::ePacketMaskType + Virtex6::ePacketMaskOpcode 
00061         + Virtex6::ePacketMaskType2Count;
00062     BOOST_CHECK_EQUAL(mask, 0xFFFFFFFFu);
00063     // frame address register subfield masks
00064     mask = Virtex6::eFarMaskBlockType + Virtex6::eFarMaskTopBottom + Virtex6::eFarMaskRow 
00065         + Virtex6::eFarMaskMajor + Virtex6::eFarMaskMinor;
00066     BOOST_CHECK_EQUAL(mask, 0x00FFFFFFu);
00067 
00068     // members tested:
00069     //      Virtex6::sPacketTypeName and EPacketTypeName
00070     BOOST_CHECK_EQUAL(Virtex6::sPacketTypeName[0],                          "[UNKNOWN TYPE 0]");
00071     BOOST_CHECK_EQUAL(Virtex6::sPacketTypeName[Virtex6::ePacketType1],      "TYPE1");
00072     BOOST_CHECK_EQUAL(Virtex6::sPacketTypeName[Virtex6::ePacketType2],      "TYPE2");
00073     BOOST_CHECK_EQUAL(Virtex6::sPacketTypeName[3],                          "[UNKNOWN TYPE 3]");
00074     BOOST_CHECK_EQUAL(Virtex6::sPacketTypeName[4],                          "[UNKNOWN TYPE 4]");
00075     BOOST_CHECK_EQUAL(Virtex6::sPacketTypeName[5],                          "[UNKNOWN TYPE 5]");
00076     BOOST_CHECK_EQUAL(Virtex6::sPacketTypeName[6],                          "[UNKNOWN TYPE 6]");
00077     BOOST_CHECK_EQUAL(Virtex6::sPacketTypeName[7],                          "[UNKNOWN TYPE 7]");
00078 
00079     // members tested:
00080     //      Virtex6::sOpcodeName and EOpcode
00081     BOOST_CHECK_EQUAL(Virtex6::sOpcodeName[Virtex6::eOpcodeNOP],            "NOP");
00082     BOOST_CHECK_EQUAL(Virtex6::sOpcodeName[Virtex6::eOpcodeRead],           "READ");
00083     BOOST_CHECK_EQUAL(Virtex6::sOpcodeName[Virtex6::eOpcodeWrite],          "WRITE");
00084     BOOST_CHECK_EQUAL(Virtex6::sOpcodeName[Virtex6::eOpcodeReserved],       "RESERVED");
00085 
00086     // members tested:
00087     //      Virtex6::sRegisterName and ERegister
00088     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterCRC],        "CRC");
00089     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterFAR],        "FAR");
00090     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterFDRI],       "FDRI");
00091     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterFDRO],       "FDRO");
00092     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterCMD],        "CMD");
00093     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterCTL0],       "CTL0");
00094     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterMASK],       "MASK");
00095     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterSTAT],       "STAT");
00096     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterLOUT],       "LOUT");
00097     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterCOR0],       "COR0");
00098     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterMFWR],       "MFWR");
00099     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterCBC],        "CBC");
00100     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterIDCODE],     "IDCODE");
00101     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterAXSS],       "AXSS");
00102     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterCOR1],       "COR1");
00103     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterCSOB],       "CSOB");
00104     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterWBSTAR],     "WBSTAR");
00105     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterTIMER],      "TIMER");
00106     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterBOOTSTS],    "BOOTSTS");
00107     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterCTL1],       "CTL1");
00108     BOOST_CHECK_EQUAL(Virtex6::sRegisterName[Virtex6::eRegisterDWC],        "DWC");
00109 
00110     // members tested:
00111     //      Virtex6::sCommandName and ECommand
00112     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandNULL],         "NULL");
00113     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandWCFG],         "WCFG");
00114     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandMFW],          "MFW");
00115     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandLFRM],         "DGHIGH/LFRM");
00116     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandRCFG],         "RCFG");
00117     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandSTART],        "START");
00118     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandRCAP],         "RCAP");
00119     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandRCRC],         "RCRC");
00120     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandAGHIGH],       "AGHIGH");
00121     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandSWITCH],       "SWITCH");
00122     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandGRESTORE],     "GRESTORE");
00123     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandSHUTDOWN],     "SHUTDOWN");
00124     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandGCAPTURE],     "GCAPTURE");
00125     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandDESYNCH],      "DESYNCH");
00126     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandReserved],     "Reserved");
00127     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandIPROG],        "IPROG");
00128     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandCRCC],         "CRCC");
00129     BOOST_CHECK_EQUAL(Virtex6::sCommandName[Virtex6::eCommandLTIMER],       "LTIMER");
00130 
00131     // build the file paths
00132     boost::filesystem::path regressionPath 
00133         = torc::common::DirectoryTree::getExecutablePath() / "regression";
00134     boost::filesystem::path generatedPath = regressionPath / "Virtex6UnitTest.generated.bit";
00135     boost::filesystem::path referencePath = regressionPath / "Virtex6UnitTest.reference.bit";
00136 
00137     // read the bitstream
00138     std::fstream fileStream(referencePath.string().c_str(), std::ios::binary | std::ios::in);
00139     BOOST_REQUIRE(fileStream.good());
00140     Virtex6 bitstream;
00141     bitstream.read(fileStream, false);
00142     // write the bitstream digest to the console
00143     //std::cout << bitstream << std::endl;
00144 
00145     std::string designName = bitstream.getDesignName();
00146     std::string deviceName = bitstream.getDeviceName();
00147     std::string designDate = bitstream.getDesignDate();
00148     std::string designTime = bitstream.getDesignTime();
00149     torc::common::DeviceDesignator deviceDesignator(deviceName);
00150     //std::cout << "family of " << deviceName << " is " << deviceDesignator.getFamily() << std::endl;
00151 
00152     // write the bitstream back out
00153     std::fstream outputStream(generatedPath.string().c_str(), std::ios::binary | std::ios::out);
00154     BOOST_REQUIRE(outputStream.good());
00155     bitstream.write(outputStream);
00156     outputStream.flush();
00157 
00158     // compare the reference and generated XDL
00159     BOOST_CHECK(torc::common::fileContentsAreEqual(generatedPath, referencePath));
00160 }
00161 
00162 
00163 
00164 
00165 
00166 
00167 
00168 
00169 
00170 
00171 
00172 
00173 
00174 
00175 
00176 
00177 
00178 
00179 
00180 
00181 
00182 
00183 
00184 
00185 
00186 
00187 
00188 
00189 
00190 
00191 
00192 
00193 
00194 
00195 
00196 
00197 
00198 
00199 
00200 
00201 void testVirtex6Device(const std::string& inDeviceName, const boost::filesystem::path& inWorkingPath);
00202 
00203 /// \brief Unit test for the Virtex6 class Frame Address Register mapping.
00204 BOOST_AUTO_TEST_CASE(Virtex6FarUnitTest) {
00205 
00206     // look up the command line arguments
00207     int& argc = boost::unit_test::framework::master_test_suite().argc;
00208     char**& argv = boost::unit_test::framework::master_test_suite().argv;
00209     // make sure that we at least have the name under which we were invoked
00210     BOOST_REQUIRE(argc >= 1);
00211     // resolve symbolic links if applicable
00212     torc::common::DirectoryTree directoryTree(argv[0]);
00213 
00214     // iterate over the Virtex6 devices
00215     {
00216         const torc::common::DeviceVector& devices = torc::common::Devices::getVirtex6Devices();
00217         torc::common::DeviceVector::const_iterator dp = devices.begin();
00218         torc::common::DeviceVector::const_iterator de = devices.end();
00219         while(dp < de) {
00220             const std::string& device = *dp++;
00221             if(device.empty()) break;
00222     //std::cout << "device " << ": " << device << std::endl;
00223             testVirtex6Device(device, torc::common::DirectoryTree::getWorkingPath());
00224         }
00225     }
00226 
00227     // iterate over the Virtex6L devices
00228     {
00229         const torc::common::DeviceVector& devices = torc::common::Devices::getVirtex6LDevices();
00230         torc::common::DeviceVector::const_iterator dp = devices.begin();
00231         torc::common::DeviceVector::const_iterator de = devices.end();
00232         while(dp < de) {
00233             const std::string& device = *dp++;
00234             if(device.empty()) break;
00235     //std::cout << "device " << ": " << device << std::endl;
00236             testVirtex6Device(device, torc::common::DirectoryTree::getWorkingPath());
00237         }
00238     }
00239 }
00240 
00241 /*
00242     class TileTypeWidths {
00243     public:
00244         uint32_t mWidth[8];
00245         TileTypeWidths(uint32_t in0 = 0, uint32_t in1 = 0, uint32_t in2 = 0, uint32_t in3 = 0, 
00246             uint32_t in4 = 0, uint32_t in5 = 0, uint32_t in6 = 0, uint32_t in7 = 0) {
00247             int i = 0;
00248             mWidth[i++] = in0; mWidth[i++] = in1; mWidth[i++] = in2; mWidth[i++] = in3;
00249             mWidth[i++] = in4; mWidth[i++] = in5; mWidth[i++] = in6; mWidth[i++] = in7;
00250         }
00251         void clear(void) { for(int i = 0; i < 8; i++) mWidth[i] = 0; }
00252         uint32_t operator[] (int inIndex) const { return mWidth[inIndex]; }
00253     };
00254 */
00255 
00256     std::ostream& operator<< (std::ostream& os, const Virtex6::FrameAddress& rhs);
00257     std::ostream& operator<< (std::ostream& os, const Virtex6::FrameAddress& rhs) {
00258         return os << (rhs.mTopBottom == Virtex6::eFarTop ? 'T' : 'B') << "" << rhs.mBlockType 
00259                 << "(" << rhs.mRow << "," << rhs.mMajor << "." << rhs.mMinor << ")";
00260     }
00261 
00262 void testVirtex6Device(const std::string& inDeviceName, const boost::filesystem::path& inWorkingPath) {
00263 
00264     // build the file paths
00265     boost::filesystem::path debugBitstreamPath = inWorkingPath / "torc" / "bitstream" / "regression";
00266     //boost::filesystem::path generatedPath = debugBitstreamPath / (inDeviceName + ".debug.bit");
00267     boost::filesystem::path referencePath = debugBitstreamPath / (inDeviceName + ".debug.bit");
00268 
00269     // read the bitstream
00270     std::fstream fileStream(referencePath.string().c_str(), std::ios::binary | std::ios::in);
00271     std::cerr << "Trying to read: " << referencePath << std::endl;
00272     BOOST_REQUIRE(fileStream.good());
00273     Virtex6 bitstream;
00274     bitstream.read(fileStream, false);
00275     // write the bitstream digest to the console
00276 //  std::cout << bitstream << std::endl;
00277 
00278 //  // initialize the bitstream frame maps
00279 //  boost::filesystem::path deviceColumnsPath = inWorkingPath / "torc" / "bitstream" / "regression" 
00280 //      / (inDeviceName + ".cpp");
00281 //  std::fstream deviceColumnsStream(deviceColumnsPath.string().c_str(), std::ios::out);
00282     bitstream.initializeDeviceInfo(inDeviceName);
00283     bitstream.initializeFrameMaps();
00284 
00285     // iterate through the packets, and extract all of the FARs
00286     Virtex6::FrameAddressToIndex farRemaining = bitstream.mFrameAddressToIndex;
00287     Virtex6::FrameAddressToIndex farVisited;
00288     {
00289         bool first = true;
00290         Virtex6::const_iterator p = bitstream.begin();
00291         Virtex6::const_iterator e = bitstream.end();
00292         uint32_t header = VirtexPacket::makeHeader(VirtexPacket::ePacketType1, 
00293             VirtexPacket::eOpcodeWrite, Virtex6::eRegisterLOUT, 1);
00294         while(p < e) {
00295             const VirtexPacket& packet = *p++;
00296             if(packet.getHeader() != header) continue;
00297             if(first) { first = false; continue; }
00298             Virtex6::FrameAddress far = packet[1];
00299             farVisited[far] = 0;
00300             Virtex6::FrameAddressToIndex::iterator found = farRemaining.find(far);
00301             if(found != farRemaining.end()) {
00302                 farRemaining.erase(found);
00303             } else {
00304                 std::cerr << "missing " << far << " ";
00305             }
00306         }
00307     }
00308     {
00309         Virtex6::FrameAddressToIndex::const_iterator p = farRemaining.begin();
00310         Virtex6::FrameAddressToIndex::const_iterator e = farRemaining.end();
00311         while(p != e) {
00312             std::cerr << "remaining " << (*p++).first << " ";
00313         }
00314         std::cerr << std::endl;
00315     }
00316     // verify that we have visited all of the expected FARs and no others
00317     std::cout << "Device: " << inDeviceName << std::endl;
00318     std::cout << "Size of farRemaining: " << farRemaining.size() << std::endl;
00319     std::cout << "Size of farVisited: " << farVisited.size() << std::endl;
00320     BOOST_REQUIRE_EQUAL(bitstream.mFrameAddressToIndex.size(), farVisited.size());
00321     BOOST_REQUIRE_EQUAL(farRemaining.size(), 0u);
00322 
00323 return;
00324 
00325     // iterate through the debug bitstream packets, and extract all of the FARs
00326     // this isn't currently being used, but it may come in handy for debugging
00327     for(int half = 0; half < 2; half++) {
00328         for(uint32_t row = 0; row < 2; row++) {
00329             typedef std::map<uint32_t, uint32_t> ColumnMaxFrame;
00330             ColumnMaxFrame maxFrames[Virtex6::eFarBlockTypeCount];
00331             Virtex6::const_iterator p = bitstream.begin();
00332             Virtex6::const_iterator e = bitstream.end();
00333             uint32_t header = VirtexPacket::makeHeader(VirtexPacket::ePacketType1, 
00334                 VirtexPacket::eOpcodeWrite, Virtex6::eRegisterLOUT, 1);
00335             while(p < e) {
00336                 const VirtexPacket& packet = *p++;
00337                 if(packet.getHeader() != header) continue;
00338                 Virtex6::FrameAddress far = packet[1];
00339 //              uint32_t far = packet[1];
00340 //              std::cerr << Hex32(far) << " ";
00341                 if(far.mTopBottom == half && far.mRow == row) {
00342 //                  std::cerr << far << " ";
00343                     ColumnMaxFrame::iterator i = maxFrames[far.mBlockType].find(far.mMajor);
00344                     if(i == maxFrames[far.mBlockType].end()) {
00345                         maxFrames[far.mBlockType][far.mMajor] = 0;
00346                     } else {
00347                         if(maxFrames[far.mBlockType][far.mMajor] < far.mMinor) 
00348                             maxFrames[far.mBlockType][far.mMajor] = far.mMinor;
00349                     }
00350                 }
00351             }
00352             std::cerr << std::endl;
00353             uint32_t frameCount = 0;
00354             for(uint32_t i = 0; i < Virtex6::eFarBlockTypeCount; i++) {
00355                 Virtex6::EFarBlockType blockType = Virtex6::EFarBlockType(i);
00356                 uint32_t majorCount = maxFrames[blockType].size();
00357                 for(uint32_t major = 0; major < majorCount; major++) {
00358                     frameCount += maxFrames[blockType][major] + 1;
00359                     std::cerr << blockType << "(" << major << "): " 
00360                         << (maxFrames[blockType][major] + 1) << " (" << frameCount << ")" 
00361                         << std::endl;
00362                 }
00363             }
00364         }
00365     }
00366 
00367 }
00368 
00369 void testVirtex6FullMapping(const boost::filesystem::path& inWorkingPath);
00370 void testVirtex6PartialMapping(const boost::filesystem::path& inWorkingPath);
00371 
00372 /// \brief Unit test for the Virtex6 bitstream to bitmap conversion.
00373 BOOST_AUTO_TEST_CASE(Virtex6MapUnitTest) {
00374     // look up the command line arguments
00375     int& argc = boost::unit_test::framework::master_test_suite().argc;
00376     char**& argv = boost::unit_test::framework::master_test_suite().argv;
00377     // make sure that we at least have the name under which we were invoked
00378     BOOST_REQUIRE(argc >= 1);
00379     // resolve symbolic links if applicable
00380     torc::common::DirectoryTree directoryTree(argv[0]);
00381     testVirtex6FullMapping(torc::common::DirectoryTree::getWorkingPath());
00382     //testVirtex6PartialMapping(torc::common::DirectoryTree::getWorkingPath());
00383 }
00384 
00385 
00386 void testVirtex6FullMapping(const boost::filesystem::path& inWorkingPath) {
00387     // build the file paths
00388     boost::filesystem::path regressionPath 
00389         = torc::common::DirectoryTree::getExecutablePath() / "regression";
00390     boost::filesystem::path generatedPath = regressionPath / "Virtex6UnitTest.generatedFull.bit";
00391     boost::filesystem::path referencePath = regressionPath / "Virtex6UnitTest.reference.bit";
00392 
00393     // read the bitstream
00394     std::fstream fileStream(referencePath.string().c_str(), std::ios::binary | std::ios::in);
00395     BOOST_REQUIRE(fileStream.good());
00396     // read and gather bitstream frames
00397     Virtex6 bitstream;
00398     bitstream.read(fileStream, false);
00399 
00400     // initialize frame map
00401     bitstream.initializeDeviceInfo("xc6vlx75t");
00402     bitstream.initializeFrameMaps();
00403 
00404     // load bitstream frames in data structure
00405     bitstream.initializeFullFrameBlocks();
00406 
00407     // write full bitstream from frame blocks data structure
00408     uint32_t frameLength = bitstream.getFrameLength();
00409     typedef boost::shared_array<uint32_t> WordSharedArray;
00410     Virtex6::iterator p = bitstream.begin();
00411     Virtex6::iterator e = bitstream.end();
00412     while (p < e) {
00413         const VirtexPacket& packet = *p++;
00414         if (packet.isType2()) {
00415             WordSharedArray words = packet.getWords();
00416             uint32_t* ptr = words.get();
00417             for (uint32_t block = 0; block < 8; block++) {
00418                 for (uint32_t frame = 0; frame < bitstream.mBlockFrameIndexBounds[block]; frame++) {
00419                     VirtexFrameBlocks::word_t* words = const_cast<VirtexFrameBlocks::word_t*>(bitstream.mFrameBlocks.mBlock[block][frame]->getWords());
00420                     for (uint32_t index = 0; index < frameLength; index++) {
00421                         *ptr++ = words[index];
00422                     }
00423                 }
00424             }
00425         }
00426     }
00427     // write the test bitstream back out
00428     std::fstream outputStream(generatedPath.string().c_str(), std::ios::binary | std::ios::out);
00429     BOOST_REQUIRE(outputStream.good());
00430     bitstream.write(outputStream);
00431     outputStream.flush();
00432     BOOST_REQUIRE(torc::common::fileContentsAreEqual(referencePath, generatedPath));
00433 
00434     return;
00435 }
00436 
00437 
00438 
00439 
00440 
00441 
00442 /*
00443 /// \brief Unit test for the Virtex6 static device info generation.
00444 BOOST_AUTO_TEST_CASE(Virtex6GenerateUnitTest) {
00445 
00446     Virtex6 bitstream;
00447     const torc::common::DeviceVector& virtex6Devices = torc::common::Devices::getVirtex6Devices();
00448     const torc::common::DeviceVector& virtex6LDevices = torc::common::Devices::getVirtex6LDevices();
00449     torc::common::DeviceVector devices;
00450     devices.insert(devices.end(), virtex6Devices.begin(), virtex6Devices.end());
00451     devices.insert(devices.end(), virtex6LDevices.begin(), virtex6LDevices.end());
00452     DeviceInfoHelper::buildFamilyDeviceInfo("Virtex6", "Virtex6DeviceInfo.template", 
00453         "Virtex6DeviceInfo.cpp", devices, bitstream);
00454 
00455 }
00456 */
00457 
00458 
00459 
00460 
00461 
00462 
00463 BOOST_AUTO_TEST_SUITE_END()
00464 
00465 } // namespace bitstream
00466 } // namespace torc