/Users/huttone/Devel/sedflux-new/sedflux/trunk/ew/sed/sed_cell_unit_test.c

Go to the documentation of this file.
00001 #include "sed_cell.h"
00002 #include <utils/utils.h>
00003 #include <check.h>
00004 
00005 START_TEST ( test_cell_new )
00006 {
00007    {
00008       Sed_cell c = sed_cell_new( 5 );
00009       fail_if    ( c==NULL                         , "NULL returned instead of a new cell"  );
00010       fail_unless( sed_cell_n_types(c)==5          , "Incorrect number of grain types"      );
00011       fail_unless( sed_cell_is_empty(c)            , "Newly created cell should be empty"   );
00012       fail_unless( fabs( sed_cell_age(c) ) < 1e-12 , "Newly created cell should have 0 age" );
00013       fail_unless( sed_cell_is_valid(c)            , "Newly created cell should be valid"   );
00014 
00015       sed_cell_destroy( c );
00016    }
00017 
00018    {
00019       Sed_cell c = sed_cell_new( 0 );
00020 
00021       fail_unless( c==NULL , "A cell of 0 size is not allowed" );
00022       
00023       sed_cell_destroy( c );
00024    }
00025 
00026    {
00027       Sed_cell c = sed_cell_new( -1 );
00028 
00029       fail_unless( c==NULL , "A cell of negative size is not allowed" );
00030       
00031       sed_cell_destroy( c );
00032    }
00033 
00034 }
00035 END_TEST
00036 
00037 START_TEST( test_cell_new_classed )
00038 {
00039    Sed_cell c = sed_cell_new_classed( NULL , 27.2 , S_SED_TYPE_SAND|S_SED_TYPE_SILT|S_SED_TYPE_CLAY );
00040 
00041    fail_unless( sed_cell_is_valid(c) );
00042    fail_unless( sed_cell_mass(c)>=0  );
00043    fail_unless( !sed_cell_is_empty(c) );
00044 
00045    sed_cell_destroy(c);
00046 }
00047 END_TEST
00048 
00049 START_TEST (test_cell_destroy)
00050 {
00051    {
00052       Sed_cell c = sed_cell_new( 1 );
00053 
00054       c = sed_cell_destroy( c );
00055 
00056       fail_unless( c==NULL , "Destroy function should return NULL" );
00057    }
00058 }
00059 END_TEST
00060 
00061 START_TEST (test_cell_cmp)
00062 {
00063    gboolean same;
00064 
00065    {
00066       Sed_cell a = sed_cell_new( 3 );
00067 
00068       same = sed_cell_is_same( a , a );
00069 
00070       fail_unless( same , "Cell comparison failed" );
00071 
00072       sed_cell_destroy( a );
00073    }
00074 
00075    {
00076       Sed_cell a = sed_cell_new( 3 );
00077       Sed_cell b = sed_cell_new( 1 );
00078 
00079       same = sed_cell_is_same( a , b );
00080 
00081       fail_unless( !same , "Cells must have same size" );
00082       
00083       sed_cell_destroy( a );
00084       sed_cell_destroy( b );
00085    }
00086 
00087    {
00088       Sed_cell a = sed_cell_new( 3 );
00089       Sed_cell b = sed_cell_new( 3 );
00090 
00091       sed_cell_resize( a , 1. );
00092       sed_cell_resize( b , 2. );
00093 
00094       same = sed_cell_is_same( a , b );
00095 
00096       fail_unless( !same , "Cells must have same thickness" );
00097       
00098       sed_cell_destroy( a );
00099       sed_cell_destroy( b );
00100    }
00101 
00102 }
00103 END_TEST
00104 
00105 START_TEST (test_cell_copy)
00106 {
00107 
00108    {
00109       Sed_cell a = sed_cell_new( 5 );
00110       Sed_cell b;
00111 
00112       sed_cell_resize( a , 100 );
00113 
00114       b = sed_cell_copy( NULL , a );
00115 
00116       fail_if    ( a == b            , "Duplicate cell should not be the original" );
00117       fail_unless( sed_cell_is_same(a,b) , "Failed to duplicate cell" );
00118 
00119       sed_cell_destroy( a );
00120       sed_cell_destroy( b );
00121    }
00122 
00123    {
00124       Sed_cell a = sed_cell_new( 5 );
00125       Sed_cell b = sed_cell_new( 5 );
00126 
00127       sed_cell_resize( a , 100 );
00128 
00129       sed_cell_copy( b , a );
00130 
00131       fail_unless( sed_cell_is_same(a,b) , "Failed to copy cell" );
00132 
00133       sed_cell_destroy( a );
00134       sed_cell_destroy( b );
00135    }
00136 
00137 }
00138 END_TEST
00139 
00140 START_TEST ( test_cell_clear )
00141 {
00142    {
00143       Sed_cell c = sed_cell_new( 5 );
00144 
00145       fail_unless( sed_cell_clear(c)==c , "Should return the cleared cell" );
00146 
00147       sed_cell_destroy( c );
00148    }
00149    {
00150       Sed_cell c = sed_cell_new( 5 );
00151       double f[5] = { .2 , .2 , .2 , .2 , .2 };
00152 
00153       sed_cell_resize ( c , 10 );
00154       sed_cell_set_age( c , 33 );
00155       sed_cell_set_fraction( c , f );
00156 
00157       sed_cell_clear( c );
00158 
00159       fail_unless( sed_cell_is_empty(c)         , "Thickness not cleared" );
00160       fail_unless( fabs(sed_cell_age(c)) <1e-12 , "Age not cleared"       );
00161    }
00162 }
00163 END_TEST
00164 
00165 START_TEST ( test_cell_set_and_get_functions )
00166 {
00167    {
00168       gssize n;
00169       Sed_cell c = sed_cell_new( 5 );
00170       double f[5] = { .2 , .2 , .2 , .2 , .2 };
00171 
00172       sed_cell_resize( c , 2 );
00173       fail_unless( sed_cell_is_size(c,2)              , "Size not set correctly" );
00174       fail_unless( fabs(sed_cell_size_0(c)-2) < 1e-12 , "Original size not set correctly" );
00175 
00176       sed_cell_set_age( c , 33 );
00177       fail_unless( fabs(sed_cell_age(c)-33) < 1e-12 , "Age not set correctly" );
00178 
00179       sed_cell_set_facies( c , S_FACIES_PLUME );
00180       fail_unless( sed_cell_facies(c)==S_FACIES_PLUME , "Facies not set correctly" );
00181 
00182       sed_cell_set_facies( c , S_FACIES_WAVE );
00183       fail_unless( sed_cell_facies(c)==S_FACIES_WAVE , "Facies not reset correctly" );
00184 
00185       sed_cell_add_facies( c , S_FACIES_RIVER );
00186       fail_unless( sed_cell_facies(c)&S_FACIES_WAVE  , "Adding a facies should keep original" );
00187       fail_unless( sed_cell_facies(c)&S_FACIES_RIVER , "New facies not added correctly" );
00188 
00189       sed_cell_set_fraction( c , f );
00190       f[0] = 1;
00191       fail_if( fabs( sed_cell_fraction(c,0)-1. ) < 1e-12 , "Values should be copied" );
00192       for ( n=0 ; n<sed_cell_n_types(c) ; n++ )
00193          fail_unless( fabs( sed_cell_fraction(c,n)-.2 ) < 1e-12 , "Fraction not set correctly" );
00194 
00195       sed_cell_set_pressure( c , 1000 );
00196       fail_unless( fabs(sed_cell_pressure(c)-1000) < 1e-12 , "Pressure not set correctly" );
00197 
00198       sed_cell_destroy( c );
00199    }
00200 }
00201 END_TEST
00202 
00203 START_TEST ( test_cell_add )
00204 {
00205 
00206    {
00207       Sed_cell a = sed_cell_new( 5 );
00208       Sed_cell b = sed_cell_new( 5 );
00209 
00210       sed_cell_set_equal_fraction( a );
00211       sed_cell_resize( a , 1 );
00212 
00213       sed_cell_add( b , a );
00214 
00215       fail_unless( sed_cell_is_same(a,b) , "Adding to an empty cell should produce a copy" );
00216 
00217       sed_cell_destroy( a );
00218       sed_cell_destroy( b );
00219    }
00220 
00221    {
00222       Sed_cell a = sed_cell_new( 5 );
00223       Sed_cell b = sed_cell_new( 5 );
00224 
00225       sed_cell_set_equal_fraction( a );
00226       sed_cell_resize( a , 1 );
00227       sed_cell_set_age( a , 1 );
00228 
00229       sed_cell_set_equal_fraction( b );
00230       sed_cell_resize( b , 2 );
00231       sed_cell_set_age( b , 4 );
00232 
00233       sed_cell_add( b , a );
00234 
00235       fail_unless(  sed_cell_is_size(b,3)            , "New size should be the sum of cell sizes" );
00236       fail_if    ( !sed_cell_is_size(a,1)            , "Size of the original cell shouldn't change" );
00237       fail_unless( fabs(sed_cell_age (b)-3.) < 1e-12 , "New age should be a weighted average" );
00238 
00239       sed_cell_destroy( a );
00240       sed_cell_destroy( b );
00241    }
00242 }
00243 END_TEST
00244 
00245 START_TEST ( test_cell_resize )
00246 {
00247    {
00248       gssize n;
00249       Sed_cell c = sed_cell_new( 5 );
00250 
00251       sed_cell_set_age     ( c , 10 );
00252       sed_cell_set_pressure( c , 10 );
00253       sed_cell_set_facies  ( c , S_FACIES_PLUME );
00254 
00255       sed_cell_set_equal_fraction( c );
00256 
00257       sed_cell_resize( c , 1 );
00258       fail_unless( fabs(sed_cell_size  (c)-1.) < 1e-12 , "Size not initialized correctly" );
00259       fail_unless( fabs(sed_cell_size_0(c)-1.) < 1e-12 , "Original size not initialized correctly" );
00260 
00261       sed_cell_resize( c , .5 );
00262       fail_unless( fabs(sed_cell_size  (c)-.5) < 1e-12 , "Size not reset correctly" );
00263       fail_unless( fabs(sed_cell_size_0(c)-.5) < 1e-12 , "Resize must maintain degree of compaction" );
00264 
00265       sed_cell_compact( c , .25 );
00266       fail_unless( fabs(sed_cell_size  (c)-.25) < 1e-12 , "Cell not compacted correctly" );
00267       fail_unless( fabs(sed_cell_size_0(c)-.5 ) < 1e-12 , "Compaction must not affect original size" );
00268 
00269       fail_unless( fabs( sed_cell_age(c)-10. ) < 1e-12      , "Resizing should not change age" );
00270       fail_unless( fabs( sed_cell_pressure(c)-10. ) < 1e-12 , "Resizing should not change pressure" );
00271       fail_unless( sed_cell_facies(c)==S_FACIES_PLUME       , "Resizing should not change facies" );
00272 
00273       for ( n=0 ; n<sed_cell_n_types(c) ; n++ )
00274          fail_unless( fabs(sed_cell_fraction(c,n)-.2)<1e-12 , "Resizing should not change fraction" );
00275 
00276       sed_cell_destroy( c );
00277    }
00278 }
00279 END_TEST
00280 
00281 START_TEST ( test_cell_resize_neg )
00282 {
00283    Sed_cell c = sed_cell_new( 5 );
00284 
00285    sed_cell_resize( c , -1 );
00286 
00287    fail_unless( sed_cell_is_clear(c) , "Negative resize should clear cell" );
00288 
00289    sed_cell_destroy( c );
00290 }
00291 END_TEST
00292 
00293 START_TEST ( test_cell_resize_zero )
00294 {
00295    Sed_cell c = sed_cell_new( 5 );
00296 
00297    sed_cell_resize( c , 0 );
00298 
00299    fail_unless( sed_cell_is_clear(c) , "Zero resize should clear cell" );
00300 
00301    sed_cell_destroy( c );
00302 }
00303 END_TEST
00304 
00305 START_TEST ( test_cell_separate_cell )
00306 {
00307    {
00308       double f_0[5] = { 1. , 0 , 0 , 0 , 0 };
00309       double   f[5] = { .2 , .2 , .2 , .2 , .2 };
00310       Sed_cell a = sed_cell_new_sized( 5 , 5 , f   );
00311       Sed_cell b = sed_cell_new_sized( 5 , 1 , f_0 );
00312       Sed_cell b_copy;
00313 
00314       b_copy = sed_cell_dup( b );
00315 
00316       sed_cell_separate_cell( a , b );
00317 
00318       fail_unless( sed_cell_is_same(b_copy,b)                 , "Right-hand cell should not change" );
00319       fail_unless( sed_cell_is_size(a,4)                  , "Separated cell not resized correctly" );
00320       fail_unless( fabs( sed_cell_fraction(a,0) ) < 1e-12 , "Incorrect sediment type removed" );
00321       fail_unless( sed_cell_is_valid(a)                   , "Separation must produce a valid cell" );
00322 
00323       sed_cell_destroy( a );
00324       sed_cell_destroy( b );
00325       sed_cell_destroy( b_copy );
00326    }
00327 }
00328 END_TEST
00329 
00330 START_TEST ( test_cell_separate )
00331 {
00332    {
00333       double f[5] = { .2 , .2 , .2 , .2 , .2 };
00334       Sed_cell a = sed_cell_new_sized( 5 , 1 , f );
00335       Sed_cell b;
00336 
00337       b = sed_cell_separate( a , f , .25 , NULL );
00338 
00339       fail_unless( sed_cell_is_valid(b)    , "Separated cell must be a valid cell"   );
00340       fail_unless( sed_cell_is_size(a,.75) , "Original cell not separated correctly" );
00341       fail_unless( sed_cell_is_size(b,.25) , "Separated cell not sized correctly"    );
00342 
00343       sed_cell_destroy( a );
00344       sed_cell_destroy( b );
00345    }
00346 
00347    {
00348       double f[5] = { .2 , .2 , .2 , .2 , .2 };
00349       Sed_cell a = sed_cell_new_sized( 5 , 1 , f );
00350       Sed_cell b = sed_cell_new_sized( 5 , 2 , f );
00351       Sed_cell b_copy = b;
00352       Sed_cell a_after;
00353       Sed_cell b_after;
00354 
00355       sed_cell_set_age   ( a , 1              );
00356       sed_cell_set_facies( a , S_FACIES_WAVE  );
00357       sed_cell_set_age   ( b , 10             );
00358       sed_cell_set_facies( b , S_FACIES_PLUME );
00359 
00360       a_after = sed_cell_dup( a );
00361       b_after = sed_cell_dup( a );
00362 
00363       sed_cell_resize( a_after , .75 );
00364       sed_cell_resize( b_after , .25 );
00365 
00366       b = sed_cell_separate( a , f , .25 , b );
00367 
00368       fail_if    ( b!=b_copy               , "Separated cell should be provided cell" );
00369       fail_unless( sed_cell_is_valid(b)    , "Separated cell must be a valid cell" );
00370       fail_unless( sed_cell_is_same(a,a_after) , "Original cell not separated correctly" );
00371       fail_unless( sed_cell_is_same(b,b_after) , "Separated cell not separated correctly" );
00372 
00373       sed_cell_destroy( a );
00374       sed_cell_destroy( b );
00375       sed_cell_destroy( a_after );
00376       sed_cell_destroy( b_after );
00377    }
00378 }
00379 END_TEST
00380 
00381 START_TEST ( test_cell_separate_thickness )
00382 {
00383    double f[5] = { .2 , .2 , .2 , .2 , .2 };
00384    Sed_cell a = sed_cell_new_sized( 5 , 1 , f );
00385 
00386    {
00387       Sed_cell b;
00388       Sed_cell a_after;
00389       Sed_cell b_after;
00390 
00391       sed_cell_set_age   ( a , 1              );
00392       sed_cell_set_facies( a , S_FACIES_WAVE  );
00393 
00394       a_after = sed_cell_dup( a );
00395       b_after = sed_cell_dup( a );
00396 
00397       sed_cell_resize( a_after , .25 );
00398       sed_cell_resize( b_after , .75 );
00399 
00400       b = sed_cell_separate_thickness( a , .75 , NULL );
00401 
00402       fail_unless( sed_cell_is_valid(b)        , "Separated cell must be a valid cell" );
00403       fail_unless( sed_cell_is_same(a,a_after) , "Original cell not separated correctly" );
00404       fail_unless( sed_cell_is_same(b,b_after) , "Separated cell not separated correctly" );
00405 
00406       sed_cell_resize( a_after , .0  );
00407       sed_cell_resize( b_after , .25 );
00408 
00409       b = sed_cell_separate_thickness( a , .75 , NULL );
00410 
00411       fail_unless( sed_cell_is_valid(b)        , "Separated cell must be a valid cell" );
00412       fail_unless( sed_cell_is_same(a,a_after) , "Original cell not separated correctly" );
00413       fail_unless( sed_cell_is_same(b,b_after) , "Separated cell not separated correctly" );
00414 
00415       sed_cell_destroy( a );
00416       sed_cell_destroy( b );
00417       sed_cell_destroy( a_after );
00418       sed_cell_destroy( b_after );
00419    }
00420 }
00421 END_TEST
00422 
00423 START_TEST ( test_cell_separate_fraction )
00424 {
00425    {
00426       double f[5] = { 1. , 0  , .5 , .5  , 0  };
00427       double f_0[5] = { .4 , .0 , .2 , .2 , .2 };
00428       Sed_cell a = sed_cell_new_sized( 5 , 1 , f_0 );
00429       Sed_cell b;
00430 
00431       b = sed_cell_separate_fraction( a , f , NULL );
00432 
00433       fail_unless( sed_cell_is_valid(a)    , "Separated cell must be a valid cell" );
00434       fail_unless( sed_cell_is_valid(b)    , "Separated cell must be a valid cell" );
00435       fail_unless( sed_cell_is_size(a,.4)  , "Original cell not sized correctly"   );
00436       fail_unless( sed_cell_is_size(b,.6)  , "Separated cell not sized correctly"  );
00437 
00438       sed_cell_destroy( a );
00439       sed_cell_destroy( b );
00440    }
00441 }
00442 END_TEST
00443 
00444 START_TEST ( test_cell_is_valid )
00445 {
00446    {
00447       Sed_cell a = sed_cell_new( 3 );
00448       double f[3] = { 0. , 0. , 0. };
00449 
00450       fail_unless( !sed_cell_is_valid(NULL) , "NULL is an invalid cell" );
00451 
00452       sed_cell_resize( a , 0 );
00453       sed_cell_set_fraction( a , f );
00454       fail_unless( sed_cell_is_valid(a) , "A cell with no size can be non-normalized" );
00455 
00456       sed_cell_resize( a , 1 );
00457       fail_unless( !sed_cell_is_valid(a) , "A cell with size must be normalized" );
00458 
00459       f[0] = 1, f[1] = 1, f[2] = 1;
00460       sed_cell_set_fraction( a , f );
00461       fail_unless( !sed_cell_is_valid(a) , "Fractions must sum to 1" );
00462 
00463       f[0] = -1;
00464       fail_unless( !sed_cell_is_valid(a) , "Fractions must be positive" );
00465 
00466       sed_cell_destroy( a );
00467    }
00468 
00469    {
00470       Sed_cell a = sed_cell_new( 3 );
00471 
00472       fail_unless( sed_cell_is_valid(a) , "A newly created empty cell is valid" );
00473 
00474       sed_cell_destroy( a );
00475    }
00476 
00477    {
00478       double f[3] = { .75 , .25 , 0 };
00479       Sed_cell a = sed_cell_new_sized( 3 , 2 , f );
00480 
00481       fail_unless( sed_cell_is_valid(a) , "A newly created filled cell is valid" );
00482 
00483       sed_cell_destroy( a );
00484    }
00485 }
00486 END_TEST
00487 
00488 START_TEST( test_cell_array_delete_empty )
00489 {
00490    Sed_cell* a      = NULL;
00491    double    f_0[5] = { .4 , .0 , .2 , .2 , .2 };
00492    Sed_cell  b      = NULL;
00493    gint      i;
00494 
00495    for ( i=0 ; i<10 ; i++ )
00496    {
00497       b = sed_cell_new_sized( 5 , i+1 , f_0 );
00498       eh_strv_append( &a , b );
00499    }
00500 
00501    fail_unless( g_strv_length( a )==10 );
00502 
00503    sed_cell_clear( a[2] );
00504    a = sed_cell_array_delete_empty( a );
00505    fail_unless( g_strv_length( a )==9 , "Error deleting element" );
00506 
00507    sed_cell_clear( a[0] );
00508    a = sed_cell_array_delete_empty( a );
00509    fail_unless( g_strv_length( a )==8 , "Error deleting first element" );
00510 
00511    sed_cell_clear( a[2] );
00512    sed_cell_clear( a[3] );
00513    a = sed_cell_array_delete_empty( a );
00514    fail_unless( g_strv_length( a )==6 , "Error deleting successive elements" );
00515 
00516    sed_cell_clear( a[5] );
00517    a = sed_cell_array_delete_empty( a );
00518    fail_unless( g_strv_length( a )==5 , "Error deleting last element" );
00519 
00520    sed_cell_clear( a[3] );
00521    sed_cell_clear( a[4] );
00522    a = sed_cell_array_delete_empty( a );
00523    fail_unless( g_strv_length( a )==3 , "Error deleting last two element" );
00524 
00525    sed_cell_clear( a[0] );
00526    sed_cell_clear( a[1] );
00527    sed_cell_clear( a[2] );
00528    a = sed_cell_array_delete_empty( a );
00529    fail_unless( a==NULL , "Error deleting all elements" );
00530 
00531    sed_cell_array_free( a );
00532 }
00533 END_TEST
00534 
00535 Suite *sed_cell_suite( void )
00536 {
00537    Suite *s = suite_create( "Sed_cell" );
00538    TCase *test_case_core  = tcase_create( "Core" );
00539    TCase *test_case_array = tcase_create( "Cell Array" );
00540 
00541    suite_add_tcase( s , test_case_core  );
00542    suite_add_tcase( s , test_case_array );
00543 
00544    tcase_add_test( test_case_core , test_cell_new         );
00545    tcase_add_test( test_case_core , test_cell_new_classed );
00546    tcase_add_test( test_case_core , test_cell_destroy);
00547    tcase_add_test( test_case_core , test_cell_cmp);
00548    tcase_add_test( test_case_core , test_cell_copy);
00549    tcase_add_test( test_case_core , test_cell_clear );
00550    tcase_add_test( test_case_core , test_cell_set_and_get_functions );
00551    tcase_add_test( test_case_core , test_cell_add );
00552    tcase_add_test( test_case_core , test_cell_resize );
00553    tcase_add_test( test_case_core , test_cell_resize_neg );
00554    tcase_add_test( test_case_core , test_cell_resize_zero );
00555    tcase_add_test( test_case_core , test_cell_separate_cell );
00556    tcase_add_test( test_case_core , test_cell_separate );
00557    tcase_add_test( test_case_core , test_cell_separate_thickness );
00558    tcase_add_test( test_case_core , test_cell_separate_fraction );
00559    tcase_add_test( test_case_core , test_cell_is_valid );
00560 
00561    tcase_add_test( test_case_array , test_cell_array_delete_empty );
00562 
00563    return s;
00564 }
00565 
00566 int test_sed_cell( void )
00567 {
00568    int n;
00569 
00570    {
00571       Suite *s = sed_cell_suite();
00572       SRunner *sr = srunner_create( s );
00573 
00574       srunner_run_all( sr , CK_NORMAL );
00575       n = srunner_ntests_failed( sr );
00576       srunner_free( sr );
00577    }
00578 
00579    return n;
00580 }
00581 
00582 

Generated on Fri Jan 4 18:04:15 2008 for sedflux by  doxygen 1.5.2