00001 #include "utils/utils.h" 00002 #include <check.h> 00003 00004 #include "sed_column.h" 00005 00006 START_TEST ( test_sed_column_new ) 00007 { 00008 { 00009 Sed_column c = sed_column_new( 5 ); 00010 00011 fail_if ( c==NULL , "NULL is not a valid column" ); 00012 fail_unless( sed_column_len(c)==0 , "A new column is empty" ); 00013 fail_unless( fabs(sed_column_thickness(c))<1e-12 , "A new column has no thickness" ); 00014 fail_unless( fabs(sed_column_base_height(c))<=0 , "Initial elevation is 0" ); 00015 fail_unless( fabs(sed_column_z_res(c)-1)<=0 , "Default resolution is 1" ); 00016 fail_unless( fabs(sed_column_x_position(c))<=0 , "Initial x-position is 1" ); 00017 fail_unless( fabs(sed_column_y_position(c))<=0 , "Initial y-position is 1" ); 00018 00019 sed_column_destroy( c ); 00020 } 00021 } 00022 END_TEST 00023 00024 START_TEST ( test_sed_column_new_neg ) 00025 { 00026 Sed_column c = sed_column_new( -1 ); 00027 00028 fail_unless( c==NULL , "A column of negative length is not allowed" ); 00029 } 00030 END_TEST 00031 00032 START_TEST ( test_sed_column_new_zero ) 00033 { 00034 Sed_column c = sed_column_new( 0 ); 00035 00036 fail_unless( c==NULL , "A column of zero length is not allowed" ); 00037 00038 } 00039 END_TEST 00040 00041 START_TEST ( test_sed_column_destroy ) 00042 { 00043 Sed_column c = sed_column_new( 5 ); 00044 00045 c = sed_column_destroy(c); 00046 00047 fail_unless( c==NULL , "Destroyed column should be NULL" ); 00048 } 00049 END_TEST 00050 00051 START_TEST ( test_sed_column_copy ) 00052 { 00053 Sed_column c_1 = sed_column_new( 5 ); 00054 Sed_column c_2 = sed_column_new( 55 ); 00055 Sed_column c_3; 00056 00057 sed_column_set_base_height( c_1 , 16 ); 00058 sed_column_set_z_res ( c_1 , 42 ); 00059 00060 c_3 = sed_column_copy( c_2 , c_1 ); 00061 00062 fail_if ( c_1==c_2 , "A copy of the column should be made" ); 00063 fail_unless( c_2==c_3 , "The copy should not be a new column" ); 00064 fail_unless( sed_column_is_same_data(c_1,c_2) , "Column data not copied properly" ); 00065 fail_unless( sed_column_is_same(c_1,c_2) , "Column cells not copied properly" ); 00066 00067 sed_column_destroy( c_1 ); 00068 sed_column_destroy( c_2 ); 00069 } 00070 END_TEST 00071 00072 START_TEST ( test_sed_column_copy_null ) 00073 { 00074 Sed_column c_1 = sed_column_new( 5 ); 00075 Sed_column c_2; 00076 00077 sed_column_set_base_height( c_1 , 16 ); 00078 sed_column_set_z_res ( c_1 , 42 ); 00079 00080 c_2 = sed_column_copy( NULL , c_1 ); 00081 00082 fail_if ( c_1==NULL , "NULL destination should duplicate" ); 00083 fail_if ( c_1==c_2 , "A copy of the column should be made" ); 00084 fail_unless( sed_column_is_same_data(c_1,c_2) , "Column data not copied properly" ); 00085 fail_unless( sed_column_is_same(c_1,c_2) , "Column cells not copied properly" ); 00086 00087 sed_column_destroy( c_1 ); 00088 sed_column_destroy( c_2 ); 00089 } 00090 END_TEST 00091 00092 START_TEST ( test_sed_column_clear ) 00093 { 00094 Sed_column c_0; 00095 Sed_column c = sed_column_new( 5 ); 00096 Sed_cell cell = sed_cell_new_classed( NULL , 27.2 , S_SED_TYPE_MUD ); 00097 00098 sed_column_set_z_res ( c , 5 ); 00099 sed_column_set_x_position ( c , 5 ); 00100 sed_column_set_y_position ( c , 5 ); 00101 sed_column_set_base_height( c , 5 ); 00102 00103 sed_column_add_cell( c , cell ); 00104 00105 c_0 = sed_column_clear( c ); 00106 00107 fail_unless( c_0==c , "Cleared column should be returned" ); 00108 fail_unless( sed_column_is_empty(c) , "Cleared column should be empty" ); 00109 fail_unless( sed_column_mass_is(c,0) , "Cleared column should have no mass" ); 00110 fail_unless( sed_column_len(c)==0 , "Cleared column length should be zero" ); 00111 00112 if ( fabs( sed_column_z_res(c) -5 ) > 1e-12 00113 || fabs( sed_column_x_position(c) -5 ) > 1e-12 00114 || fabs( sed_column_y_position(c) -5 ) > 1e-12 00115 || fabs( sed_column_base_height(c)-5 ) > 1e-12 ) 00116 fail( "Cleared column data should not change" ); 00117 00118 sed_column_destroy( c ); 00119 sed_cell_destroy( cell ); 00120 } 00121 END_TEST 00122 00123 START_TEST ( test_sed_column_rebin ) 00124 { 00125 Sed_column c = sed_column_new( 5 ); 00126 Sed_cell cell = sed_cell_new_classed( NULL , 150.5 , S_SED_TYPE_SAND ); 00127 Sed_column c_0; 00128 double mass_0, mass_1; 00129 00130 sed_column_stack_cell( c , cell ); 00131 00132 mass_0 = sed_column_mass ( c ); 00133 c_0 = sed_column_rebin( c ); 00134 mass_1 = sed_column_mass ( c ); 00135 00136 fail_unless( c_0==c , "Rebin returns the rebinned column" ); 00137 fail_unless( fabs(mass_0-mass_1)<1e-12 , "Rebinned column should have same mass" ); 00138 fail_unless( sed_column_len(c)==151 , "Rebinned column has wrong length" ); 00139 00140 sed_cell_destroy ( cell ); 00141 sed_column_destroy( c ); 00142 } 00143 END_TEST 00144 00145 START_TEST ( test_sed_column_destroy_null ) 00146 { 00147 Sed_column c = sed_column_destroy( NULL ); 00148 00149 fail_unless( c==NULL , "Destroyed column should be NULL" ); 00150 } 00151 END_TEST 00152 00153 START_TEST ( test_sed_column_set_height ) 00154 { 00155 Sed_column c = sed_column_new( 5 ); 00156 Sed_column c_0; 00157 00158 c_0 = sed_column_set_base_height( c , 33 ); 00159 00160 fail_unless( c==c_0 , "Source column not returned in set function" ); 00161 fail_unless( fabs( sed_column_base_height(c)-33 ) < 1e-12 , "Column height not set properly" ); 00162 00163 sed_column_destroy( c ); 00164 } 00165 END_TEST 00166 00167 START_TEST ( test_sed_column_height ) 00168 { 00169 Sed_column c = sed_column_new( 5 ); 00170 Sed_cell s = sed_cell_new_classed( NULL , 10. , S_SED_TYPE_SAND ); 00171 double top, base; 00172 00173 sed_column_set_base_height( c , 142 ); 00174 sed_column_add_cell( c , s ); 00175 00176 top = sed_column_top_height (c); 00177 base = sed_column_base_height(c); 00178 fail_unless( fabs( top-152 ) < 1e-12 , "Top height not returned correctly" ); 00179 fail_unless( fabs( base-142 ) < 1e-12 , "Base height not returned correctly" ); 00180 00181 sed_cell_destroy( s ); 00182 sed_column_destroy( c ); 00183 } 00184 END_TEST 00185 00186 START_TEST ( test_sed_column_height_empty ) 00187 { 00188 Sed_column c = sed_column_new( 5 ); 00189 double top, base; 00190 00191 sed_column_set_base_height( c , 15 ); 00192 00193 top = sed_column_top_height ( c ); 00194 base = sed_column_base_height( c ); 00195 00196 fail_unless( fabs( base - 15. ) < 1e-12 , "Incorrect base height for empty column returned" ); 00197 fail_unless( fabs( base - top ) < 1e-12 , "For empty column, top height is the same as base height" ); 00198 } 00199 END_TEST 00200 00201 START_TEST ( test_sed_column_height_null ) 00202 { 00203 double top = sed_column_top_height( NULL ); 00204 double base = sed_column_base_height( NULL ); 00205 00206 fail_unless( fabs( top ) < 1e-12 , "Height to the top of a NULL column is 0" ); 00207 fail_unless( fabs( base ) < 1e-12 , "Height to the base of a NULL column is 0" ); 00208 } 00209 END_TEST 00210 00211 START_TEST ( test_sed_column_set_x_position ) 00212 { 00213 Sed_column c = sed_column_new( 5 ); 00214 Sed_column c_0; 00215 00216 c_0 = sed_column_set_x_position( c , 3.14 ); 00217 00218 fail_unless( c==c_0 , "Source column not returned in set function" ); 00219 fail_unless( fabs( sed_column_x_position(c)-3.14 ) < 1e-12 , "Column x-position not set properly" ); 00220 00221 sed_column_destroy( c ); 00222 } 00223 END_TEST 00224 00225 START_TEST ( test_sed_column_set_y_position ) 00226 { 00227 Sed_column c = sed_column_new( 5 ); 00228 Sed_column c_0; 00229 00230 c_0 = sed_column_set_y_position( c , 2.78 ); 00231 00232 fail_unless( c==c_0 , "Source column not returned in set function" ); 00233 fail_unless( fabs( sed_column_y_position(c)-2.78 ) < 1e-12 , "Column y-position not set properly" ); 00234 00235 sed_column_destroy( c ); 00236 } 00237 END_TEST 00238 00239 START_TEST ( test_sed_column_set_z_res ) 00240 { 00241 Sed_column c = sed_column_new( 5 ); 00242 Sed_column c_0; 00243 00244 c_0 = sed_column_set_z_res( c , .707 ); 00245 00246 fail_unless( c==c_0 , "Source column not returned in set function" ); 00247 fail_unless( fabs( sed_column_z_res(c)-.707 ) < 1e-12 , "Column z resolution not set properly" ); 00248 00249 sed_column_destroy( c ); 00250 } 00251 END_TEST 00252 00253 START_TEST ( test_sed_column_stack_cells_loc ) 00254 { 00255 Sed_cell* c_arr = NULL; 00256 Sed_column c = sed_column_new( 5 ); 00257 double mass_in = 0; 00258 gint i; 00259 00260 for ( i=0 ; i<10 ; i++ ) 00261 { 00262 eh_strv_append( &c_arr , sed_cell_new_classed( NULL , 1. , S_SED_TYPE_SAND ) ); 00263 mass_in += sed_cell_mass( c_arr[i] ); 00264 } 00265 00266 sed_column_stack_cells_loc( c , c_arr ); 00267 00268 fail_unless( sed_column_len(c)==g_strv_length(c_arr) , "Column not resized correctly" ); 00269 fail_unless( eh_compare_dbl( sed_column_mass(c) , mass_in , 1e-12 ) , "Column mass should match cell mass" ); 00270 fail_unless( eh_compare_dbl( sed_column_thickness(c) , 10. , 1e-12 ) , "Column thickness should match cell thickness" ); 00271 00272 for ( i=0 ; i<10 ; i++ ) 00273 fail_if( sed_column_nth_cell(c,i)!=c_arr[i] , "Sed_cell locations should be set" ); 00274 00275 eh_free( c_arr ); 00276 sed_column_destroy( c ); 00277 } 00278 END_TEST 00279 00280 START_TEST ( test_sed_column_add_cell ) 00281 { 00282 Sed_column c = sed_column_new( 5 ); 00283 Sed_cell s = sed_cell_new_classed( NULL , 1. , S_SED_TYPE_SAND ); 00284 double mass_in = sed_cell_mass( s ); 00285 double t; 00286 00287 t = sed_column_add_cell( c , s ); 00288 00289 fail_unless( fabs( t - 1. ) < 1e-12 , "Added thickness should be returned" ); 00290 fail_unless( sed_column_len(c)==1 , "Column not resized correctly" ); 00291 fail_unless( fabs( sed_cell_mass(s) -mass_in ) < 1e-12 , "Cell should not change mass" ); 00292 fail_unless( fabs( sed_column_mass(c)-mass_in ) < 1e-12 , "Column mass should match cell mass" ); 00293 fail_unless( fabs( sed_column_thickness(c)-1. ) < 1e-12 , "Column thickness should match cell thickness" ); 00294 00295 sed_cell_resize( s , 128 ); 00296 mass_in += sed_cell_mass( s ); 00297 t = sed_column_add_cell( c , s ); 00298 00299 fail_unless( fabs( t - 128. ) < 1e-12 , "Added thickness should be returned" ); 00300 fail_unless( sed_column_len(c)==129 , "Column not resized correctly" ); 00301 fail_unless( fabs( sed_column_mass(c)-mass_in ) < 1e-12 , "Column mass should match cell mass" ); 00302 fail_unless( fabs( sed_column_thickness(c)-129) < 1e-12 , "Column thickness should match added thickness" ); 00303 00304 sed_cell_destroy( s ); 00305 sed_column_destroy( c ); 00306 } 00307 END_TEST 00308 00309 START_TEST ( test_sed_column_add_cell_empty ) 00310 { 00311 double t; 00312 Sed_column c = sed_column_new( 5 ); 00313 Sed_cell s = sed_cell_new_classed( NULL , 2. , S_SED_TYPE_SAND ); 00314 double mass_in = sed_cell_mass( s ); 00315 00316 t = sed_column_add_cell( c , s ); 00317 sed_cell_resize( s , 0 ); 00318 t = sed_column_add_cell( c , s ); 00319 00320 fail_unless( fabs( t ) < 1e-12 , "Added thickness should be returned" ); 00321 fail_unless( sed_column_len(c)==2 , "Column not resized correctly" ); 00322 fail_unless( fabs( sed_column_mass(c)-mass_in ) < 1e-12 , "Column mass should match cell mass" ); 00323 fail_unless( sed_column_size_is(c,2.0) , "Column thickness should match cell thickness" ); 00324 00325 sed_cell_destroy( s ); 00326 sed_column_destroy( c ); 00327 } 00328 END_TEST 00329 00330 START_TEST ( test_sed_column_add_cell_small ) 00331 { 00332 double t; 00333 gssize i; 00334 Sed_column c = sed_column_new( 5 ); 00335 Sed_cell s = sed_cell_new_classed( NULL , .25 , S_SED_TYPE_SAND ); 00336 double mass_in = sed_cell_mass( s ); 00337 00338 t = sed_column_add_cell( c , s ); 00339 00340 fail_unless( fabs( t - .25 ) < 1e-12 , "Added thickness should be returned" ); 00341 fail_unless( sed_column_len(c)==1 , "Column not resized correctly" ); 00342 fail_unless( fabs( sed_cell_mass(s) -mass_in ) < 1e-12 , "Cell should not change mass" ); 00343 fail_unless( fabs( sed_column_mass(c)-mass_in ) < 1e-12 , "Column mass should match cell mass" ); 00344 fail_unless( fabs( sed_column_thickness(c)-.25) < 1e-12 , "Column thickness should match cell thickness" ); 00345 00346 sed_cell_resize( s , .030 ); 00347 for ( i=0,t=0 ; i<1000 ; i++ ) 00348 { 00349 mass_in += sed_cell_mass( s ); 00350 t += sed_column_add_cell( c , s ); 00351 } 00352 00353 fail_unless( fabs( t - 30. ) < 1e-12 , "Added thickness should be returned" ); 00354 fail_unless( sed_column_len(c)==31 , "Column not resized correctly" ); 00355 fail_unless( eh_compare_dbl( sed_column_mass(c),mass_in,1e-12 ) , "Column mass should match cell mass" ); 00356 fail_unless( fabs( sed_column_thickness(c)-30.25) < 1e-12 , "Column thickness should match added thickness" ); 00357 00358 sed_cell_destroy( s ); 00359 sed_column_destroy( c ); 00360 } 00361 END_TEST 00362 00363 START_TEST ( test_sed_column_add_cell_large ) 00364 { 00365 double t; 00366 gssize i; 00367 Sed_column c = sed_column_new( 5 ); 00368 Sed_cell s = sed_cell_new_classed( NULL , 25 , S_SED_TYPE_SAND ); 00369 double mass_in = sed_cell_mass( s ); 00370 00371 t = sed_column_add_cell( c , s ); 00372 00373 fail_unless( fabs( t - 25 ) < 1e-12 , "Added thickness should be returned" ); 00374 fail_unless( sed_column_len(c)==25 , "Column not resized correctly" ); 00375 fail_unless( fabs( sed_cell_mass(s) -mass_in ) < 1e-12 , "Cell should not change mass" ); 00376 fail_unless( fabs( sed_column_mass(c)-mass_in ) < 1e-12 , "Column mass should match cell mass" ); 00377 fail_unless( fabs( sed_column_thickness(c)-25.) < 1e-12 , "Column thickness should match cell thickness" ); 00378 00379 sed_cell_resize( s , 30 ); 00380 for ( i=0,t=0 ; i<1000 ; i++ ) 00381 { 00382 mass_in += sed_cell_mass( s ); 00383 t += sed_column_add_cell( c , s ); 00384 } 00385 00386 fail_unless( fabs( t - 30000. ) < 1e-12 , "Added thickness should be returned" ); 00387 fail_unless( sed_column_len(c)==30025 , "Column not resized correctly" ); 00388 fail_unless( fabs( sed_column_mass(c)-mass_in ) < 1e-12 , "Column mass should match cell mass" ); 00389 fail_unless( fabs( sed_column_thickness(c)-30025) < 1e-12 , "Column thickness should match added thickness" ); 00390 00391 sed_cell_destroy( s ); 00392 sed_column_destroy( c ); 00393 } 00394 END_TEST 00395 00396 START_TEST ( test_sed_column_stack_cell ) 00397 { 00398 Sed_column c = sed_column_new( 5 ); 00399 Sed_cell s = sed_cell_new_classed( NULL , .5 , S_SED_TYPE_SAND ); 00400 double mass_in = sed_cell_mass( s ); 00401 double t; 00402 00403 t = sed_column_stack_cell( c , s ); 00404 00405 fail_unless( fabs( t - .5 ) < 1e-12 , "Added thickness should be returned" ); 00406 fail_unless( sed_column_len(c)==1 , "Column not resized correctly" ); 00407 fail_unless( fabs( sed_cell_mass(s) -mass_in ) < 1e-12 , "Cell should not change mass" ); 00408 fail_unless( fabs( sed_column_mass(c)-mass_in ) < 1e-12 , "Column mass should match cell mass" ); 00409 fail_unless( fabs( sed_column_thickness(c)-.5 ) < 1e-12 , "Column thickness should match cell thickness" ); 00410 00411 sed_cell_resize( s , 128 ); 00412 mass_in += sed_cell_mass( s ); 00413 t = sed_column_stack_cell( c , s ); 00414 00415 fail_unless( fabs( t - 128. ) < 1e-12 , "Added thickness should be returned" ); 00416 fail_unless( sed_column_len(c)==2 , "Column not resized correctly" ); 00417 fail_unless( eh_compare_dbl( sed_column_mass(c),mass_in,1e-12 ) , "Column mass should match cell mass" ); 00418 fail_unless( fabs( sed_column_thickness(c)-128.5) < 1e-12 , "Column thickness should match added thickness" ); 00419 00420 sed_cell_destroy( s ); 00421 sed_column_destroy( c ); 00422 } 00423 END_TEST 00424 00425 START_TEST ( test_sed_column_compact_cell ) 00426 { 00427 Sed_column c_0 ; 00428 Sed_column c = sed_column_new( 5 ); 00429 Sed_cell s = sed_cell_new_classed( NULL , 1.5 , S_SED_TYPE_SAND ); 00430 00431 sed_column_add_cell( c , s ); 00432 00433 c_0 = sed_column_compact_cell( c , 0 , .5 ); 00434 00435 fail_unless( c_0==c , "Column should be returned" ); 00436 fail_unless( sed_cell_is_size(s,1.5) , "Original cell should not change size" ); 00437 fail_unless( sed_column_size_is(c,1.) , "Column thickness not changed properly" ); 00438 fail_unless( sed_cell_is_size(sed_column_nth_cell(c,0),.5) , "Cell size not changed properly" ); 00439 00440 sed_column_destroy( c ); 00441 sed_cell_destroy ( s ); 00442 } 00443 END_TEST 00444 00445 START_TEST ( test_sed_column_resize_cell ) 00446 { 00447 Sed_column c_0 ; 00448 Sed_column c = sed_column_new( 5 ); 00449 Sed_cell s = sed_cell_new_classed( NULL , 1.5 , S_SED_TYPE_SAND ); 00450 00451 sed_column_add_cell( c , s ); 00452 00453 c_0 = sed_column_resize_cell( c , 0 , .5 ); 00454 00455 fail_unless( c_0==c , "Column should be returned" ); 00456 fail_unless( sed_cell_is_size(s,1.5) , "Original cell should not change size" ); 00457 fail_unless( sed_column_size_is(c,1.) , "Column thickness not changed properly" ); 00458 fail_unless( sed_cell_is_size(sed_column_nth_cell(c,0),.5) , "Cell size not changed properly" ); 00459 00460 sed_column_destroy( c ); 00461 sed_cell_destroy ( s ); 00462 } 00463 END_TEST 00464 00465 START_TEST ( test_sed_column_resize_cell_neg ) 00466 { 00467 Sed_column c_0 ; 00468 Sed_column c = sed_column_new( 5 ); 00469 Sed_cell s = sed_cell_new_classed( NULL , 1.5 , S_SED_TYPE_SAND ); 00470 00471 sed_column_add_cell( c , s ); 00472 00473 c_0 = sed_column_resize_cell( c , 0 , -.5 ); 00474 00475 fail_unless( c_0==c , "Column should be returned" ); 00476 fail_unless( sed_column_size_is(c,.5) , "Column thickness not changed properly" ); 00477 00478 sed_column_destroy( c ); 00479 sed_cell_destroy ( s ); 00480 } 00481 END_TEST 00482 00483 START_TEST ( test_sed_column_resize_cell_over ) 00484 { 00485 Sed_column c_0 ; 00486 Sed_column c = sed_column_new( 5 ); 00487 Sed_cell s = sed_cell_new_classed( NULL , 1.5 , S_SED_TYPE_SAND ); 00488 00489 sed_column_add_cell( c , s ); 00490 00491 c_0 = sed_column_resize_cell( c , 2 , .5 ); 00492 00493 fail_unless( c_0==c , "Column should be returned" ); 00494 fail_unless( sed_column_size_is(c,1.5) , "Invalid index should be ignored" ); 00495 00496 sed_column_destroy( c ); 00497 sed_cell_destroy ( s ); 00498 } 00499 END_TEST 00500 00501 START_TEST ( test_sed_column_resize_cell_under ) 00502 { 00503 Sed_column c_0 ; 00504 Sed_column c = sed_column_new( 5 ); 00505 Sed_cell s = sed_cell_new_classed( NULL , 1.5 , S_SED_TYPE_SAND ); 00506 00507 sed_column_add_cell( c , s ); 00508 00509 c_0 = sed_column_resize_cell( c , -1 , .5 ); 00510 00511 fail_unless( c_0==c , "Column should be returned" ); 00512 fail_unless( sed_column_size_is(c,1.5) , "Invalid index should be ignored" ); 00513 00514 sed_column_destroy( c ); 00515 sed_cell_destroy ( s ); 00516 } 00517 END_TEST 00518 00519 START_TEST ( test_sed_column_nth_cell ) 00520 { 00521 Sed_column c = sed_column_new( 5 ); 00522 Sed_cell s = sed_cell_new_classed( NULL , 1. , S_SED_TYPE_SAND ); 00523 gssize i; 00524 00525 for ( i=0 ; i<10 ; i++ ) 00526 { 00527 sed_cell_set_age( s , i ); 00528 sed_column_add_cell( c , s ); 00529 } 00530 00531 for ( i=0 ; i<sed_column_len(c) ; i++ ) 00532 { 00533 sed_cell_set_age( s , i ); 00534 fail_unless( sed_cell_is_same( sed_column_nth_cell( c , i ) , s ) , "nth cell not returned" ); 00535 } 00536 00537 sed_cell_destroy( s ); 00538 sed_column_destroy( c ); 00539 } 00540 END_TEST 00541 00542 START_TEST ( test_sed_column_nth_cell_empty ) 00543 { 00544 Sed_column c = sed_column_new( 5 ); 00545 00546 fail_unless( sed_cell_is_clear( sed_column_nth_cell( c , 0 )) , "0-th is clear for an empty column" ); 00547 fail_unless( sed_column_nth_cell( c , 1 )==NULL , "nth is NULL for an empty column" ); 00548 00549 sed_column_destroy( c ); 00550 } 00551 END_TEST 00552 00553 START_TEST ( test_sed_column_nth_cell_null ) 00554 { 00555 fail_unless( sed_column_nth_cell( NULL , 0 )==NULL , "nth is NULL for a NULL column" ); 00556 } 00557 END_TEST 00558 00559 START_TEST ( test_sed_column_top_cell ) 00560 { 00561 Sed_column c = sed_column_new( 5 ); 00562 Sed_cell s = sed_cell_new_classed( NULL , 12.5 , S_SED_TYPE_SAND ); 00563 Sed_cell top; 00564 00565 sed_column_add_cell( c , s ); 00566 00567 top = sed_column_top_cell( c ); 00568 00569 fail_unless( sed_column_nth_cell(c,12)==top , "Top cell not returned" ); 00570 00571 sed_column_clear( c ); 00572 top = sed_column_top_cell( c ); 00573 00574 fail_unless( top==NULL , "An empty column's top cell is NULL" ); 00575 00576 sed_column_destroy( c ); 00577 } 00578 END_TEST 00579 00580 START_TEST ( test_sed_column_total_load ) 00581 { 00582 Sed_column c = sed_column_new( 15 ); 00583 Sed_cell cell = sed_cell_new_classed( NULL , 26. , S_SED_TYPE_SILT ); 00584 double cell_load = sed_cell_load( cell ); 00585 double* load = eh_new( double , 26 ); 00586 double load_0 = 2006; 00587 gssize i; 00588 00589 sed_column_add_cell( c , cell ); 00590 00591 sed_column_total_load( c , 0 , sed_column_len(c) , load_0 , load ); 00592 00593 for ( i=25 ; i>=0 ; i-- ) 00594 fail_unless( fabs( load[i] - cell_load*(25-i) + load_0 ) > 1e-12 , "Load calculated incorrectly" ); 00595 00596 eh_free( load ); 00597 sed_cell_destroy( cell ); 00598 sed_column_destroy( c ); 00599 } 00600 END_TEST 00601 00602 START_TEST ( test_sed_column_load_at ) 00603 { 00604 Sed_column c = sed_column_new( 15 ); 00605 Sed_cell cell = sed_cell_new_classed( NULL , 26. , S_SED_TYPE_SILT ); 00606 double cell_load = sed_cell_load( cell ); 00607 double load; 00608 00609 sed_column_add_cell( c , cell ); 00610 00611 load = sed_column_load_at( c , 0 ); 00612 fail_unless( fabs( load - cell_load*25. ) > 1e-12 , "Load calculated incorrectly" ); 00613 00614 load = sed_column_load_at( c , sed_column_top_index(c) ); 00615 fail_unless( fabs( load ) > 1e-12 , "Load calculated incorrectly" ); 00616 00617 load = sed_column_load_at( c , sed_column_top_index(c)-5 ); 00618 fail_unless( fabs( load -cell_load*5 ) > 1e-12 , "Load calculated incorrectly" ); 00619 00620 sed_cell_destroy( cell ); 00621 sed_column_destroy( c ); 00622 } 00623 END_TEST 00624 00625 START_TEST ( test_sed_column_load ) 00626 { 00627 Sed_column c = sed_column_new( 15 ); 00628 Sed_cell cell = sed_cell_new_classed( NULL , 26. , S_SED_TYPE_SILT ); 00629 double cell_load = sed_cell_load( cell ); 00630 double* load = eh_new( double , 26 ); 00631 double* load_0; 00632 gssize i; 00633 00634 sed_column_add_cell( c , cell ); 00635 00636 load_0 = sed_column_load( c , 0 , sed_column_len(c) , load ); 00637 00638 fail_unless( load_0==load , "Load array should be returned" ); 00639 00640 for ( i=25 ; i>=0 ; i-- ) 00641 fail_unless( fabs( load[i] - cell_load*(25-i) ) > 1e-12 , "Load calculated incorrectly" ); 00642 00643 eh_free( load ); 00644 sed_cell_destroy( cell ); 00645 sed_column_destroy( c ); 00646 } 00647 END_TEST 00648 00649 START_TEST ( test_sed_column_load_neg_start ) 00650 { 00651 Sed_column c = sed_column_new( 15 ); 00652 Sed_cell cell = sed_cell_new_classed( NULL , 26. , S_SED_TYPE_SILT ); 00653 double cell_load = sed_cell_load( cell ); 00654 double* load = eh_new( double , 26 ); 00655 gssize i; 00656 00657 sed_column_add_cell( c , cell ); 00658 00659 sed_column_load( c , -16 , sed_column_len(c) , load ); 00660 00661 for ( i=25 ; i>=0 ; i-- ) 00662 fail_unless( fabs( load[i] - cell_load*(25-i) ) > 1e-12 , "Load calculated incorrectly" ); 00663 00664 eh_free( load ); 00665 sed_cell_destroy( cell ); 00666 sed_column_destroy( c ); 00667 } 00668 END_TEST 00669 00670 START_TEST ( test_sed_column_load_neg_bins ) 00671 { 00672 Sed_column c = sed_column_new( 15 ); 00673 Sed_cell cell = sed_cell_new_classed( NULL , 26. , S_SED_TYPE_SILT ); 00674 double cell_load = sed_cell_load( cell ); 00675 double* load = eh_new( double , 26 ); 00676 gssize i; 00677 00678 sed_column_add_cell( c , cell ); 00679 00680 sed_column_load( c , -16 , -1 , load ); 00681 00682 for ( i=25 ; i>=0 ; i-- ) 00683 fail_unless( fabs( load[i] - cell_load*(25-i) ) > 1e-12 , "Load calculated incorrectly" ); 00684 00685 eh_free( load ); 00686 sed_cell_destroy( cell ); 00687 sed_column_destroy( c ); 00688 } 00689 END_TEST 00690 00691 START_TEST ( test_sed_column_load_partial ) 00692 { 00693 Sed_column c = sed_column_new( 15 ); 00694 Sed_cell cell = sed_cell_new_classed( NULL , 26. , S_SED_TYPE_SILT ); 00695 double cell_load = sed_cell_load( cell ); 00696 double* load = eh_new( double , 5 ); 00697 gssize i; 00698 00699 sed_column_add_cell( c , cell ); 00700 00701 sed_column_load( c , 0 , 5 , load ); 00702 00703 for ( i=4 ; i>=0 ; i-- ) 00704 fail_unless( fabs( load[i] - cell_load*(25-i) ) > 1e-12 , "Load calculated incorrectly" ); 00705 00706 eh_free( load ); 00707 sed_cell_destroy( cell ); 00708 sed_column_destroy( c ); 00709 } 00710 END_TEST 00711 00712 START_TEST ( test_sed_column_load_null ) 00713 { 00714 Sed_column c = sed_column_new( 15 ); 00715 Sed_cell cell = sed_cell_new_classed( NULL , 26. , S_SED_TYPE_SILT ); 00716 double cell_load = sed_cell_load( cell ); 00717 double* load; 00718 gssize i; 00719 00720 sed_column_add_cell( c , cell ); 00721 00722 load = sed_column_load( c , 0 , sed_column_len(c) , NULL ); 00723 00724 fail_if( load==NULL , "New load array not allocated" ); 00725 00726 for ( i=25 ; i>=0 ; i-- ) 00727 fail_unless( fabs( load[i] - cell_load*(25-i) ) > 1e-12 , "Load calculated incorrectly" ); 00728 00729 eh_free( load ); 00730 sed_cell_destroy( cell ); 00731 sed_column_destroy( c ); 00732 } 00733 END_TEST 00734 00735 START_TEST ( test_sed_column_top_index ) 00736 { 00737 Sed_column c = sed_column_new( 5 ); 00738 Sed_cell cell = sed_cell_new_classed( NULL , 3.14 , S_SED_TYPE_SAND|S_SED_TYPE_SILT ); 00739 gssize top_ind; 00740 00741 sed_column_add_cell( c , cell ); 00742 00743 top_ind = sed_column_top_index( c ); 00744 00745 fail_unless( top_ind==3 , "Top index not correct" ); 00746 00747 sed_cell_destroy( cell ); 00748 sed_column_destroy( c ); 00749 } 00750 END_TEST 00751 00752 START_TEST ( test_sed_column_top_index_null ) 00753 { 00754 gssize top_ind; 00755 00756 top_ind = sed_column_top_index( NULL ); 00757 00758 fail_unless( top_ind==-1 , "Top index should be -1 for NULL column" ); 00759 } 00760 END_TEST 00761 00762 START_TEST ( test_sed_column_top_index_empty ) 00763 { 00764 Sed_column c = sed_column_new( 5 ); 00765 gssize top_ind; 00766 00767 top_ind = sed_column_top_index( c ); 00768 00769 fail_unless( top_ind==-1 , "Top index should be -1 for empty column" ); 00770 00771 sed_column_destroy( c ); 00772 } 00773 END_TEST 00774 00775 START_TEST ( test_sed_column_is_above ) 00776 { 00777 Sed_column c = sed_column_new( 5 ); 00778 Sed_cell cell = sed_cell_new_classed( NULL , 33 , S_SED_TYPE_SAND ); 00779 00780 sed_column_set_base_height( c , 58 ); 00781 sed_column_add_cell( c , cell ); 00782 00783 fail_unless( sed_column_is_above(c,90) , "Column should be above" ); 00784 fail_unless( !sed_column_is_above(c,92) , "Column should not be above" ); 00785 00786 sed_cell_destroy ( cell ); 00787 sed_column_destroy( c ); 00788 } 00789 END_TEST 00790 00791 START_TEST ( test_sed_column_is_below ) 00792 { 00793 Sed_column c = sed_column_new( 5 ); 00794 Sed_cell cell = sed_cell_new_classed( NULL , 33 , S_SED_TYPE_SAND ); 00795 00796 sed_column_set_base_height( c , 58 ); 00797 sed_column_add_cell( c , cell ); 00798 00799 fail_unless( !sed_column_is_below(c,90) , "Column should not be below" ); 00800 fail_unless( sed_column_is_below(c,92) , "Column should be below" ); 00801 00802 sed_cell_destroy ( cell ); 00803 sed_column_destroy( c ); 00804 } 00805 END_TEST 00806 00807 START_TEST ( test_sed_column_is_valid_index ) 00808 { 00809 Sed_column c = sed_column_new( 5 ); 00810 00811 fail_unless( sed_column_is_valid_index(c,0) , "0 is a valid index for this column" ); 00812 fail_unless( !sed_column_is_valid_index(c,S_ADDBINS) , "Index will result in seg fault" ); 00813 fail_unless( !sed_column_is_valid_index(c,-1) , "Index will result in seg fault" ); 00814 00815 fail_unless( !sed_column_is_valid_index(NULL,0) , "NULL has no valid indices" ); 00816 00817 sed_column_clear( c ); 00818 00819 fail_unless( sed_column_is_valid_index(c,0) , "0 is a valid index for an empty column" ); 00820 00821 sed_column_destroy( c ); 00822 } 00823 END_TEST 00824 00825 START_TEST ( test_sed_column_is_get_index ) 00826 { 00827 Sed_column c = sed_column_new( 5 ); 00828 Sed_cell cell = sed_cell_new_classed( NULL , 6 , S_SED_TYPE_SAND ); 00829 gssize len; 00830 00831 sed_column_add_cell( c , cell ); 00832 len = sed_column_len( c ); 00833 00834 fail_unless( sed_column_is_get_index(c,0) , "0 is a valid get-index for this column" ); 00835 fail_unless( !sed_column_is_get_index(c,len) , "Column len is not a valid get-index for a column" ); 00836 fail_unless( sed_column_is_get_index(c,len-1) , "Column len-1 is a valid get-index for a column" ); 00837 fail_unless( !sed_column_is_get_index(c,-1) , "-1 is never a valid get-index for a column" ); 00838 00839 fail_unless( !sed_column_is_get_index(NULL,0) , "NULL has no valid get-indices" ); 00840 00841 sed_column_clear( c ); 00842 00843 fail_unless( !sed_column_is_get_index(c,0) , "An empty column has no valid get indices" ); 00844 00845 sed_cell_destroy( cell ); 00846 sed_column_destroy( c ); 00847 } 00848 END_TEST 00849 00850 START_TEST ( test_sed_column_is_set_index ) 00851 { 00852 Sed_column c = sed_column_new( 5 ); 00853 Sed_cell cell = sed_cell_new_classed( NULL , 6 , S_SED_TYPE_SAND ); 00854 gssize len; 00855 00856 sed_column_add_cell( c , cell ); 00857 len = sed_column_len( c ); 00858 00859 fail_unless( sed_column_is_set_index(c,0) , "0 is always a valid set-index for a non-NULL column" ); 00860 fail_unless( sed_column_is_set_index(c,len) , "Column len is a valid set-index for a column" ); 00861 fail_unless( sed_column_is_set_index(c,len-1) , "Column len-1 is a valid set-index for a column" ); 00862 fail_unless( !sed_column_is_set_index(c,-1) , "-1 is never a valid set-index for a column" ); 00863 00864 fail_unless( !sed_column_is_get_index(NULL,0) , "NULL has no valid set-indices" ); 00865 00866 sed_column_clear( c ); 00867 00868 fail_unless( sed_column_is_set_index(c,0) , "0 is the only valid set-index for an empty column" ); 00869 fail_unless( !sed_column_is_set_index(c,1) , "1 is not a valid set-index for an empty column" ); 00870 00871 sed_cell_destroy( cell ); 00872 sed_column_destroy( c ); 00873 } 00874 END_TEST 00875 00876 START_TEST ( test_sed_column_top_nbins ) 00877 { 00878 Sed_column c = sed_column_new( 5 ); 00879 Sed_cell cell = sed_cell_new_classed( NULL , 50. , S_SED_TYPE_SAND ); 00880 gssize n; 00881 00882 sed_column_set_base_height( c , 100 ); 00883 sed_column_add_cell( c , cell ); 00884 00885 n = sed_column_top_nbins( c , 150 ); 00886 fail_unless( n==1 , "The top bin" ); 00887 00888 n = sed_column_top_nbins( c , 148.5 ); 00889 fail_unless( n==2 , "Partial bins count" ); 00890 00891 n = sed_column_top_nbins( c , 100 ); 00892 fail_unless( n==sed_column_len(c) , "All of the bins" ); 00893 00894 n = sed_column_top_nbins( c , 99 ); 00895 fail_unless( n==sed_column_len(c) , "Depth to below column uses all bins" ); 00896 00897 n = sed_column_top_nbins( c , 151 ); 00898 fail_unless( n==1 , "Depth above top of column uses only the top bin" ); 00899 00900 sed_cell_destroy ( cell ); 00901 sed_column_destroy( c ); 00902 00903 } 00904 END_TEST 00905 00906 START_TEST ( test_sed_column_top ) 00907 { 00908 Sed_column c = sed_column_new_filled( 20 , S_SED_TYPE_SAND ); 00909 Sed_cell cell = sed_cell_new_classed(NULL,13,S_SED_TYPE_CLAY); 00910 Sed_cell cell_0; 00911 00912 cell_0 = sed_column_top( c , 1.5 , cell ); 00913 00914 fail_unless( cell_0==cell , "Destination cell is returned" ); 00915 fail_unless( sed_cell_is_size(cell,1.5) , "Size of destination cell is amount gotten" ); 00916 fail_unless( sed_cell_is_size_class(cell,S_SED_TYPE_SAND) , "Destination contains column sediment" ); 00917 fail_unless( sed_column_size_is(c,20) , "Source column should not change" ); 00918 00919 sed_cell_destroy ( cell ); 00920 sed_column_destroy( c ); 00921 } 00922 END_TEST 00923 00924 START_TEST ( test_sed_column_top_above ) 00925 { 00926 Sed_column c = sed_column_new_filled( 20 , S_SED_TYPE_SAND ); 00927 Sed_cell cell = sed_cell_new_classed(NULL,13,S_SED_TYPE_CLAY); 00928 Sed_cell cell_0; 00929 00930 cell_0 = sed_column_top( c , -1.5 , cell ); 00931 00932 fail_unless( cell_0==cell , "Destination cell is returned" ); 00933 fail_unless( sed_cell_is_clear(cell) , "Negative thickness returns a clear cell" ); 00934 fail_unless( sed_column_size_is(c,20) , "Source column should not change" ); 00935 00936 sed_cell_destroy ( cell ); 00937 sed_column_destroy( c ); 00938 } 00939 END_TEST 00940 00941 START_TEST ( test_sed_column_top_below ) 00942 { 00943 Sed_column c = sed_column_new_filled( 20 , S_SED_TYPE_SAND ); 00944 Sed_cell cell = sed_cell_new_classed(NULL,13,S_SED_TYPE_CLAY); 00945 Sed_cell cell_0; 00946 00947 cell_0 = sed_column_top( c , 21.5 , cell ); 00948 00949 fail_unless( cell_0==cell , "Destination cell is returned" ); 00950 fail_unless( sed_cell_is_size(cell,20) , "Size of destination cell is amount gotten" ); 00951 fail_unless( sed_column_size_is(c,20) , "Source column should not change" ); 00952 00953 sed_cell_destroy ( cell ); 00954 sed_column_destroy( c ); 00955 } 00956 END_TEST 00957 00958 START_TEST ( test_sed_column_top_null ) 00959 { 00960 Sed_column c = sed_column_new_filled( 20 , S_SED_TYPE_SAND ); 00961 Sed_cell cell; 00962 00963 cell = sed_column_top( c , 1.5 , NULL ); 00964 00965 fail_unless( sed_cell_is_valid(cell) , "Valid destination cell is created" ); 00966 fail_unless( sed_cell_is_size(cell,1.5) , "Size of destination cell is amount gotten" ); 00967 fail_unless( sed_cell_is_size_class(cell,S_SED_TYPE_SAND) , "Destination contains column sediment" ); 00968 fail_unless( sed_column_size_is(c,20) , "Source column should not change" ); 00969 00970 sed_cell_destroy ( cell ); 00971 sed_column_destroy( c ); 00972 } 00973 END_TEST 00974 00975 START_TEST ( test_sed_column_top_empty ) 00976 { 00977 Sed_column c = sed_column_new( 5 ); 00978 Sed_cell cell = sed_cell_new_classed(NULL,13,S_SED_TYPE_CLAY); 00979 Sed_cell cell_0; 00980 00981 cell_0 = sed_column_top( c , 1.5 , cell ); 00982 00983 fail_unless( cell_0==cell , "Destination cell is returned" ); 00984 fail_unless( sed_cell_is_clear(cell) , "Empty column returns a clear cell" ); 00985 fail_unless( sed_column_is_empty(c) , "Source column should not change" ); 00986 00987 sed_cell_destroy ( cell ); 00988 sed_column_destroy( c ); 00989 } 00990 END_TEST 00991 00992 START_TEST ( test_sed_column_top_rho ) 00993 { 00994 Sed_column c = sed_column_new( 5 ); 00995 Sed_cell cell = sed_cell_new_classed(NULL,13,S_SED_TYPE_CLAY|S_SED_TYPE_SAND); 00996 double rho, rho_0; 00997 00998 sed_column_add_cell( c , cell ); 00999 01000 rho_0 = sed_cell_density( cell ); 01001 rho = sed_column_top_rho( c , 1.5 ); 01002 01003 fail_unless( eh_compare_dbl( rho , rho_0 , 1e-12 ) , "Column density doesn't match cell density" ); 01004 01005 sed_cell_destroy ( cell ); 01006 sed_column_destroy( c ); 01007 } 01008 END_TEST 01009 01010 START_TEST ( test_sed_column_top_age ) 01011 { 01012 Sed_column c = sed_column_new( 5 ); 01013 Sed_cell cell = sed_cell_new_classed(NULL,1,S_SED_TYPE_CLAY|S_SED_TYPE_SAND); 01014 double age; 01015 gssize i; 01016 01017 for ( i=1 ; i<=10 ; i++ ) 01018 { 01019 sed_cell_set_age( cell , i ); 01020 sed_column_add_cell( c , cell ); 01021 } 01022 01023 age = sed_column_top_age( c , 1.5 ); 01024 01025 fail_unless( eh_compare_dbl( age , 29./3., 1e-12 ) , "Column age not calculated correctly" ); 01026 01027 sed_cell_destroy ( cell ); 01028 sed_column_destroy( c ); 01029 } 01030 END_TEST 01031 01032 START_TEST ( test_sed_column_top_property ) 01033 { 01034 Sed_column c = sed_column_new( 5 ); 01035 Sed_cell cell = sed_cell_new_classed(NULL,10,S_SED_TYPE_CLAY|S_SED_TYPE_SAND); 01036 Sed_property p = sed_property_new( "grain" ); 01037 double gz, gz_0; 01038 01039 sed_column_add_cell( c , cell ); 01040 01041 gz_0 = sed_cell_grain_size_in_phi( cell ); 01042 gz = sed_column_top_property( p , c , 1.5 ); 01043 01044 fail_unless( eh_compare_dbl( gz , gz_0 , 1e-12 ) , "Column grain size not calculated correctly" ); 01045 01046 sed_property_destroy( p ); 01047 sed_cell_destroy ( cell ); 01048 sed_column_destroy( c ); 01049 } 01050 END_TEST 01051 01052 START_TEST ( test_sed_column_top_property_with_load ) 01053 { 01054 Sed_column c = sed_column_new( 5 ); 01055 Sed_cell cell = sed_cell_new_classed(NULL,10,S_SED_TYPE_CLAY|S_SED_TYPE_SAND); 01056 Sed_property p = sed_property_new( "cohesion" ); 01057 double cohesion, cohesion_0; 01058 01059 sed_column_add_cell_real( c , cell , FALSE ); 01060 01061 cohesion_0 = sed_cell_cohesion( cell , sed_cell_load(cell)*.1 ); 01062 cohesion = sed_column_top_property( p , c , 1. ); 01063 01064 fail_unless( eh_compare_dbl( cohesion , cohesion_0 , 1e-12 ) , "Column cohesion not calculated correctly" ); 01065 01066 cohesion_0 = sed_cell_cohesion( cell , sed_cell_load(cell)*.65 ); 01067 cohesion = sed_column_top_property( p , c , 6.5 ); 01068 01069 fail_unless( eh_compare_dbl( cohesion , cohesion_0 , 1e-12 ) , "Column cohesion not calculated correctly" ); 01070 01071 sed_property_destroy( p ); 01072 sed_cell_destroy ( cell ); 01073 sed_column_destroy ( c ); 01074 } 01075 END_TEST 01076 01077 START_TEST ( test_sed_column_index_depth ) 01078 { 01079 Sed_column c = sed_column_new( 5 ); 01080 Sed_cell cell = sed_cell_new_classed( NULL , 21. , S_SED_TYPE_SAND ); 01081 gssize ind; 01082 01083 sed_column_add_cell( c , cell ); 01084 01085 ind = sed_column_index_depth( c , 1.5 ); 01086 fail_unless( ind==19 , "Index to middle of cell incorrect" ); 01087 01088 ind = sed_column_index_depth( c , 2 ); 01089 fail_unless( ind==18 , "Index to top of cell incorrect" ); 01090 01091 ind = sed_column_index_depth( c , 0 ); 01092 fail_unless( ind==20 , "Index to column top incorrect" ); 01093 01094 ind = sed_column_index_depth( c , 21 ); 01095 fail_unless( ind==-1 , "Index to column bottom incorrect" ); 01096 01097 ind = sed_column_index_depth( c , 21./2. ); 01098 fail_unless( ind==10 , "Index to column middle incorrect" ); 01099 01100 sed_cell_destroy( cell ); 01101 sed_column_destroy( c ); 01102 } 01103 END_TEST 01104 01105 START_TEST ( test_sed_column_depth_age ) 01106 { 01107 Sed_column c = sed_column_new( 5 ); 01108 Sed_cell cell = sed_cell_new_classed( NULL , 1. , S_SED_TYPE_SAND ); 01109 double d; 01110 gssize i; 01111 01112 for ( i=1 ; i<=3 ; i++ ) 01113 { 01114 sed_cell_set_age( cell , i/10. ); 01115 sed_column_add_cell( c , cell ); 01116 } 01117 01118 d = sed_column_depth_age( c , .1 ); 01119 fail_unless( eh_compare_dbl(d,2,1e-12) , "Age of bottom cell" ); 01120 01121 d = sed_column_depth_age( c , .3 ); 01122 fail_unless( eh_compare_dbl(d,0,1e-12) , "Age of top cell" ); 01123 01124 d = sed_column_depth_age( c , .25 ); 01125 fail_unless( eh_compare_dbl(d,1.,1e-12) , "Age of a middle cell" ); 01126 01127 d = sed_column_depth_age( c , 0 ); 01128 fail_unless( eh_compare_dbl(d,3.,1e-12) , "Age below column" ); 01129 01130 d = sed_column_depth_age( c , .4 ); 01131 fail_unless( eh_compare_dbl(d,0,1e-12) , "Age above column" ); 01132 01133 sed_cell_destroy ( cell ); 01134 sed_column_destroy( c ); 01135 } 01136 END_TEST 01137 01138 START_TEST ( test_sed_column_thickness_index ) 01139 { 01140 Sed_column c = sed_column_new( 5 ); 01141 Sed_cell cell = sed_cell_new_classed( NULL , 21. , S_SED_TYPE_SAND ); 01142 double t; 01143 01144 sed_column_add_cell( c , cell ); 01145 01146 t = sed_column_thickness_index( c , 0 ); 01147 fail_unless( fabs(t-1.) < 1e-12 , "Thickness to first cell" ); 01148 01149 t = sed_column_thickness_index( c , 20 ); 01150 fail_unless( fabs(t-21.) < 1e-12 , "Thickness to last cell" ); 01151 01152 sed_cell_destroy ( cell ); 01153 sed_column_destroy( c ); 01154 } 01155 END_TEST 01156 01157 START_TEST ( test_sed_column_thickness_index_neg ) 01158 { 01159 Sed_column c = sed_column_new( 5 ); 01160 Sed_cell cell = sed_cell_new_classed( NULL , 21. , S_SED_TYPE_SAND ); 01161 double t; 01162 01163 sed_column_add_cell( c , cell ); 01164 01165 t = sed_column_thickness_index( c , -1 ); 01166 fail_unless( fabs(t) < 1e-12 , "Thickness is zero to negative indices" ); 01167 01168 sed_cell_destroy ( cell ); 01169 sed_column_destroy( c ); 01170 } 01171 END_TEST 01172 01173 START_TEST ( test_sed_column_thickness_index_above ) 01174 { 01175 Sed_column c = sed_column_new( 5 ); 01176 Sed_cell cell = sed_cell_new_classed( NULL , 21. , S_SED_TYPE_SAND ); 01177 double t; 01178 01179 sed_column_add_cell( c , cell ); 01180 01181 t = sed_column_thickness_index( c , 47 ); 01182 fail_unless( fabs(t-21) < 1e-12 , "Thickness to above column is column thickness" ); 01183 01184 sed_cell_destroy ( cell ); 01185 sed_column_destroy( c ); 01186 } 01187 END_TEST 01188 01189 START_TEST ( test_sed_column_thickness_index_null ) 01190 { 01191 Sed_column c = sed_column_new( 5 ); 01192 double t = sed_column_thickness_index( NULL , 0 ); 01193 01194 fail_unless( fabs(t) < 1e-12 , "Thickness of empty column is zero" ); 01195 01196 sed_column_destroy( c ); 01197 } 01198 END_TEST 01199 01200 START_TEST ( test_sed_column_thickness_index_empty ) 01201 { 01202 double t = sed_column_thickness_index( NULL , 47 ); 01203 fail_unless( fabs(t) < 1e-12 , "Thickness of NULL column is zero" ); 01204 } 01205 END_TEST 01206 01207 START_TEST ( test_sed_column_index_thickness ) 01208 { 01209 Sed_column c = sed_column_new( 5 ); 01210 Sed_cell cell = sed_cell_new_classed( NULL , 21. , S_SED_TYPE_SAND ); 01211 gssize ind; 01212 01213 sed_column_add_cell( c , cell ); 01214 01215 ind = sed_column_index_thickness( c , 3.5 ); 01216 fail_unless( ind==3 , "Index to middle of cell incorrect" ); 01217 01218 ind = sed_column_index_thickness( c , 3 ); 01219 fail_unless( ind==2 , "Index to top of cell incorrect" ); 01220 01221 ind = sed_column_index_thickness( c , 21 ); 01222 fail_unless( ind==20 , "Index to column top incorrect" ); 01223 01224 ind = sed_column_index_thickness( c , 0 ); 01225 fail_unless( ind==-1 , "Index to column bottom incorrect" ); 01226 01227 ind = sed_column_index_thickness( c , 21./2. ); 01228 fail_unless( ind==10 , "Index to column middle incorrect" ); 01229 01230 sed_cell_destroy( cell ); 01231 sed_column_destroy( c ); 01232 } 01233 END_TEST 01234 01235 START_TEST ( test_sed_column_index_at ) 01236 { 01237 Sed_column c = sed_column_new( 5 ); 01238 Sed_cell cell = sed_cell_new_classed( NULL , 21. , S_SED_TYPE_SAND ); 01239 gssize ind; 01240 01241 sed_column_set_base_height( c , 142 ); 01242 sed_column_add_cell( c , cell ); 01243 01244 ind = sed_column_index_at( c , 145.5 ); 01245 fail_unless( ind==3 , "Index to middle of cell incorrect" ); 01246 01247 ind = sed_column_index_at( c , 145 ); 01248 fail_unless( ind==2 , "Index to top of cell incorrect" ); 01249 01250 ind = sed_column_index_at( c , 163 ); 01251 fail_unless( ind==20 , "Index to column top incorrect" ); 01252 01253 sed_cell_destroy( cell ); 01254 sed_column_destroy( c ); 01255 } 01256 END_TEST 01257 01258 START_TEST ( test_sed_column_index_at_base ) 01259 { 01260 Sed_column c = sed_column_new( 5 ); 01261 Sed_cell cell = sed_cell_new_classed( NULL , 21. , S_SED_TYPE_SAND ); 01262 gssize ind; 01263 01264 sed_column_set_base_height( c , 142 ); 01265 sed_column_add_cell( c , cell ); 01266 01267 ind = sed_column_index_at( c , 142 ); 01268 fail_unless( ind==-1 , "Index to base is incorrect" ); 01269 01270 sed_cell_destroy( cell ); 01271 sed_column_destroy( c ); 01272 } 01273 END_TEST 01274 01275 START_TEST ( test_sed_column_index_at_above ) 01276 { 01277 Sed_column c = sed_column_new( 5 ); 01278 Sed_cell cell = sed_cell_new_classed( NULL , 21. , S_SED_TYPE_SAND ); 01279 gssize ind; 01280 01281 sed_column_set_base_height( c , 142 ); 01282 sed_column_add_cell( c , cell ); 01283 01284 ind = sed_column_index_at( c , 175 ); 01285 fail_unless( ind==20 , "Index above top is incorrect" ); 01286 01287 sed_cell_destroy( cell ); 01288 sed_column_destroy( c ); 01289 } 01290 END_TEST 01291 01292 START_TEST ( test_sed_column_index_at_below ) 01293 { 01294 Sed_column c = sed_column_new( 5 ); 01295 Sed_cell cell = sed_cell_new_classed( NULL , 21. , S_SED_TYPE_SAND ); 01296 gssize ind; 01297 01298 sed_column_set_base_height( c , 142 ); 01299 sed_column_add_cell( c , cell ); 01300 01301 ind = sed_column_index_at( c , 100 ); 01302 fail_unless( ind==-1 , "Index above top is incorrect" ); 01303 01304 sed_cell_destroy( cell ); 01305 sed_column_destroy( c ); 01306 } 01307 END_TEST 01308 01309 #include <glib/gstdio.h> 01310 01311 START_TEST ( test_sed_column_write ) 01312 { 01313 char* name_used; 01314 gssize n_bytes; 01315 01316 { 01317 Sed_column c = sed_column_new( 5 ); 01318 Sed_cell cell = sed_cell_new_classed( NULL , 23.1 , S_SED_TYPE_SAND|S_SED_TYPE_MUD ); 01319 FILE* fp_tmp = eh_open_temp_file( "sed_column_test.binXXXXXX" , &name_used ); 01320 01321 sed_column_add_cell( c , cell ); 01322 01323 sed_column_set_z_res ( c , 2.718 ); 01324 sed_column_set_x_position ( c , 3.14 ); 01325 sed_column_set_y_position ( c , 9.81 ); 01326 sed_column_set_base_height( c , 1.414 ); 01327 sed_column_set_age ( c , 33. ); 01328 01329 n_bytes = sed_column_write( fp_tmp , c ); 01330 01331 sed_cell_destroy ( cell ); 01332 sed_column_destroy( c ); 01333 01334 fclose( fp_tmp ); 01335 } 01336 01337 { 01338 FILE* fp; 01339 FILE* fp_tmp = fopen( name_used , "rb" ); 01340 char* data_0 = eh_new( char , n_bytes ); 01341 char* data_1 = eh_new( char , n_bytes ); 01342 01343 fp = fopen( SED_COLUMN_TEST_FILE , "rb" ); 01344 01345 fread( data_0 , sizeof(char) , n_bytes , fp ); 01346 fread( data_1 , sizeof(char) , n_bytes , fp_tmp ); 01347 01348 fail_unless( strncmp( data_0 , data_1 , n_bytes )==0 , "Binary file does not compare to test file" ); 01349 01350 eh_free( data_0 ); 01351 eh_free( data_1 ); 01352 01353 fclose( fp ); 01354 fclose( fp_tmp ); 01355 } 01356 01357 g_remove( name_used ); 01358 } 01359 END_TEST 01360 01361 START_TEST ( test_sed_column_read ) 01362 { 01363 FILE* fp = eh_fopen( SED_COLUMN_TEST_FILE , "rb" ); 01364 Sed_column c; 01365 01366 c = sed_column_read( fp ); 01367 01368 fail_if ( c==NULL , "Read error" ); 01369 fail_unless( fabs(sed_column_z_res(c)-2.718) < 1e-12 , "Read error for column z res" ); 01370 fail_unless( fabs(sed_column_x_position(c)-3.14) < 1e-12 , "Read error for column x-position" ); 01371 fail_unless( fabs(sed_column_y_position(c)-9.81) < 1e-12 , "Read error for column y-position" ); 01372 fail_unless( fabs(sed_column_base_height(c)-1.414) < 1e-12 , "Read error for column base height" ); 01373 fail_unless( fabs(sed_column_mass(c)-40425) < 1e0 , "Read error for column mass" ); 01374 fail_unless( sed_column_len(c)==24 , "Read error for column length" ); 01375 01376 sed_column_destroy( c ); 01377 01378 fclose( fp ); 01379 } 01380 END_TEST 01381 01382 START_TEST ( test_sed_column_chop ) 01383 { 01384 Sed_column c_0; 01385 Sed_column c = sed_column_new( 5 ); 01386 Sed_cell cell = sed_cell_new_classed( NULL , 20 , S_SED_TYPE_SAND ); 01387 01388 sed_column_set_base_height( c , 123 ); 01389 01390 sed_column_add_cell( c , cell ); 01391 01392 c_0 = sed_column_chop( c , 133 ); 01393 01394 fail_unless( c_0==c , "Chopped column should be returned" ); 01395 fail_unless( fabs( sed_column_base_height(c)-123 ) < 1e-23 , "Chop doesn't change base height" ); 01396 fail_unless( fabs( sed_column_top_height(c) -133 ) < 1e-23 , "Top height not changed correctly" ); 01397 01398 sed_cell_destroy ( cell ); 01399 sed_column_destroy( c ); 01400 } 01401 END_TEST 01402 01403 START_TEST ( test_sed_column_chomp ) 01404 { 01405 Sed_column c_0; 01406 Sed_column c = sed_column_new( 5 ); 01407 Sed_cell cell = sed_cell_new_classed( NULL , 20 , S_SED_TYPE_SAND ); 01408 01409 sed_column_set_base_height( c , 123 ); 01410 01411 sed_column_add_cell( c , cell ); 01412 01413 c_0 = sed_column_chomp( c , 133 ); 01414 01415 fail_unless( c_0==c , "Chompped column should be returned" ); 01416 fail_unless( fabs( sed_column_base_height(c)-133 ) < 1e-23 , "Base height not changed correctly" ); 01417 fail_unless( fabs( sed_column_top_height(c) -143 ) < 1e-23 , "Chomp does not change top height" ); 01418 01419 sed_cell_destroy ( cell ); 01420 sed_column_destroy( c ); 01421 } 01422 END_TEST 01423 01424 START_TEST ( test_sed_column_strip ) 01425 { 01426 Sed_column c_0; 01427 Sed_column c = sed_column_new( 5 ); 01428 Sed_cell cell = sed_cell_new_classed( NULL , 20 , S_SED_TYPE_SAND ); 01429 01430 sed_column_set_base_height( c , 123 ); 01431 01432 sed_column_add_cell( c , cell ); 01433 01434 c_0 = sed_column_strip( c , 133 , 135 ); 01435 01436 fail_unless( c_0==c , "Stripped column should be returned" ); 01437 fail_unless( fabs( sed_column_base_height(c)-133 ) < 1e-23 , "Base height not changed correctly" ); 01438 fail_unless( fabs( sed_column_top_height(c) -135 ) < 1e-23 , "Top height not changed correctly" ); 01439 01440 sed_cell_destroy ( cell ); 01441 sed_column_destroy( c ); 01442 } 01443 END_TEST 01444 01445 START_TEST ( test_sed_column_chop_above ) 01446 { 01447 Sed_column c_0; 01448 Sed_column c = sed_column_new( 5 ); 01449 Sed_cell cell = sed_cell_new_classed( NULL , 20 , S_SED_TYPE_SAND ); 01450 01451 sed_column_set_base_height( c , 123 ); 01452 01453 sed_column_add_cell( c , cell ); 01454 01455 c_0 = sed_column_chop( c , 145 ); 01456 01457 fail_unless( c_0==c , "Chopped column should be returned" ); 01458 fail_unless( fabs( sed_column_base_height(c)-123 ) < 1e-23 , "Chop doesn't change base height" ); 01459 fail_unless( fabs( sed_column_top_height(c) -143 ) < 1e-23 , "Chopping above column doesn't change height" ); 01460 01461 sed_cell_destroy ( cell ); 01462 sed_column_destroy( c ); 01463 } 01464 END_TEST 01465 01466 START_TEST ( test_sed_column_extract_above_0 ) 01467 { 01468 Sed_cell* c_arr = NULL; 01469 Sed_column c = sed_column_new( 5 ); 01470 Sed_cell cell = sed_cell_new_classed( NULL , 20 , S_SED_TYPE_SAND ); 01471 01472 sed_column_set_base_height( c , 123 ); 01473 01474 sed_column_add_cell( c , cell ); 01475 01476 c_arr = sed_column_extract_cells_above( c , 140 ); 01477 01478 fail_unless( c_arr!=NULL , "Returned array is null" ); 01479 fail_unless( g_strv_length(c_arr)==3 , "Incorrect number of cells extracted" ); 01480 fail_unless( fabs( sed_column_base_height(c)-123 ) < 1e-23 , "Extract doesn't change base height" ); 01481 fail_unless( fabs( sed_column_top_height(c) -140 ) < 1e-23 , "Top height not correct" ); 01482 01483 sed_cell_array_free( c_arr ); 01484 sed_cell_destroy ( cell ); 01485 sed_column_destroy ( c ); 01486 } 01487 END_TEST 01488 01489 START_TEST ( test_sed_column_extract_above_1 ) 01490 { 01491 Sed_cell* c_arr = NULL; 01492 Sed_column c = sed_column_new( 5 ); 01493 Sed_cell cell = sed_cell_new_classed( NULL , 20 , S_SED_TYPE_SAND ); 01494 01495 sed_column_set_base_height( c , 123 ); 01496 01497 sed_column_add_cell( c , cell ); 01498 01499 c_arr = sed_column_extract_cells_above( c , 125.1 ); 01500 01501 fail_unless( c_arr!=NULL , "Returned array is null" ); 01502 fail_unless( g_strv_length(c_arr)==18 , "Incorrect number of cells extracted" ); 01503 fail_unless( fabs( sed_column_base_height(c)-123 ) < 1e-23 , "Extract doesn't change base height" ); 01504 fail_unless( fabs( sed_column_top_height(c) -125.1 ) < 1e-23 , "Top height not correct" ); 01505 01506 sed_cell_array_free( c_arr ); 01507 sed_cell_destroy ( cell ); 01508 sed_column_destroy ( c ); 01509 } 01510 END_TEST 01511 01512 START_TEST ( test_sed_column_extract_above_2 ) 01513 { 01514 Sed_cell* c_arr = NULL; 01515 Sed_column c = sed_column_new( 5 ); 01516 Sed_cell cell = sed_cell_new_classed( NULL , 20 , S_SED_TYPE_SAND ); 01517 01518 sed_column_set_base_height( c , 123 ); 01519 01520 sed_column_add_cell( c , cell ); 01521 01522 c_arr = sed_column_extract_cells_above( c , 120.1 ); 01523 01524 fail_unless( c_arr!=NULL , "Returned array is null" ); 01525 fail_unless( g_strv_length(c_arr)==20 , "Incorrect number of cells extracted" ); 01526 fail_unless( sed_column_is_empty(c) , "Column should have been emptied" ); 01527 fail_unless( fabs( sed_column_base_height(c)-123 ) < 1e-23 , "Extract doesn't change base height" ); 01528 fail_unless( fabs( sed_column_top_height(c) -123 ) < 1e-23 , "Top height not correct" ); 01529 01530 sed_cell_array_free( c_arr ); 01531 sed_cell_destroy ( cell ); 01532 sed_column_destroy ( c ); 01533 } 01534 END_TEST 01535 01536 START_TEST ( test_sed_column_chop_below ) 01537 { 01538 Sed_column c_0; 01539 Sed_column c = sed_column_new( 5 ); 01540 Sed_cell cell = sed_cell_new_classed( NULL , 20 , S_SED_TYPE_SAND ); 01541 01542 sed_column_set_base_height( c , 123 ); 01543 01544 sed_column_add_cell( c , cell ); 01545 01546 c_0 = sed_column_chop( c , 120 ); 01547 01548 fail_unless( c_0==c , "Chopped column should be returned" ); 01549 fail_unless( fabs( sed_column_base_height(c)-120 ) < 1e-23 , "Chopping below column moves base" ); 01550 fail_unless( fabs( sed_column_top_height(c) -120 ) < 1e-23 , "Chopping below column removes all sediment" ); 01551 fail_unless( sed_column_is_empty(c) , "Chopping below column empties column" ); 01552 01553 sed_cell_destroy ( cell ); 01554 sed_column_destroy( c ); 01555 } 01556 END_TEST 01557 01558 START_TEST ( test_sed_column_chop_null ) 01559 { 01560 fail_unless( sed_column_chop( NULL , 120 )==NULL , "Chopping a NULL column returns NULL" ); 01561 } 01562 END_TEST 01563 01564 START_TEST ( test_sed_column_chomp_above ) 01565 { 01566 Sed_column c_0; 01567 Sed_column c = sed_column_new( 5 ); 01568 Sed_cell cell = sed_cell_new_classed( NULL , 20 , S_SED_TYPE_SAND ); 01569 01570 sed_column_set_base_height( c , 123 ); 01571 01572 sed_column_add_cell( c , cell ); 01573 01574 c_0 = sed_column_chomp( c , 153 ); 01575 01576 fail_unless( c_0==c , "Chompped column should be returned" ); 01577 fail_unless( fabs( sed_column_base_height(c)-153 ) < 1e-23 , "Base height not changed correctly" ); 01578 fail_unless( fabs( sed_column_top_height(c) -153 ) < 1e-23 , "Top height not changed correctly" ); 01579 01580 sed_cell_destroy ( cell ); 01581 sed_column_destroy( c ); 01582 } 01583 END_TEST 01584 01585 START_TEST ( test_sed_column_chomp_below ) 01586 { 01587 Sed_column c_0; 01588 Sed_column c = sed_column_new( 5 ); 01589 Sed_cell cell = sed_cell_new_classed( NULL , 20 , S_SED_TYPE_SAND ); 01590 01591 sed_column_set_base_height( c , 123 ); 01592 01593 sed_column_add_cell( c , cell ); 01594 01595 c_0 = sed_column_chomp( c , 120 ); 01596 01597 fail_unless( c_0==c , "Chompped column should be returned" ); 01598 fail_unless( fabs( sed_column_base_height(c)-123 ) < 1e-23 , "Base height not changed correctly" ); 01599 fail_unless( fabs( sed_column_top_height(c) -143 ) < 1e-23 , "Top height not changed correctly" ); 01600 01601 sed_cell_destroy ( cell ); 01602 sed_column_destroy( c ); 01603 } 01604 END_TEST 01605 01606 START_TEST ( test_sed_column_chomp_null ) 01607 { 01608 fail_unless( sed_column_chomp( NULL , 120 )==NULL , "Chomping a NULL column returns NULL" ); 01609 } 01610 END_TEST 01611 01612 START_TEST ( test_sed_cell_add_column ) 01613 { 01614 Sed_column s = sed_column_new( 5 ); 01615 Sed_cell cell = sed_cell_new_classed( NULL , 10 , S_SED_TYPE_SAND ); 01616 Sed_cell cell_0; 01617 double mass_in; 01618 01619 sed_cell_set_age( cell , 33 ); 01620 sed_column_add_cell( s , cell ); 01621 01622 sed_cell_set_age( cell , 66 ); 01623 sed_column_add_cell( s , cell ); 01624 01625 mass_in = sed_column_mass( s ); 01626 01627 sed_cell_clear( cell ); 01628 cell_0 = sed_cell_add_column( cell , s ); 01629 01630 fail_unless( cell_0==cell , "Cell should be returned" ); 01631 fail_unless( sed_cell_is_valid(cell) , "Cell isn't valid" ); 01632 fail_unless( sed_cell_is_mass(cell,mass_in) , "Cell mass doesn't match column mass" ); 01633 fail_unless( sed_cell_is_age(cell,49.5) , "Cell mass doesn't match column mass" ); 01634 fail_unless( sed_column_mass_is(s,mass_in) , "Column mass should not change" ); 01635 01636 sed_cell_add_column( cell , s ); 01637 01638 fail_unless( sed_cell_is_mass(cell,2*mass_in) , "Cell should not be cleared before being added to" ); 01639 01640 sed_cell_destroy ( cell ); 01641 sed_column_destroy( s ); 01642 } 01643 END_TEST 01644 01645 START_TEST ( test_sed_cell_add_column_dup ) 01646 { 01647 Sed_column s = sed_column_new( 5 ); 01648 Sed_cell cell = sed_cell_new_classed( NULL , 33 , S_SED_TYPE_SAND ); 01649 Sed_cell cell_0; 01650 double mass_in; 01651 01652 sed_cell_set_age( cell , 33 ); 01653 sed_column_add_cell( s , cell ); 01654 01655 mass_in = sed_column_mass( s ); 01656 01657 cell_0 = sed_cell_add_column( NULL , s ); 01658 01659 fail_unless( sed_cell_is_valid(cell_0) , "Cell isn't valid" ); 01660 fail_unless( sed_cell_is_mass(cell_0,mass_in) , "Cell mass doesn't match column mass" ); 01661 fail_unless( sed_cell_is_age(cell_0,33) , "Cell age doesn't match column age" ); 01662 01663 sed_cell_destroy ( cell ); 01664 sed_cell_destroy ( cell_0 ); 01665 sed_column_destroy( s ); 01666 } 01667 END_TEST 01668 01669 START_TEST ( test_sed_cell_add_column_null ) 01670 { 01671 Sed_cell cell = sed_cell_new_classed( NULL , 33 , S_SED_TYPE_SAND ); 01672 Sed_cell cell_0; 01673 01674 cell_0 = sed_cell_add_column( cell , NULL ); 01675 01676 fail_unless( cell_0==NULL , "A NULL column should return a NULL cell" ); 01677 01678 sed_cell_destroy ( cell ); 01679 } 01680 END_TEST 01681 01682 START_TEST ( test_sed_column_add ) 01683 { 01684 Sed_column d = sed_column_new( 5 ); 01685 Sed_column s = sed_column_new( 5 ); 01686 Sed_cell c = sed_cell_new_classed( NULL , 58 , S_SED_TYPE_SAND|S_SED_TYPE_CLAY ); 01687 Sed_column d_0; 01688 double mass_in; 01689 01690 sed_column_set_base_height( s , 666 ); 01691 sed_column_set_base_height( d , 868 ); 01692 01693 sed_column_add_cell( s , c ); 01694 01695 mass_in = sed_column_mass( s ); 01696 01697 d_0 = sed_column_add( d , s ); 01698 01699 fail_unless( sed_column_mass_is(d,sed_column_mass(s)) , "Source and destination mass does not match" ); 01700 fail_unless( sed_column_mass_is(s,mass_in) , "Source column mass should not change" ); 01701 fail_unless( d_0==d , "Should return destination column" ); 01702 fail_unless( fabs(sed_column_base_height(d)-868) < 1e-12 , "Column height should not change" ); 01703 01704 sed_column_add( d , s ); 01705 01706 fail_unless( sed_column_mass_is(d,2.*mass_in) , "Destination column is not cleared before addition" ); 01707 01708 sed_cell_destroy ( c ); 01709 sed_column_destroy( d ); 01710 sed_column_destroy( s ); 01711 } 01712 END_TEST 01713 01714 START_TEST ( test_sed_column_add_dup ) 01715 { 01716 Sed_column d; 01717 Sed_column s = sed_column_new( 5 ); 01718 Sed_column s_0 = sed_column_new( 5 ); 01719 Sed_cell c = sed_cell_new_classed( NULL , 58 , S_SED_TYPE_SAND|S_SED_TYPE_CLAY ); 01720 01721 sed_column_set_base_height( s , 666 ); 01722 sed_column_set_z_res( s , 1.2 ); 01723 01724 d = sed_column_add( NULL , s ); 01725 01726 fail_if ( d==NULL , "A non-NULL column should be returned" ); 01727 fail_if ( d==s , "A new column should be created" ); 01728 fail_unless( sed_column_is_same_data(d,s_0) , "New column should keep newly-created data" ); 01729 fail_unless( sed_column_is_empty(d) , "Columns not added correctly" ); 01730 01731 sed_column_add_cell( s , c ); 01732 sed_column_destroy( d ); 01733 01734 d = sed_column_add( NULL , s ); 01735 01736 fail_unless( sed_column_mass_is(d,sed_column_mass(s)) , "Source and destination mass does not match" ); 01737 01738 sed_cell_destroy ( c ); 01739 sed_column_destroy( d ); 01740 sed_column_destroy( s ); 01741 sed_column_destroy( s_0 ); 01742 } 01743 END_TEST 01744 01745 START_TEST ( test_sed_column_add_null ) 01746 { 01747 Sed_column d = sed_column_new( 5 ); 01748 01749 fail_unless( sed_column_add( d , NULL )==NULL , "A NULL source column returns a NULL column" ); 01750 01751 sed_column_destroy( d ); 01752 } 01753 END_TEST 01754 01755 START_TEST ( test_sed_column_remove ) 01756 { 01757 Sed_column d_0; 01758 Sed_column d = sed_column_new( 5 ); 01759 Sed_column s = sed_column_new( 5 ); 01760 Sed_cell c_1 = sed_cell_new_classed( NULL , 25 , S_SED_TYPE_SAND ); 01761 01762 sed_column_set_base_height( d , 100 ); 01763 01764 sed_column_add_cell( d , c_1 ); 01765 sed_column_add_cell( d , c_1 ); 01766 sed_column_add_cell( d , c_1 ); 01767 01768 sed_column_set_base_height( s , 125 ); 01769 01770 d_0 = sed_column_remove( d , s ); 01771 01772 fail_unless( d_0==d , "Eroded column should be returned" ); 01773 fail_unless( sed_column_base_height_is( d , 100 ) , "Base height should not change" ); 01774 fail_unless( sed_column_top_height_is ( d , 125 ) , "Top height should be source base height" ); 01775 fail_unless( sed_column_mass_is ( d , sed_cell_mass(c_1) ) , "Incorrect mass after erosion" ); 01776 01777 sed_cell_destroy ( c_1 ); 01778 sed_column_destroy( d ); 01779 sed_column_destroy( s ); 01780 } 01781 END_TEST 01782 01783 START_TEST ( test_sed_column_remove_above ) 01784 { 01785 Sed_column d = sed_column_new( 5 ); 01786 Sed_column s = sed_column_new( 5 ); 01787 Sed_cell c_1 = sed_cell_new_classed( NULL , 25 , S_SED_TYPE_SAND ); 01788 01789 sed_column_set_base_height( d , 100 ); 01790 01791 sed_column_add_cell( d , c_1 ); 01792 01793 sed_column_set_base_height( s , 135 ); 01794 01795 sed_column_remove( d , s ); 01796 01797 fail_unless( sed_column_base_height_is( d , 100 ) , "Base height should not change" ); 01798 fail_unless( sed_column_top_height_is ( d , 125 ) , "Top height should be source base height" ); 01799 fail_unless( sed_column_mass_is ( d , sed_cell_mass(c_1) ) , "Incorrect mass after erosion" ); 01800 01801 sed_cell_destroy ( c_1 ); 01802 sed_column_destroy( d ); 01803 sed_column_destroy( s ); 01804 } 01805 END_TEST 01806 01807 START_TEST ( test_sed_column_remove_below ) 01808 { 01809 Sed_column d = sed_column_new( 5 ); 01810 Sed_column s = sed_column_new( 5 ); 01811 Sed_cell c_1 = sed_cell_new_classed( NULL , 25 , S_SED_TYPE_SAND ); 01812 01813 sed_column_set_base_height( d , 100 ); 01814 01815 sed_column_add_cell( d , c_1 ); 01816 01817 sed_column_set_base_height( s , 75 ); 01818 01819 sed_column_remove( d , s ); 01820 01821 fail_unless( sed_column_base_height_is( d , 75 ) , "Erosion below base changes base height" ); 01822 fail_unless( sed_column_top_height_is ( d , 75 ) , "Erosion below base removes all sediment" ); 01823 fail_unless( sed_column_is_empty(d) , "Erosion below base empties column" ); 01824 01825 sed_cell_destroy ( c_1 ); 01826 sed_column_destroy( d ); 01827 sed_column_destroy( s ); 01828 } 01829 END_TEST 01830 01831 START_TEST ( test_sed_column_remove_empty ) 01832 { 01833 Sed_column d = sed_column_new( 5 ); 01834 Sed_column s = sed_column_new( 55 ); 01835 01836 sed_column_set_base_height( d , 100 ); 01837 sed_column_set_base_height( s , 125 ); 01838 01839 sed_column_remove( d , s ); 01840 01841 fail_unless( sed_column_is_empty(d) , "Erosion of an empty column produces an empty column" ); 01842 fail_unless( sed_column_base_height_is( d , 100 ) , "Erosion above an empty column causes no change in height" ); 01843 01844 sed_column_set_base_height( s , 75 ); 01845 01846 sed_column_remove( d , s ); 01847 01848 fail_unless( sed_column_is_empty(d) , "Erosion of an empty column produces an empty column" ); 01849 fail_unless( sed_column_base_height_is( d , 75 ) , "Erosion below an empty column changes its base height" ); 01850 01851 sed_column_destroy( d ); 01852 sed_column_destroy( s ); 01853 } 01854 END_TEST 01855 01856 Suite *sed_column_suite( void ) 01857 { 01858 Suite *s = suite_create( "Sed_column" ); 01859 TCase *test_case_core = tcase_create( "Core" ); 01860 TCase *test_case_limits = tcase_create( "Limits" ); 01861 TCase *test_case_set = tcase_create( "Set" ); 01862 TCase *test_case_io = tcase_create( "IO" ); 01863 01864 suite_add_tcase( s , test_case_core ); 01865 suite_add_tcase( s , test_case_limits ); 01866 suite_add_tcase( s , test_case_set ); 01867 suite_add_tcase( s , test_case_io ); 01868 01869 tcase_add_test( test_case_core , test_sed_column_new ); 01870 tcase_add_test( test_case_core , test_sed_column_destroy ); 01871 tcase_add_test( test_case_core , test_sed_column_copy ); 01872 tcase_add_test( test_case_core , test_sed_column_clear ); 01873 tcase_add_test( test_case_core , test_sed_column_stack_cells_loc ); 01874 tcase_add_test( test_case_core , test_sed_column_add_cell ); 01875 tcase_add_test( test_case_core , test_sed_column_add_cell_small ); 01876 tcase_add_test( test_case_core , test_sed_column_add_cell_large ); 01877 tcase_add_test( test_case_core , test_sed_column_stack_cell ); 01878 tcase_add_test( test_case_core , test_sed_column_resize_cell ); 01879 tcase_add_test( test_case_core , test_sed_column_compact_cell ); 01880 tcase_add_test( test_case_core , test_sed_column_height ); 01881 tcase_add_test( test_case_core , test_sed_column_top_cell ); 01882 tcase_add_test( test_case_core , test_sed_column_nth_cell ); 01883 tcase_add_test( test_case_core , test_sed_column_load ); 01884 tcase_add_test( test_case_core , test_sed_column_load_at ); 01885 tcase_add_test( test_case_core , test_sed_column_total_load ); 01886 tcase_add_test( test_case_core , test_sed_column_top_index ); 01887 tcase_add_test( test_case_core , test_sed_column_is_valid_index ); 01888 tcase_add_test( test_case_core , test_sed_column_is_get_index ); 01889 tcase_add_test( test_case_core , test_sed_column_is_set_index ); 01890 tcase_add_test( test_case_core , test_sed_column_index_at ); 01891 tcase_add_test( test_case_core , test_sed_column_index_thickness ); 01892 tcase_add_test( test_case_core , test_sed_column_index_depth ); 01893 tcase_add_test( test_case_core , test_sed_column_depth_age ); 01894 tcase_add_test( test_case_core , test_sed_column_top_nbins ); 01895 tcase_add_test( test_case_core , test_sed_column_rebin ); 01896 tcase_add_test( test_case_core , test_sed_column_thickness_index ); 01897 tcase_add_test( test_case_core , test_sed_column_is_above ); 01898 tcase_add_test( test_case_core , test_sed_column_is_below ); 01899 tcase_add_test( test_case_core , test_sed_column_chop ); 01900 tcase_add_test( test_case_core , test_sed_column_chomp ); 01901 tcase_add_test( test_case_core , test_sed_column_strip ); 01902 tcase_add_test( test_case_core , test_sed_cell_add_column ); 01903 tcase_add_test( test_case_core , test_sed_column_add ); 01904 tcase_add_test( test_case_core , test_sed_column_remove ); 01905 tcase_add_test( test_case_core , test_sed_column_top ); 01906 tcase_add_test( test_case_core , test_sed_column_top_rho ); 01907 tcase_add_test( test_case_core , test_sed_column_top_age ); 01908 tcase_add_test( test_case_core , test_sed_column_top_property ); 01909 tcase_add_test( test_case_core , test_sed_column_top_property_with_load ); 01910 01911 tcase_add_test( test_case_set , test_sed_column_set_height ); 01912 tcase_add_test( test_case_set , test_sed_column_set_x_position ); 01913 tcase_add_test( test_case_set , test_sed_column_set_y_position ); 01914 tcase_add_test( test_case_set , test_sed_column_set_z_res ); 01915 01916 tcase_add_test( test_case_limits , test_sed_column_destroy_null ); 01917 tcase_add_test( test_case_limits , test_sed_column_copy_null ); 01918 tcase_add_test( test_case_limits , test_sed_column_new_neg ); 01919 tcase_add_test( test_case_limits , test_sed_column_new_zero ); 01920 tcase_add_test( test_case_limits , test_sed_column_add_cell_empty ); 01921 tcase_add_test( test_case_limits , test_sed_column_resize_cell_neg ); 01922 tcase_add_test( test_case_limits , test_sed_column_resize_cell_over ); 01923 tcase_add_test( test_case_limits , test_sed_column_resize_cell_under ); 01924 tcase_add_test( test_case_limits , test_sed_column_load_partial ); 01925 tcase_add_test( test_case_limits , test_sed_column_load_null ); 01926 tcase_add_test( test_case_limits , test_sed_column_load_neg_start ); 01927 tcase_add_test( test_case_limits , test_sed_column_load_neg_bins ); 01928 tcase_add_test( test_case_limits , test_sed_column_top_index_null ); 01929 tcase_add_test( test_case_limits , test_sed_column_top_index_empty ); 01930 tcase_add_test( test_case_limits , test_sed_column_nth_cell_empty ); 01931 tcase_add_test( test_case_limits , test_sed_column_nth_cell_null ); 01932 tcase_add_test( test_case_limits , test_sed_column_index_at_base ); 01933 tcase_add_test( test_case_limits , test_sed_column_index_at_above ); 01934 tcase_add_test( test_case_limits , test_sed_column_index_at_below ); 01935 tcase_add_test( test_case_limits , test_sed_column_height_empty ); 01936 tcase_add_test( test_case_limits , test_sed_column_height_null ); 01937 tcase_add_test( test_case_limits , test_sed_column_thickness_index_neg ); 01938 tcase_add_test( test_case_limits , test_sed_column_thickness_index_above ); 01939 tcase_add_test( test_case_limits , test_sed_column_thickness_index_null ); 01940 tcase_add_test( test_case_limits , test_sed_column_thickness_index_empty ); 01941 tcase_add_test( test_case_limits , test_sed_column_chomp_above ); 01942 tcase_add_test( test_case_limits , test_sed_column_chomp_below ); 01943 tcase_add_test( test_case_limits , test_sed_column_chomp_null ); 01944 tcase_add_test( test_case_limits , test_sed_column_extract_above_0 ); 01945 tcase_add_test( test_case_limits , test_sed_column_extract_above_1 ); 01946 tcase_add_test( test_case_limits , test_sed_column_extract_above_2 ); 01947 tcase_add_test( test_case_limits , test_sed_column_chop_above ); 01948 tcase_add_test( test_case_limits , test_sed_column_chop_below ); 01949 tcase_add_test( test_case_limits , test_sed_column_chop_null ); 01950 tcase_add_test( test_case_limits , test_sed_cell_add_column_null ); 01951 tcase_add_test( test_case_limits , test_sed_cell_add_column_dup ); 01952 tcase_add_test( test_case_limits , test_sed_column_add_null ); 01953 tcase_add_test( test_case_limits , test_sed_column_add_dup ); 01954 tcase_add_test( test_case_limits , test_sed_column_remove_above ); 01955 tcase_add_test( test_case_limits , test_sed_column_remove_below ); 01956 tcase_add_test( test_case_limits , test_sed_column_remove_empty ); 01957 tcase_add_test( test_case_limits , test_sed_column_top_above ); 01958 tcase_add_test( test_case_limits , test_sed_column_top_below ); 01959 tcase_add_test( test_case_limits , test_sed_column_top_null ); 01960 tcase_add_test( test_case_limits , test_sed_column_top_empty ); 01961 01962 tcase_add_test( test_case_io , test_sed_column_write ); 01963 tcase_add_test( test_case_io , test_sed_column_read ); 01964 01965 return s; 01966 } 01967 01968 #include "sed_sediment.h" 01969 01970 int test_sed_column( void ) 01971 { 01972 int n; 01973 01974 { 01975 Suite *s = sed_column_suite(); 01976 SRunner *sr = srunner_create( s ); 01977 01978 srunner_run_all( sr , CK_NORMAL ); 01979 n = srunner_ntests_failed( sr ); 01980 srunner_free( sr ); 01981 } 01982 01983 return n; 01984 } 01985 01986