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