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