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

           1                 : // -*- C++ -*-
           2                 : #include <ept/config.h>
           3                 : #include <ept/core/apt.h>
           4                 : #include <ept/core/list.h>
           5                 : #include <ept/test.h>
           6                 :
           7                 : using namespace ept::core;
           8                 :
           9                 : struct TestCoreApt : AptTestEnvironment
          10              12 : {
          11                 :     package::Source pkgs;
          12                 :     version::Source vers;
          13                 :     ept::Token t;
          14                 :
          15              12 :     TestCoreApt() : pkgs( db ), vers( db ) {
          16              12 :         t._id = "sp";
          17              12 :     }
          18                 :
          19               1 :     Test token() {
          20               1 :         assert_eq( t.package(), "sp" );
          21               2 :         assert_eq( t.version(), "" );
          22               1 :     }
          23                 :
          24               1 :     Test tokenVersion() {
          25               1 :         ept::Token t2;
          26               1 :         t2._id = "libwibble-dev_0.1.10";
          27               1 :         assert_eq( t2.package(), "libwibble-dev" );
          28               1 :         assert_eq( t2.version(), "0.1.10" );
          29               1 :     }
          30                 :
          31               1 :     Test packageName() {
          32               1 :         assert_eq( t.package(), pkgs.get< package::Name >( t ) );
          33               1 :     }
          34                 :
          35                 :     template< typename List >
          36               1 :     void checkPackageNameList( List l ) {
          37            3779 :         while ( !l.empty() ) {
          38            3777 :             assert_eq( l.token().package(), l.property() );
          39            3777 :             l = l.tail();
          40                 :         }
          41               1 :     }
          42                 :
          43                 :     template< typename List >
          44               1 :     void checkVersionPackageList( List l ) {
          45            1810 :         while ( !l.empty() ) {
          46            1808 :             assert_eq( l.property().package(), l.token().package() );
          47            3616 :             assert_eq( l.property().version(), "" );
          48            1808 :             l = l.tail();
          49                 :         }
          50               1 :     }
          51                 :
          52               1 :     Test packageCount() {
          53                 :         assert_eq( list::count( pkgs.list< package::Name >() ),
          54               1 :                    3777 );
          55               1 :     }
          56                 :
          57               1 :     Test packageNameList() {
          58               1 :         checkPackageNameList( pkgs.list< package::Name >() );
          59               1 :     }
          60                 :
          61               1 :     Test versionCount() {
          62                 :         assert_eq( list::count( vers.list< version::Package >() ),
          63               1 :                   1808 );
          64               1 :     }
          65                 :
          66               1 :     Test versionPackage() {
          67               1 :         checkVersionPackageList( vers.list< version::Package >() );
          68               1 :     }
          69                 :
          70               1 :     Test validate() {
          71               1 :         assert_eq( t, db.validate( t ) );
          72                 :         assert_neq( ept::Token( "libfoobar" ),
          73               2 :                     db.validate( ept::Token( "libfooar" ) ) );
          74               2 :         assert_eq( ept::Token(), db.validate( ept::Token( "libfoobar" ) ) );
          75               1 :     }
          76                 :
          77               1 :     Test packageState() {
          78               1 :         assert( db.packageState( t ) & PackageState::Keep );
          79               1 :     }
          80                 :
          81               1 :     Test packageState2() {
          82               1 :         assert( pkgs.get< package::State >( t ) & PackageState::Keep );
          83               1 :     }
          84                 :
          85               1 :     Test exists() {
          86               1 :         assert( pkgs.exists( t ) );
          87               2 :         assert( !pkgs.exists( ept::Token( "nonexistent-package" ) ) );
          88               1 :     }
          89                 :
          90               1 :     Test invalidate() {
          91               1 :         assert( pkgs.exists( t ) );
          92               1 :         db.invalidate();
          93               2 :         assert( pkgs.exists( t ) );
          94               1 :     }
          95                 : };

Generated by: LTP GCOV extension version 1.6