LTP GCOV extension - code coverage report
Current view: | directory - ept/debtags - debtags.test.h
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 103
Code covered: | 100.0 % |  | Executed lines: | 103

           1                 : // -*- mode: c++; tab-width: 4; indent-tabs-mode: t -*-
           2                 : /**
           3                 :  * @file
           4                 :  * @author Enrico Zini (enrico) <enrico@enricozini.org>
           5                 :  */
           6                 :
           7                 : /*
           8                 :  * Test for the Debtags data provider
           9                 :  *
          10                 :  * Copyright (C) 2003-2007  Enrico Zini <enrico@debian.org>
          11                 :  *
          12                 :  * This library is free software; you can redistribute it and/or
          13                 :  * modify it under the terms of the GNU Lesser General Public
          14                 :  * License as published by the Free Software Foundation; either
          15                 :  * version 2.1 of the License, or (at your option) any later version.
          16                 :  *
          17                 :  * This library is distributed in the hope that it will be useful,
          18                 :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
          19                 :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
          20                 :  * Lesser General Public License for more details.
          21                 :  *
          22                 :  * You should have received a copy of the GNU Lesser General Public
          23                 :  * License along with this library; if not, write to the Free Software
          24                 :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
          25                 :  */
          26                 :
          27                 :
          28                 : #include <ept/debtags/debtags.h>
          29                 : #include <ept/core/apt.h>
          30                 :
          31                 : #include <tagcoll/coll/simple.h>
          32                 : #include <tagcoll/stream/sink.h>
          33                 :
          34                 : #include <wibble/operators.h>
          35                 :
          36                 : #include <ept/test.h>
          37                 :
          38                 : #ifndef EPT_DEBTAGS_TESTH
          39                 : #define EPT_DEBTAGS_TESTH
          40                 :
          41                 : using namespace tagcoll;
          42                 : using namespace std;
          43                 : using namespace ept;
          44                 : using namespace ept::debtags;
          45                 : using namespace wibble::operators;
          46                 :
          47                 : struct TestDebtags : DebtagsTestEnvironment
          48               5 : {
          49                 :         Debtags debtags;
          50                 :
          51               5 :     TestDebtags() {}
          52                 :
          53              10 :         Vocabulary& voc() { return debtags.vocabulary(); }
          54                 :
          55               1 :         Test _1() {
          56           21146 :                 for (Debtags::const_iterator i = debtags.begin(); i != debtags.end(); ++i)
          57                 :                 {
          58           21145 :                         *i;
          59           21145 :                         i->first;
          60           21145 :                         i->second;
          61               1 :                 }
          62               1 :                 int items = 0, tags = 0;
          63               1 :                 debtags.outputSystem(stream::countingSink(items, tags));
          64                 :
          65               1 :                 int pitems = 0, ptags = 0;
          66               1 :         debtags.outputPatched(stream::countingSink(pitems, ptags));
          67                 :
          68               2 :         assert(items > 10);
          69               2 :         assert(tags > 10);
          70               2 :         assert(items <= pitems);
          71               2 :         assert(tags <= ptags);
          72               1 : }
          73                 :
          74               1 :         Test _2()
          75                 : {
          76               1 :     string p("debtags");
          77               1 :         std::set<Tag> tags = debtags.getTagsOfItem(p);
          78               1 :         assert( !tags.empty() );
          79                 :
          80                 : #if 0
          81                 :         for ( std::set< Tag >::iterator i = tags.begin(); i != tags.end(); ++ i ) {
          82                 :                 std::cerr << i->id() << ": " << i->fullname() << std::endl;
          83                 :         }
          84                 :         std::cerr << "---" << std::endl;
          85                 :         Tag t = voc().tagByName( "interface::commandline" );
          86                 :         std::cerr << t.id() << ": " << t.fullname() << std::endl;
          87                 : #endif
          88                 :
          89               2 :         assert_eq( tags.size(), 8u );
          90               2 :         assert( voc().tagByName( "devel::buildtools" ) <= tags );
          91               2 :         assert( voc().tagByName( "implemented-in::c++" ) <= tags );
          92               2 :         assert( voc().tagByName( "interface::commandline" ) <= tags );
          93               2 :         assert( voc().tagByName( "role::program" ) <= tags );
          94               2 :         assert( voc().tagByName( "scope::application" ) <= tags );
          95               2 :         assert( voc().tagByName( "suite::debian" ) <= tags );
          96               2 :         assert( voc().tagByName( "use::searching" ) <= tags );
          97               2 :         assert( voc().tagByName( "works-with::software:package" ) <= tags );
          98               1 : }
          99                 :
         100               1 :         Test _3()
         101                 : {
         102                 :         using namespace std;
         103                 :
         104                 :     /* Get the 'debtags' package */
         105               1 :     string p("debtags");
         106                 :
         107                 :     /* Get its tags */
         108               1 :         std::set<Tag> tags = debtags.getTagsOfItem(p);
         109               1 :     assert(!tags.empty());
         110                 :
         111                 :         /*
         112                 :         cerr << "Intersection size: " << endl;
         113                 :         using namespace wibble::operators;
         114                 :         std::set<Tag>::const_iterator dbgi = tags.begin();
         115                 :         cerr << "* " << dbgi->fullname() << ": " << dbgi->id() << endl;
         116                 :         std::set<int> dbgres = debtags.tagdb().getItemsHavingTag(dbgi->id());
         117                 :         std::set<Package> dbgpres = debtags.getItemsHavingTag(*dbgi);
         118                 :         cerr << " #pkgs " << dbgres.size() << " == " << dbgpres.size() << endl;
         119                 :         cerr << " #isec " << dbgres.size() << " == " << dbgpres.size() << endl;
         120                 :         cerr << "  "; ppset(dbgpres); cerr << endl;
         121                 :         cerr << "  "; piset(dbgres); cerr << endl;
         122                 :         for (++dbgi ; dbgi != tags.end(); ++dbgi)
         123                 :         {
         124                 :                 cerr << "* " << dbgi->fullname() << ": " << dbgi->id() << endl;
         125                 :                 std::set<Package> dbgpkgs = debtags.getItemsHavingTag(*dbgi);
         126                 :                 std::set<int> dbgids = debtags.tagdb().getItemsHavingTag(dbgi->id());
         127                 :                 cerr << "  "; ppset(dbgpkgs); cerr << endl;
         128                 :                 cerr << "  "; piset(dbgids); cerr << endl;
         129                 :                 cerr << " #pkgs " << dbgpkgs.size() << " == " << dbgids.size() << endl;
         130                 :                 dbgres &= dbgids;
         131                 :                 dbgpres &= dbgpkgs;
         132                 :                 cerr << " #isec " << dbgres.size() << " == " << dbgpres.size() << endl;
         133                 :         }
         134                 :         cerr << " " << dbgres.size() << endl << "Results: " << endl;
         135                 :         for (std::set<int>::const_iterator i = dbgres.begin(); i != dbgres.end(); ++i)
         136                 :                 cerr << "   " << *i << endl;
         137                 :         */
         138                 :
         139                 :
         140                 : //      cerr << "Tags of debtags: ";
         141                 : //      for (std::set<Tag>::const_iterator i = tags.begin(); i != tags.end(); ++i)
         142                 : //      {
         143                 : //              cerr << " " + i->fullname() << endl;
         144                 : //              std::set<Package> packages = debtags.getItemsHavingTag(*i);
         145                 : //              for (std::set<Package>::const_iterator p = packages.begin();
         146                 : //                              p != packages.end(); ++p)
         147                 : //                      cerr << "   PKG " << p->name() << endl;
         148                 : //      }
         149                 : //      cerr << endl;
         150                 :
         151                 :     /* Get the items for the tagset of 'debtags' */
         152               1 :         std::set<string> packages = debtags.getItemsHavingTags(tags);
         153                 :         //cerr << packages.size() << endl;
         154               1 :     assert(!packages.empty());
         155                 :         /*
         156                 :         for ( std::set< Package >::iterator i = packages.begin(); i != packages.end(); ++ i )
         157                 :                 std::cerr << i->name() << std::endl;
         158                 :         std::cerr << "---" << std::endl;
         159                 :         std::cerr << p.name() << std::endl;
         160                 :         */
         161                 :     /* They should at least contain 'debtags' */
         162               2 :     assert( p <= packages );
         163                 :
         164                 :     /* Get one of the tags of 'debtags' */
         165               2 :     Tag tag = *tags.begin();
         166               1 :     assert(tag);
         167                 :
         168                 :     /* Get its items */
         169                 :     {
         170                 :         /* Need this workaround until I figure out how to tell the new GCC
         171                 :          * that TagDB is a TDBReadonlyDiskIndex and should behave as such
         172                 :          */
         173               1 :                 std::set<Tag> ts;
         174               1 :                 ts.insert(tag);
         175               1 :         packages = debtags.getItemsHavingTags(ts);
         176                 :     }
         177                 :     //packages = c.debtags().tagdb().getItems(tag);
         178               1 :     assert(!packages.empty());
         179                 :     /* They should at least contain 'debtags' */
         180               2 :     assert( p <= packages );
         181                 :
         182                 :     //c.debtags().getTags(""); // XXX HACK AWW!
         183               1 : }
         184                 :
         185               1 :         Test _4()
         186                 : {
         187               1 :         std::string patchfile = Path::debtagsUserSourceDir() + "patch";
         188               1 :         unlink(patchfile.c_str());
         189                 :
         190               1 :         string p("debtags");
         191                 :
         192                 :     /* Get its tags */
         193               1 :         std::set<Tag> tags = debtags.getTagsOfItem(p);
         194               1 :     assert(!tags.empty());
         195                 :
         196                 :         // Ensure that it's not tagged with gameplaying
         197               2 :         Tag t = voc().tagByName("use::gameplaying");
         198               2 :     assert(! (t <= tags) );
         199                 :
         200                 :         // Add the gameplaying tag
         201               1 :         PatchList<string, Tag> change;
         202               1 :         change.addPatch(Patch<string, Tag>(p, wibble::singleton(t), wibble::Empty<Tag>()));
         203               1 :         debtags.applyChange(change);
         204                 :
         205                 :         // See that the patch is non empty
         206               1 :         PatchList<string, Tag> tmp = debtags.changes();
         207               1 :         assert(tmp.size() > 0);
         208               2 :         assert_eq(tmp.size(), 1u);
         209                 :
         210                 :         // Ensure that the tag has been added
         211               2 :         tags = debtags.getTagsOfItem(p);
         212               1 :     assert(!tags.empty());
         213                 :
         214               2 :         t = voc().tagByName("use::gameplaying");
         215               2 :     assert( t <= tags );
         216                 :
         217                 :         // Save the patch
         218               1 :         debtags.savePatch();
         219                 :
         220                 :         // Check that the saved patch is correct
         221               1 :         FILE* in = fopen(patchfile.c_str(), "r");
         222               1 :         string writtenPatch;
         223                 :         int c;
         224              29 :         while ((c = getc(in)) != EOF)
         225              27 :                 writtenPatch += c;
         226               1 :         fclose(in);
         227                 :
         228               1 :         assert_eq(writtenPatch, string("debtags: +use::gameplaying\n"));
         229                 :
         230               2 :         unlink(patchfile.c_str());
         231                 :
         232                 :         // Reapply the patch and see that it doesn't disrept things
         233               1 :         debtags.applyChange(change);
         234                 :
         235                 :         // The patch should not have changed
         236               1 :         tmp = debtags.changes();
         237               1 :         assert_eq(tmp.size(), 1u);
         238               2 :         assert_eq(tmp.begin()->first, p);
         239               1 :         assert_eq(tmp.begin()->second.item, p);
         240               1 : }
         241                 :
         242                 : // If there is no data, Debtags should work as an empty collection
         243               1 :         Test _5()
         244                 : {
         245               1 :         Path::OverrideDebtagsSourceDir odsd("./empty");
         246               2 :         Path::OverrideDebtagsIndexDir odid("./empty");
         247               2 :         Path::OverrideDebtagsUserSourceDir odusd("./empty");
         248               2 :         Path::OverrideDebtagsUserIndexDir oduid("./empty");
         249               1 :         Debtags empty;
         250                 :
         251               1 :         assert(empty.begin() == empty.end());
         252               1 :         assert_eq(empty.timestamp(), 0);
         253               2 :         assert(!empty.hasData());
         254                 :
         255               1 :         tagcoll::PatchList<std::string, Tag> patches = empty.changes();
         256               1 :         assert(patches.empty());
         257                 :
         258               2 :         set<Tag> res = empty.getTagsOfItem("apt");
         259               2 :         assert(res.empty());
         260               2 :         res = empty.getTagsOfItems(wibble::singleton(string("apt")));
         261               2 :         assert(res.empty());
         262                 :
         263               2 :         res = empty.getAllTags();
         264               1 :         assert(res.empty());
         265                 :
         266               1 :         tagcoll::coll::Simple<string, Tag> coll;
         267               1 :         empty.outputSystem(tagcoll::coll::inserter(coll));
         268               1 :         assert_eq(coll.itemCount(), 0u);
         269                 :
         270               1 :         coll.clear();
         271                 :
         272               1 :         empty.outputPatched(tagcoll::coll::inserter(coll));
         273               1 :         assert_eq(coll.itemCount(), 0u);
         274               1 : }
         275                 :
         276                 : };
         277                 :
         278                 : #include <ept/debtags/debtags.tcc>
         279                 : #include <tagcoll/coll/simple.tcc>
         280                 :
         281                 : #endif
         282                 :
         283                 : // vim:set ts=4 sw=4:

Generated by: LTP GCOV extension version 1.6