Changeset 471 for library/tests

Show
Ignore:
Timestamp:
08/05/09 00:01:58 (16 years ago)
Author:
mido
Message:

1) ad UserInfo?: UI::get a UI::build predelany tak, ze vraci fals / NULL v pripade neexistence pozadovaneho Settingu, pridana enumericky typ UI::SettingPresence?, predelany stavajici UI implementace, dodelana UI dokumentace
2) dokoncena konfigurace ASTYLERU, brzy bude aplikovan
3) doxygen nastaven tak, ze vytvari soubor doxy_warnings.txt

Location:
library/tests
Files:
4 modified

Legend:

Unmodified
Added
Removed

  • library/tests/egiw_harness.cpp

    r456 r471  
    88 
    99void egiw_harness::from_setting(const Setting &set) { 
    10     epdf_harness::from_setting(set); 
    11     UI::get(lognc, set, "lognc"); 
     10    epdf_harness::from_setting(set);                             
     11    UI::get(lognc, set, "lognc", UI::compulsory); 
    1212} 
    1313 

  • library/tests/epdf_harness.cpp

    r469 r471  
    2929 
    3030void epdf_harness::from_setting(const Setting &set) { 
    31     hepdf = UI::build<epdf>(set, "epdf"); 
    32     UI::get(mean, set, "mean"); 
    33     UI::get(variance, set, "variance"); 
     31    hepdf = UI::build<epdf>(set, "epdf", UI::compulsory); 
     32    UI::get(mean, set, "mean", UI::compulsory); 
     33    UI::get(variance, set, "variance", UI::compulsory); 
    3434 
    35     if (set.exists("support")) { 
    36         UI::get(support, set, "support"); 
    37     } 
    3835 
    39     if (set.exists("nbins")) { 
    40         UI::get(nbins, set, "nbins"); 
    41     } 
     36        UI::get(support, set, "support"); 
     37        UI::get(nbins, set, "nbins"); 
     38    UI::get(nsamples, set, "nsamples"); 
     39    UI::get(R, set, "R"); 
    4240 
    43     if (set.exists("nsamples")) { 
    44         UI::get(nsamples, set, "nsamples"); 
    45     } 
     41        RV* rv = UI::build<RV>(set, "marginal_rv"); 
     42    if (rv)  
     43        mrv = shared_ptr<RV>(rv);     
    4644 
    47     if (set.exists("R")) { 
    48         UI::get(R, set, "R"); 
    49     } 
    50  
    51     if (set.exists("marginal_rv")) { 
    52         mrv = shared_ptr<RV>(UI::build<RV>(set, "marginal_rv")); 
    53     } 
    54  
    55     if (set.exists("tolerance")) { 
    56         UI::get(tolerance, set, "tolerance"); 
    57     } 
     45        UI::get(tolerance, set, "tolerance");     
    5846} 
    5947 

  • library/tests/mpdf_harness.cpp

    r456 r471  
    1818    UIFile in(config_file_name); 
    1919    Array<mpdf_harness *> input; 
    20     UI::get(input, in, "data"); 
     20        UI::get(input, in, "data"); 
    2121    int sz = input.size(); 
    2222    CHECK(sz > 0); 
    … …  
    2626} 
    2727 
    28 void mpdf_harness::from_setting(const Setting &set) { 
    29     hmpdf = UI::build<mpdf>(set, "mpdf"); 
    30     UI::get(cond, set, "cond"); 
    31     UI::get(mean, set, "mean"); 
     28void mpdf_harness::from_setting(const Setting &set) {                    
     29        hmpdf = UI::build<mpdf>(set, "mpdf", UI::compulsory); 
     30    UI::get(cond, set, "cond", UI::compulsory); 
     31    UI::get(mean, set, "mean", UI::compulsory); 
    3232 
    33     if (set.exists("nsamples")) { 
    34         UI::get(nsamples, set, "nsamples"); 
    35     } 
    3633 
     34        UI::get(nsamples, set, "nsamples"); 
    3735    UI::get(R, set, "R"); 
    38  
    39     if (set.exists("tolerance")) { 
    40         UI::get(tolerance, set, "tolerance"); 
    41     } 
     36        UI::get(tolerance, set, "tolerance"); 
    4237} 
    4338 

  • library/tests/test_user_info.cpp

    r425 r471  
    99using namespace bdm; 
    1010 
    11 class Passenger : public root 
    12 { 
    13 public: 
    14  
    15   Passenger() { 
    16   } 
    17 }; 
    18  
    19 class Human : public Passenger 
    20 { 
    21 public: 
    22   string name; 
    23  
    24   Human() { 
    25     name = "none"; 
    26   } 
    27  
    28   virtual void from_setting(const Setting &set) { 
    29     set.lookupValue("name", name); 
    30   } 
    31  
    32   virtual void to_setting(Setting &set) const { 
    33     Setting &name_setting = set.add("name", Setting::TypeString); 
    34     name_setting = name; 
    35   } 
    36  
    37   string to_string() { 
    38     return name; 
    39   } 
    40 }; 
    41  
    42 UIREGISTER(Human); 
    43  
    44 class Robot : public Passenger 
    45 { 
    46 public: 
    47   int number; 
    48   Array<string> software; 
    49  
    50   Robot() : software() { 
    51     number = -1; 
    52   } 
    53  
    54   virtual void from_setting(const Setting &set) { 
    55     set.lookupValue("number", number); 
    56         if( set.exists( "software" ) ) 
    57                 UI::get(software, set, "software"); 
    58   } 
    59  
    60   virtual void to_setting(Setting &set) const { 
    61     Setting &number_setting = set.add("number", Setting::TypeInt); 
    62     number_setting = number; 
    63  
    64     UI::save(software, set, "software"); 
    65   } 
    66  
    67   string to_string() { 
    68     stringstream stream; 
    69     stream << number; 
    70     for (int i = 0; i < software.length(); i++) 
    71       stream << "_" + software(i); 
    72     return stream.str(); 
    73   } 
    74 }; 
    75  
    76 UIREGISTER(Robot); 
    77  
    78 class Transport : public root 
    79 { 
    80 public: 
    81   int year; 
    82   string manufacturer; 
    83  
    84   Transport() { 
    85     year = 1900; 
    86     manufacturer = "unknown"; 
    87   } 
    88  
    89   Transport(int year, string manufacturer) 
    90       : year(year), manufacturer(manufacturer) { 
    91   } 
    92  
    93   virtual void from_setting(const Setting &set) { 
    94     set.lookupValue("year", year); 
    95     set.lookupValue("manufacturer", manufacturer); 
    96   } 
    97  
    98   virtual void to_setting(Setting &set) const { 
    99     Setting &year_setting = set.add("year", Setting::TypeInt); 
    100     year_setting = year; 
    101  
    102     Setting &manufacturer_setting = set.add("manufacturer", Setting::TypeString); 
    103     manufacturer_setting = manufacturer; 
    104   } 
    105 }; 
    106  
    107 class Car : public Transport 
    108 { 
    109 public: 
    110   int kilometers; 
    111   Array<Passenger*> passengers; 
    112  
    113   Car() : Transport() { 
    114     kilometers = 0; 
    115   } 
    116  
    117  
    118   Car(int year, string manufacturer, int kilometers) 
    119       : Transport(year, manufacturer), kilometers(kilometers) { 
    120   } 
    121  
    122   virtual void from_setting(const Setting &set) { 
    123     Transport::from_setting(set); 
    124  
    125     set.lookupValue("kilometers", kilometers); 
    126  
    127         if( set.exists( "passengers" ) ) 
    128             UI::get(passengers, set, "passengers"); 
    129   } 
    130  
    131   virtual void to_setting(Setting &set) const { 
    132     Transport::to_setting(set); 
    133  
    134     Setting &kilometers_setting = set.add("kilometers", Setting::TypeInt); 
    135     kilometers_setting = kilometers; 
    136  
    137     UI::save(passengers, set, "passengers"); 
    138   } 
    139  
    140   string to_string() { 
    141     stringstream stream; 
    142     stream << "A car made in " << year << " by " << manufacturer << ", having " << kilometers << " kilometers on the clock."; 
    143     if (passengers.length()) { 
    144       stream << "The names of passengers are as follows: "; 
    145       for (int i = 0; i < passengers.length(); i++) 
    146         stream << passengers(i)->to_string() << " "; 
    147     } 
    148     return stream.str(); 
    149   } 
    150 }; 
    151  
    152 UIREGISTER(Car); 
    153  
    154 class Bike : public Transport 
    155 { 
    156 public: 
    157   bool electricLights; 
    158   mat matr; 
    159  
    160   Bike() : Transport(), matr("2,2;3,4") { 
    161     electricLights = false; 
    162   } 
    163  
    164   Bike(int year, string manufacturer, bool electricLights) 
    165       : Transport(year, manufacturer), electricLights(electricLights) { 
    166   } 
    167  
    168   ~Bike() { 
    169   } 
    170  
    171   void from_setting(const Setting &set) { 
    172     Transport::from_setting(set); 
    173  
    174     set.lookupValue("electricLights", electricLights); 
    175  
    176         UI::get(matr, set, "matr"); 
    177   } 
    178  
    179   void to_setting(Setting &set) const { 
    180     Transport::to_setting(set); 
    181  
    182     Setting &electricLights_setting = set.add("electricLights", Setting::TypeBoolean); 
    183     electricLights_setting = electricLights; 
    184  
    185     UI::save(matr, set, "matr"); 
    186   } 
    187  
    188   string to_string() { 
    189     stringstream stream; 
    190     stream << "a bike made in " << year << " by " << manufacturer; 
    191     if (electricLights) stream << " with electric lights included"; 
    192     return stream.str(); 
    193   } 
    194 }; 
    195  
    196 UIREGISTER(Bike); 
    197  
    198 TEST(test_load) 
    199 { 
    200   UIFile in("test_user_info_input.cfg"); 
    201   auto_ptr<Transport> pepikovo(UI::build<Transport>(in, "pepikovo")); 
    202   CHECK_EQUAL(string("A car made in 1998 by audi, having 25000 kilometers on the clock.The names of passengers are as follows: Karlos Novak -1_CygWin_Matlab_Aimsun Karlosik Novacek "), pepikovo->to_string()); 
    203  
    204   auto_ptr<Transport> jardovo(UI::build<Transport>(in, "jardovo")); 
    205   CHECK_EQUAL(string("A car made in 1992 by liaz, having 1555000 kilometers on the clock."), jardovo->to_string()); 
    206  
    207   auto_ptr<Transport> ondrejovo(UI::build<Transport>(in, "ondrejovo")); 
    208   CHECK_EQUAL(string("a bike made in 1996 by author with electric lights included"), ondrejovo->to_string()); 
    209  
    210   auto_ptr<Transport> elisky(UI::build<Transport>(in, "elisky")); 
    211   CHECK_EQUAL(string("A car made in 1992 by liaz, having 1555000 kilometers on the clock."), elisky->to_string()); 
    212  
    213   auto_ptr<Transport> kati(UI::build<Transport>(in, "kati")); 
    214   CHECK_EQUAL(string("A car made in 1980 by vecernicek, having 250000 kilometers on the clock."), kati->to_string()); 
     11class Passenger : public root { 
     12public: 
     13 
     14        Passenger() { 
     15        } 
     16}; 
     17 
     18class Human : public Passenger { 
     19public: 
     20        string name; 
     21 
     22        Human() { 
     23                name = "none"; 
     24        } 
     25 
     26        virtual void from_setting ( const Setting &set ) { 
     27                UI::get ( name, set, "name" ); 
     28        } 
     29 
     30        virtual void to_setting ( Setting &set ) const { 
     31                Setting &name_setting = set.add ( "name", Setting::TypeString ); 
     32                name_setting = name; 
     33        } 
     34 
     35        string to_string() { 
     36                return name; 
     37        } 
     38}; 
     39 
     40UIREGISTER ( Human ); 
     41 
     42class Robot : public Passenger { 
     43public: 
     44        int number; 
     45        Array<string> software; 
     46 
     47        Robot() : software() { 
     48                number = -1; 
     49        } 
     50 
     51        virtual void from_setting ( const Setting &set ) { 
     52                UI::get ( number, set, "number" ); 
     53                UI::get ( software, set, "software" ); 
     54        } 
     55 
     56        virtual void to_setting ( Setting &set ) const { 
     57                Setting &number_setting = set.add ( "number", Setting::TypeInt ); 
     58                number_setting = number; 
     59 
     60                UI::save ( software, set, "software" ); 
     61        } 
     62 
     63        string to_string() { 
     64                stringstream stream; 
     65                stream << number; 
     66                for ( int i = 0; i < software.length(); i++ ) 
     67                        stream << "_" + software ( i ); 
     68                return stream.str(); 
     69        } 
     70}; 
     71 
     72UIREGISTER ( Robot ); 
     73 
     74class Transport : public root { 
     75public: 
     76        int year; 
     77        string manufacturer; 
     78 
     79        Transport() { 
     80                year = 1900; 
     81                manufacturer = "unknown"; 
     82        } 
     83 
     84        Transport ( int year, string manufacturer ) 
     85                        : year ( year ), manufacturer ( manufacturer ) { 
     86        } 
     87 
     88        virtual void from_setting ( const Setting &set ) { 
     89                UI::get ( year, set, "year" ); 
     90                UI::get ( manufacturer, set, "manufacturer" ); 
     91        } 
     92 
     93        virtual void to_setting ( Setting &set ) const { 
     94                Setting &year_setting = set.add ( "year", Setting::TypeInt ); 
     95                year_setting = year; 
     96 
     97                Setting &manufacturer_setting = set.add ( "manufacturer", Setting::TypeString ); 
     98                manufacturer_setting = manufacturer; 
     99        } 
     100}; 
     101 
     102class Car : public Transport { 
     103public: 
     104        int kilometers; 
     105        Array<Passenger*> passengers; 
     106 
     107        Car() : Transport() { 
     108                kilometers = 0; 
     109        } 
     110 
     111 
     112        Car ( int year, string manufacturer, int kilometers ) 
     113                        : Transport ( year, manufacturer ), kilometers ( kilometers ) { 
     114        } 
     115 
     116        virtual void from_setting ( const Setting &set ) { 
     117                Transport::from_setting ( set ); 
     118 
     119                UI::get ( kilometers, set, "kilometers" ); 
     120                UI::get ( passengers, set, "passengers" ); 
     121        } 
     122 
     123        virtual void to_setting ( Setting &set ) const { 
     124                Transport::to_setting ( set ); 
     125 
     126                Setting &kilometers_setting = set.add ( "kilometers", Setting::TypeInt ); 
     127                kilometers_setting = kilometers; 
     128 
     129                UI::save ( passengers, set, "passengers" ); 
     130        } 
     131 
     132        string to_string() { 
     133                stringstream stream; 
     134                stream << "A car made in " << year << " by " << manufacturer << ", having " << kilometers << " kilometers on the clock."; 
     135                if ( passengers.length() ) { 
     136                        stream << "The names of passengers are as follows: "; 
     137                        for ( int i = 0; i < passengers.length(); i++ ) 
     138                                stream << passengers ( i )->to_string() << " "; 
     139                } 
     140                return stream.str(); 
     141        } 
     142}; 
     143 
     144UIREGISTER ( Car ); 
     145 
     146class Bike : public Transport { 
     147public: 
     148        bool electricLights; 
     149        mat matr; 
     150 
     151        Bike() : Transport(), matr ( "2,2;3,4" ) { 
     152                electricLights = false; 
     153        } 
     154 
     155        Bike ( int year, string manufacturer, bool electricLights ) 
     156                        : Transport ( year, manufacturer ), electricLights ( electricLights ) { 
     157        } 
     158 
     159        ~Bike() { 
     160        } 
     161 
     162        void from_setting ( const Setting &set ) { 
     163                Transport::from_setting ( set ); 
     164 
     165                UI::get ( electricLights, set, "electricLights" ); 
     166 
     167                UI::get ( matr, set, "matr" ); 
     168        } 
     169 
     170        void to_setting ( Setting &set ) const { 
     171                Transport::to_setting ( set ); 
     172 
     173                Setting &electricLights_setting = set.add ( "electricLights", Setting::TypeBoolean ); 
     174                electricLights_setting = electricLights; 
     175 
     176                UI::save ( matr, set, "matr" ); 
     177        } 
     178 
     179        string to_string() { 
     180                stringstream stream; 
     181                stream << "a bike made in " << year << " by " << manufacturer; 
     182                if ( electricLights ) stream << " with electric lights included"; 
     183                return stream.str(); 
     184        } 
     185}; 
     186 
     187UIREGISTER ( Bike ); 
     188 
     189TEST ( test_load ) { 
     190        UIFile in ( "test_user_info_input.cfg" ); 
     191        auto_ptr<Transport> pepikovo ( UI::build<Transport> ( in, "pepikovo" ) ); 
     192        CHECK_EQUAL ( string ( "A car made in 1998 by audi, having 25000 kilometers on the clock.The names of passengers are as follows: Karlos Novak -1_CygWin_Matlab_Aimsun Karlosik Novacek " ), pepikovo->to_string() ); 
     193 
     194        auto_ptr<Transport> jardovo ( UI::build<Transport> ( in, "jardovo" ) ); 
     195        CHECK_EQUAL ( string ( "A car made in 1992 by liaz, having 1555000 kilometers on the clock." ), jardovo->to_string() ); 
     196 
     197        auto_ptr<Transport> ondrejovo ( UI::build<Transport> ( in, "ondrejovo" ) ); 
     198        CHECK_EQUAL ( string ( "a bike made in 1996 by author with electric lights included" ), ondrejovo->to_string() ); 
     199 
     200        auto_ptr<Transport> elisky ( UI::build<Transport> ( in, "elisky" ) ); 
     201        CHECK_EQUAL ( string ( "A car made in 1992 by liaz, having 1555000 kilometers on the clock." ), elisky->to_string() ); 
     202 
     203        auto_ptr<Transport> kati ( UI::build<Transport> ( in, "kati" ) ); 
     204        CHECK_EQUAL ( string ( "A car made in 1980 by vecernicek, having 250000 kilometers on the clock." ), kati->to_string() ); 
    215205} 
    216206 
    217 TEST(test_save) 
    218 { 
    219   UIFile in("test_user_info_input.cfg"); 
    220   auto_ptr<Transport> pepikovo(UI::build<Transport>(in, "pepikovo")); 
    221  
    222   Car audi(1968, "zyl", 200); 
    223   Car liaz(1989, "skoda", 1000); 
    224   Bike author(2001, "noname", false); 
    225   UIFile out; 
    226  
    227   UI::save(&audi, out, "marty"); 
    228   UI::save(&liaz, out, "bohousovo"); 
    229   UI::save(&author, out, "karlovo"); 
    230   UI::save(pepikovo.get(), out, "pepikovo"); 
    231   out.save("testUI_out.cfg"); 
    232  
    233   string expected(load_test_file("testUI_out.matrix")); 
    234   string actual(load_test_file("testUI_out.cfg")); 
    235   CHECK_EQUAL(expected, actual); 
     207TEST ( test_save ) { 
     208        UIFile in ( "test_user_info_input.cfg" ); 
     209        auto_ptr<Transport> pepikovo ( UI::build<Transport> ( in, "pepikovo" ) ); 
     210 
     211        Car audi ( 1968, "zyl", 200 ); 
     212        Car liaz ( 1989, "skoda", 1000 ); 
     213        Bike author ( 2001, "noname", false ); 
     214        UIFile out; 
     215 
     216        UI::save ( &audi, out, "marty" ); 
     217        UI::save ( &liaz, out, "bohousovo" ); 
     218        UI::save ( &author, out, "karlovo" ); 
     219        UI::save ( pepikovo.get(), out, "pepikovo" ); 
     220        out.save ( "testUI_out.cfg" ); 
     221 
     222        string expected ( load_test_file ( "testUI_out.matrix" ) ); 
     223        string actual ( load_test_file ( "testUI_out.cfg" ) ); 
     224        CHECK_EQUAL ( expected, actual ); 
    236225}