LCOV - lcov.info - ept/debtags/maint/vocabularymerger.test.h

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

           1                 : /*
           2                 :  * Merge different vocabularies together and create the tag and facet indexes
           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/maint/vocabularymerger.h>
          23                 : #include <tagcoll/input/string.h>
          24                 :
          25                 : using namespace std;
          26                 : using namespace tagcoll;
          27                 :
          28                 : struct TestVocabularyMerger {
          29                 :
          30              14 :     inline static const char* indexref(const char* index, int id)
          31                 :     {
          32              14 :         return index + ((int*)index)[id];
          33                 :     }
          34                 :
          35                 :
          36               1 :     Test _1()
          37                 : {
          38                 :         string voc1 =
          39                 :                 "Facet: taste\n"
          40                 :                 "Description: Taste\n\n"
          41                 :                 "Tag: taste::sweet\n"
          42                 :                 "Description: Sweet\n\n"
          43                 :                 "Tag: taste::salty\n"
          44               1 :                 "Description: Salty\n\n";
          45                 :         string voc2 =
          46                 :                 "Facet: smell\n"
          47                 :                 "Description: Smell\n\n"
          48                 :                 "Tag: smell::fresh\n"
          49                 :                 "Description: Fresh\n\n"
          50                 :                 "Tag: smell::mold\n"
          51               2 :                 "Description: Mold\n\n";
          52               1 :         tagcoll::input::String in1(voc1);
          53               1 :         tagcoll::input::String in2(voc2);
          54                 :
          55               1 :         ept::debtags::VocabularyMerger vm;
          56                 :
          57                 :         // Read and merge the two vocabulary samples
          58               1 :         vm.read(in1);
          59               1 :         vm.read(in2);
          60                 :
          61                 :         // Write the merged vocabulary to /dev/null (but generate offsets and indexes in the meantime)
          62               1 :         vm.write("/dev/null");
          63                 :
          64                 :         // Create the facet index
          65               2 :         char facetIndex[vm.facetIndexer().encodedSize()];
          66               1 :         vm.facetIndexer().encode(facetIndex);
          67                 :
          68                 :         // Create the tag index
          69               1 :         char tagIndex[vm.tagIndexer().encodedSize()];
          70               1 :         vm.tagIndexer().encode(tagIndex);
          71                 :
          72                 :         // Check that the facet names have been encoded correctly and in order
          73               1 :         assert_eq(string(indexref(facetIndex, 0) + 4*sizeof(int)), "smell");
          74               2 :         assert_eq(string(indexref(facetIndex, 1) + 4*sizeof(int)), "taste");
          75                 :
          76                 :         // Check the first and last tag indexes for the facets
          77               2 :         assert_eq(((int*)indexref(facetIndex, 0))[2], 0);
          78               2 :         assert_eq(((int*)indexref(facetIndex, 0))[3], 1);
          79               2 :         assert_eq(((int*)indexref(facetIndex, 1))[2], 2);
          80               2 :         assert_eq(((int*)indexref(facetIndex, 1))[3], 3);
          81                 :
          82                 :         // Check that the tag names have been encoded correctly and in order
          83               2 :         assert_eq(string(indexref(tagIndex, 0) + 3*sizeof(int)), "smell::fresh");
          84               2 :         assert_eq(string(indexref(tagIndex, 1) + 3*sizeof(int)), "smell::mold");
          85               2 :         assert_eq(string(indexref(tagIndex, 2) + 3*sizeof(int)), "taste::salty");
          86               2 :         assert_eq(string(indexref(tagIndex, 3) + 3*sizeof(int)), "taste::sweet");
          87                 :
          88                 :         // Check the facet indexes for the tags
          89               2 :         assert_eq(((int*)indexref(tagIndex, 0))[2], 0);
          90               2 :         assert_eq(((int*)indexref(tagIndex, 1))[2], 0);
          91               2 :         assert_eq(((int*)indexref(tagIndex, 2))[2], 1);
          92               2 :         assert_eq(((int*)indexref(tagIndex, 3))[2], 1);
          93               1 : }
          94                 :
          95                 : // Test parsing a vocabulary with a tag without a defined facet
          96               1 :     Test _2()
          97                 : {
          98                 :         string voc =
          99                 :                 "Tag: foo::bar\n"
         100                 :                 "Description: Tag without facet\n"
         101               1 :                 " VocabularyMerged should behave fine in this case.\n\n";
         102               1 :         tagcoll::input::String in(voc);
         103                 :
         104               1 :         ept::debtags::VocabularyMerger vm;
         105               1 :         vm.read(in);
         106                 :
         107                 :         // Write the merged vocabulary to /dev/null (but generate offsets and indexes in the meantime)
         108               1 :         vm.write("/dev/null");
         109                 :
         110                 :         // Create the facet index
         111               2 :         char facetIndex[vm.facetIndexer().encodedSize()];
         112               1 :         vm.facetIndexer().encode(facetIndex);
         113                 :
         114                 :         // Create the tag index
         115               1 :         char tagIndex[vm.tagIndexer().encodedSize()];
         116               1 :         vm.tagIndexer().encode(tagIndex);
         117               1 : }
         118                 :
         119                 : // Test parsing a vocabulary with a facet without tags
         120               1 :     Test _3()
         121                 : {
         122                 :         string voc =
         123                 :                 "Facet: empty\n"
         124                 :                 "Description: Facet without tags\n"
         125               1 :                 " VocabularyMerged used to segfault in this case.\n\n";
         126               1 :         tagcoll::input::String in(voc);
         127                 :
         128               1 :         ept::debtags::VocabularyMerger vm;
         129               1 :         vm.read(in);
         130                 :
         131                 :         // Write the merged vocabulary to /dev/null (but generate offsets and indexes in the meantime)
         132               1 :         vm.write("/dev/null");
         133                 :
         134                 :         // Create the facet index
         135               2 :         char facetIndex[vm.facetIndexer().encodedSize()];
         136               1 :         vm.facetIndexer().encode(facetIndex);
         137                 :
         138                 :         // Create the tag index
         139               1 :         char tagIndex[vm.tagIndexer().encodedSize()];
         140               1 :         vm.tagIndexer().encode(tagIndex);
         141               1 : }
         142                 :
         143                 : };
         144                 : // vim:set ts=4 sw=4:

Generated by: LTP GCOV extension version 1.6