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

       1                 : /*
       2                 :  * Tag vocabulary access
       3                 :  *
       4                 :  * Copyright (C) 2003--2007  Enrico Zini <enrico@debian.org>
       5                 :  *
       6                 :  * This program is free software; you can redistribute it and/or modify
       7                 :  * it under the terms of the GNU General Public License as published by
       8                 :  * the Free Software Foundation; either version 2 of the License, or
       9                 :  * (at your option) any later version.
      10                 :  *
      11                 :  * This program is distributed in the hope that it will be useful,
      12                 :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :  * GNU General Public License for more details.
      15                 :  *
      16                 :  * You should have received a copy of the GNU General Public License
      17                 :  * along with this program; if not, write to the Free Software
      18                 :  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      19                 :  */
      20                 : 
      21                 : #include <wibble/test.h>
      22                 : #include <ept/debtags/vocabulary.h>
      23                 : #include <ept/debtags/maint/vocabularymerger.h>
      24                 : #include <ept/debtags/maint/path.h>
      25                 : #include <tagcoll/utils/set.h>
      26                 : #include <tagcoll/input/stdio.h>
      27                 : 
      28                 : #include "debtags.test.h"
      29                 : 
      30                 : // This is not exported by default
      31                 : namespace ept {
      32                 : namespace debtags {
      33                 : int tagcmp(const char* tag1, const char* tag2);
      34                 : }
      35                 : }
      36                 : 
      37                 : using namespace std;
      38                 : using namespace tagcoll::utils;
      39                 : using namespace ept::debtags;
      40                 : 
      41                 : struct TestVocabulary : DebtagsTestEnvironment
      42              38 : {
      43                 :         Vocabulary  m_tags;
      44            1298 :         Vocabulary& tags() { return m_tags; }
      45                 : 
      46               1 :         Test _1()
      47                 : {
      48               1 :     tags(); // this will throw if the open above didn't work
      49               1 : }
      50                 : 
      51               1 :         Test _2()
      52                 : {
      53               1 :     assert( tags().hasFacet( "works-with" ) );
      54               2 :     assert( !tags().hasFacet( "blah" ) );
      55               1 : }
      56                 : 
      57               1 :         Test _3()
      58                 : {
      59               1 :     assert( tags().hasTag( "works-with::people" ) );
      60               2 :     assert( !tags().hasTag( "works-with::midgets" ) );
      61               1 : }
      62                 : 
      63               1 :         Test _4()
      64                 : {
      65               1 :     Tag people = tags().tagByName( "works-with::people" ),
      66               2 :                 midgets = tags().tagByName( "works-with::midgets" ),
      67               2 :                 blahg = tags().tagByName( "works-with::blahg" ),
      68               2 :                 text = tags().tagByName( "works-with::text" ),
      69               2 :                 people2 = tags().tagByName( "works-with::people" );
      70               2 :     assert( people != midgets );
      71               2 :     assert( people != text );
      72               2 :     assert( people != blahg );
      73               2 :     assert( midgets == blahg );
      74               2 :     assert( midgets == midgets );
      75               2 :     assert( people == people2 );
      76               2 :     assert( people == people );
      77               1 : }
      78                 : 
      79               1 :         Test _5()
      80                 : {
      81               1 :     Tag a = tags().tagByName( "works-with::people" ),
      82               2 :                 b = tags().tagByName( "works-with::midgets" );
      83               2 :         std::set< Tag > s = tags().tags(),
      84               1 :                          f = tags().tags( "works-with" ),
      85               2 :                          n = tags().tags( "nonsense" );
      86               2 :     assert( set_contains(s, a) );
      87               2 :     assert( set_contains(f, a) );
      88               2 :     assert( set_contains(s, f) );
      89               2 :     assert( !set_contains(s, b) );
      90               2 :     assert( !set_contains(f, b) );
      91               2 :     assert( n.empty() );
      92               1 : }
      93                 : 
      94               1 :         Test _6()
      95                 : {
      96               1 :         Facet f = tags().facetByName( "works-with" );
      97               2 :     Tag t = tags().tagByName( "works-with::people" );
      98               2 :         assert_eq(f.name(), "works-with");
      99               1 :         assert_eq(t.name(), "people");
     100               1 :         assert_eq(t.fullname(), "works-with::people");
     101               1 : }
     102                 : 
     103               1 :         Test _7()
     104                 : {
     105               1 :     Facet f = tags().facetByName( "works-with" );
     106               2 :         std::set< Tag > x = tags().tags( "works-with" );
     107               2 :     assert( x == f.tags() );
     108               1 : }
     109                 : 
     110               1 :         Test _8()
     111                 : {
     112               1 :     Facet f = tags().facetByName( "does-not-work-with" );
     113               1 :     int x = 1;
     114                 :     try {
     115               1 :         f.tags();
     116               0 :         x = 2;
     117               2 :     } catch (...) {
     118               1 :         x = 3;
     119                 :     }
     120               1 :     assert_eq( x, 3 );
     121               1 : }
     122                 : 
     123               1 :         Test _9()
     124                 : {
     125               1 :     Facet f = tags().facetByName( "legacy" );
     126               2 :     assert_eq(f.shortDescription(), "");
     127               1 :     assert_eq(f.longDescription(), "");
     128                 :     //assert_eq(f.shortDescription( "weehee" ), "weehee");
     129               1 : }
     130                 : 
     131                 :         Test _10()
     132                 : {
     133                 :         // assert that one-character tag names are parsed correctly
     134                 :         assert( tags().hasTag( "implemented-in::c" ) );
     135                 : }
     136                 : 
     137               1 :         Test _11()
     138                 : {
     139                 :         // assert that all tags are somehow working
     140               1 :         std::set<Facet> facets = tags().facets();
     141                 : 
     142              30 :         for (std::set<Facet>::const_iterator i = facets.begin();
     143                 :                         i != facets.end(); i++)
     144                 :         {
     145              29 :                 i->name(string("foo"));
     146              58 :                 i->shortDescription(string("foo"));
     147              58 :                 i->longDescription(string("foo"));
     148              58 :                 i->tags();
     149               1 :         }
     150               1 : }
     151                 : 
     152               1 :         Test _12()
     153                 : {
     154                 :         // assert that all tags are somehow working
     155               1 :         std::set<Tag> tags = this->tags().tags();
     156                 : 
     157            1242 :         for (std::set<Tag>::const_iterator i = tags.begin();
     158                 :                         i != tags.end(); i++)
     159                 :         {
     160             620 :                 i->name(string("foo"));
     161            1240 :                 i->fullname(string("foo"));
     162            1240 :                 i->shortDescription(string("foo"));
     163            1240 :                 i->longDescription(string("foo"));
     164               1 :         }
     165               1 : }
     166                 : 
     167                 : // Check for correctness of the first and last tag in the vocabulary
     168               1 :         Test _13()
     169                 : {
     170               1 :         Vocabulary& tags = this->tags();
     171                 : 
     172               1 :         Tag first = tags.tagByName("accessibility::TODO");
     173               2 :         assert(first != Tag());
     174               1 :         assert_eq(first.fullname(), string("accessibility::TODO"));
     175               2 :         assert_eq(first.name(), string("TODO"));
     176               2 :         assert_eq(first.shortDescription(), string("Need an extra tag"));
     177                 : 
     178               2 :         Tag last = tags.tagByName("x11::xserver");
     179               2 :         assert(last != Tag());
     180               1 :         assert_eq(last.fullname(), string("x11::xserver"));
     181               2 :         assert_eq(last.name(), string("xserver"));
     182               2 :         assert_eq(last.shortDescription(), string("X Server"));
     183               1 : }
     184                 : 
     185               1 :         Test _14()
     186                 : {
     187                 :         // assert that it's possible to go from facet to ID and back
     188               1 :         std::set<Facet> facets = tags().facets();
     189                 : 
     190              30 :         for (std::set<Facet>::const_iterator i = facets.begin();
     191                 :                         i != facets.end(); i++)
     192                 :         {
     193              29 :                 Facet f = tags().facetByID(i->id());
     194              29 :                 assert_eq(*i, f);
     195              29 :                 assert_eq(i->name(), f.name());
     196              29 :                 assert_eq(i->shortDescription(), f.shortDescription());
     197              29 :                 assert_eq(i->longDescription(), f.longDescription());
     198              29 :                 assert_eq(i->tags().size(), f.tags().size());
     199               1 :         }
     200               1 : }
     201                 : 
     202               1 :         Test _15()
     203                 : {
     204                 :         // assert that it's possible to go from tag to ID and back
     205               1 :         std::set<Tag> tags = this->tags().tags();
     206                 : 
     207             621 :         for (std::set<Tag>::const_iterator i = tags.begin();
     208                 :                         i != tags.end(); i++)
     209                 :         {
     210             620 :                 Tag t = this->tags().tagByID(i->id());
     211             620 :                 assert_eq(*i, t);
     212             620 :                 assert_eq(i->name(), t.name());
     213             620 :                 assert_eq(i->fullname(), t.fullname());
     214             620 :                 assert_eq(i->shortDescription(), t.shortDescription());
     215             620 :                 assert_eq(i->longDescription(), t.longDescription());
     216               1 :         }
     217               1 : }
     218                 : 
     219               1 :         Test _16()
     220                 : {
     221                 :         // assert that facet IDs are distinct
     222               1 :         std::set<Facet> facets = tags().facets();
     223               1 :         std::set<int> ids;
     224              30 :         for (std::set<Facet>::const_iterator i = facets.begin();
     225                 :                         i != facets.end(); i++)
     226              29 :                 ids.insert(i->id());
     227                 : 
     228               1 :         assert_eq(facets.size(), ids.size());
     229               1 : }
     230                 : 
     231               1 :         Test _17()
     232                 : {
     233                 :         // assert that tag IDs are distinct
     234               1 :         std::set<Tag> tags = this->tags().tags();
     235               1 :         std::set<int> ids;
     236             621 :         for (std::set<Tag>::const_iterator i = tags.begin();
     237                 :                         i != tags.end(); i++)
     238             620 :                 ids.insert(i->id());
     239                 : 
     240               1 :         assert_eq(tags.size(), ids.size());
     241               1 : }
     242                 : 
     243               1 :         Test _18()
     244                 : {
     245                 :         // assert that all the tags are indexed
     246               1 :         ept::debtags::VocabularyMerger voc;
     247               1 :         tagcoll::input::Stdio in(ept::debtags::Path::vocabulary());
     248               1 :         voc.read(in);
     249               1 :         std::set<std::string> all = voc.tagNames();
     250            1242 :         for (std::set<std::string>::const_iterator i = all.begin();
     251                 :                         i != all.end(); ++i)
     252             620 :                 assert(this->tags().hasTag(*i));
     253                 : 
     254                 :         // There should be the same amount of tags in both
     255               1 :         std::set<Tag> allTags = this->tags().tags();
     256               1 :         assert_eq(all.size(), allTags.size());
     257               1 : }
     258                 : 
     259               1 :         Test _19()
     260                 : {
     261                 :         // test the tagcmp function
     262                 : 
     263                 :         // If unfaceted, same as strcmp
     264               1 :         assert(ept::debtags::tagcmp("antani", "blinda") < 0);
     265               2 :         assert(ept::debtags::tagcmp("blinda", "antani") > 0);
     266               2 :         assert_eq(ept::debtags::tagcmp("antani", "antani"), 0);
     267                 : 
     268                 :         // If the same and faceted, should work
     269               2 :         assert_eq(ept::debtags::tagcmp("antani::blinda", "antani::blinda"), 0);
     270                 : 
     271                 :         // With different facet names, work just as strcmp
     272               2 :         assert(ept::debtags::tagcmp("antani::blinda", "blinda::blinda") < 0);
     273               2 :         assert(ept::debtags::tagcmp("blinda::blinda", "antani::blinda") > 0);
     274               2 :         assert(ept::debtags::tagcmp("anta::blinda", "antani::blinda") < 0);
     275               2 :         assert(ept::debtags::tagcmp("antani::blinda", "anta::blinda") > 0);
     276               2 :         assert(ept::debtags::tagcmp("anta::blinda", "anta-ni::blinda") < 0);
     277               2 :         assert(ept::debtags::tagcmp("anta-ni::blinda", "anta::blinda") > 0);
     278                 : 
     279                 :         // With same facet names, work just as strcmp on the tags
     280               2 :         assert(ept::debtags::tagcmp("a::antani", "a::blinda") < 0);
     281               2 :         assert(ept::debtags::tagcmp("a::blinda", "a::antani") > 0);
     282               2 :         assert(ept::debtags::tagcmp("a::anta", "a::antani") < 0);
     283               2 :         assert(ept::debtags::tagcmp("a::antani", "a::anta") > 0);
     284               2 :         assert(ept::debtags::tagcmp("a::anta", "a::anta-ni") < 0);
     285               2 :         assert(ept::debtags::tagcmp("a::anta-ni", "a::anta") > 0);
     286               1 : }
     287                 : 
     288                 :         Test _20()
     289                 : {
     290                 :         // check that we're seeing all the tags for a facet
     291                 :         std::set<Tag> t = tags().tags("accessibility");
     292                 :         assert_eq(t.size(), 10u);
     293                 : 
     294                 :         t = tags().tags("works-with-format");
     295                 :         assert_eq(t.size(), 33u);
     296                 : }
     297                 : 
     298                 : // If there is no data, Vocabulary should work as an empty vocabulary
     299               1 :         Test _21()
     300                 : {
     301               1 :         Path::OverrideDebtagsSourceDir odsd("./empty");
     302               2 :         Path::OverrideDebtagsIndexDir odid("./empty");
     303               2 :         Path::OverrideDebtagsUserSourceDir odusd("./empty");
     304               2 :         Path::OverrideDebtagsUserIndexDir oduid("./empty");
     305               1 :         Vocabulary empty;
     306                 : 
     307               1 :         assert(!empty.hasData());
     308                 : 
     309               1 :         set<Facet> facets = empty.facets();
     310               1 :         assert_eq(facets.size(), 0u);
     311                 : 
     312               1 :         set<Tag> tags = empty.tags();
     313               1 :         assert_eq(tags.size(), 0u);
     314               1 : }
     315                 : 
     316                 : };
     317                 : 
     318                 : // vim:set ts=4 sw=4:

Generated by: LTP GCOV extension version 1.6