int main( int argc , char ** argv) {
const char * ptr1 = "Pointer1";
const char * ptr2 = "Pointer2";
arg_pack_type * arg_pack = arg_pack_alloc();
arg_pack_append_const_ptr( arg_pack , ptr1 );
arg_pack_append_const_ptr( arg_pack , ptr2 );
test_assert_ptr_equal( ptr1 , arg_pack_iget_const_ptr( arg_pack , 0 ));
test_assert_ptr_equal( ptr2 , arg_pack_iget_const_ptr( arg_pack , 1 ));
exit(0);
}
void test_reverse() {
const char * val1 = "value1";
const char * val2 = "value2";
const char * val3 = "value3";
const char * val4 = "value4";
vector_type * vector1 = vector_alloc_new( );
vector_type * vector2 = vector_alloc_new( );
vector_append_ref( vector1 , val1 );
vector_append_ref( vector1 , val2 );
vector_append_ref( vector1 , val3 );
vector_append_ref( vector1 , val4 );
vector_append_ref( vector2 , val1 );
vector_append_ref( vector2 , val2 );
vector_append_ref( vector2 , val3 );
vector_append_ref( vector2 , val4 );
vector_inplace_reverse( vector1 );
{
int i;
int size = vector_get_size( vector1 );
for (i=0; i < vector_get_size( vector1 ); i++)
test_assert_ptr_equal( vector_iget_const( vector2 , i ) , vector_iget_const( vector1 , size - 1 - i ));
}
vector_free( vector1 );
vector_free( vector2 );
}
int main(int argc , char ** argv) {
int lgr_nr = 77;
nnc_info_type * nnc_info = nnc_info_alloc(lgr_nr);
test_assert_int_equal( 0 , nnc_info_get_total_size( nnc_info ));
test_assert_int_equal( lgr_nr , nnc_info_get_lgr_nr( nnc_info ));
test_assert_true(nnc_info_is_instance(nnc_info));
test_assert_not_NULL(nnc_info);
nnc_info_add_nnc(nnc_info, lgr_nr, 110 , 0);
test_assert_int_equal( 1, nnc_info_get_total_size( nnc_info ));
nnc_info_add_nnc(nnc_info, 1, 110 , 1);
nnc_info_add_nnc(nnc_info, 1, 111 , 2);
test_assert_int_equal( 3, nnc_info_get_total_size( nnc_info ));
nnc_vector_type * nnc_vector = nnc_info_get_vector( nnc_info , 1);
const int_vector_type * nnc_cells = nnc_info_get_grid_index_list(nnc_info, 1);
test_assert_int_equal(int_vector_size(nnc_cells), 2);
test_assert_ptr_equal( nnc_cells , nnc_vector_get_grid_index_list( nnc_vector ));
nnc_vector_type * nnc_vector_null = nnc_info_get_vector( nnc_info , 2);
const int_vector_type * nnc_cells_null = nnc_info_get_grid_index_list(nnc_info, 2);
test_assert_NULL(nnc_cells_null);
test_assert_NULL(nnc_vector_null);
nnc_vector_type * nnc_vector_self = nnc_info_get_self_vector( nnc_info );
const nnc_vector_type * nnc_vector_77 = nnc_info_get_vector( nnc_info , lgr_nr );
test_assert_ptr_equal( nnc_vector_77 , nnc_vector_self );
const int_vector_type * nnc_cells_77 = nnc_info_get_grid_index_list(nnc_info, lgr_nr);
const int_vector_type * nnc_cells_self = nnc_info_get_self_grid_index_list(nnc_info);
test_assert_ptr_equal( nnc_cells_77 , nnc_cells_self );
test_assert_int_equal( 2 , nnc_info_get_size( nnc_info ));
test_assert_ptr_equal( nnc_info_get_vector( nnc_info , 1 ) , nnc_info_iget_vector( nnc_info , 1 ));
nnc_info_free(nnc_info);
exit(0);
}
void test_wrapper() {
local_obsdata_node_type * node = local_obsdata_node_alloc("KEY");
local_obsdata_type * data = local_obsdata_alloc_wrapper( node );
test_assert_true( local_obsdata_is_instance( data ));
test_assert_int_equal( 1 , local_obsdata_get_size( data ));
test_assert_ptr_equal( node , local_obsdata_iget( data , 0 ));
test_assert_true( local_obsdata_has_node( data , "KEY" ));
test_assert_false( local_obsdata_has_node( data , "KEYX" ));
test_assert_string_equal( local_obsdata_node_get_key( node ) , local_obsdata_get_name( data ));
local_obsdata_free( data );
}
void test_iget(ert_test_context_type * test_context) {
enkf_main_type * enkf_main = ert_test_context_get_main( test_context );
enkf_obs_type * enkf_obs = enkf_main_get_obs( enkf_main );
test_assert_int_equal( 32 , enkf_obs_get_size( enkf_obs ) );
for (int iobs = 0; iobs < enkf_obs_get_size( enkf_obs ); iobs++) {
obs_vector_type * vec1 = enkf_obs_iget_vector( enkf_obs , iobs );
obs_vector_type * vec2 = enkf_obs_get_vector( enkf_obs , obs_vector_get_key( vec1 ));
test_assert_ptr_equal( vec1 , vec2 );
}
}
int main(int argc , char ** argv) {
test_install_SIGNALS();
double * rseg_data = util_calloc( 100 , sizeof * rseg_data );
well_segment_collection_type * sc = well_segment_collection_alloc();
test_assert_not_NULL( sc );
test_assert_int_equal( well_segment_collection_get_size( sc ) , 0 );
{
int outlet_segment_id = ECLIPSE_WELL_SEGMENT_OUTLET_END_VALUE;
int branch_nr = ECLIPSE_WELL_SEGMENT_BRANCH_INACTIVE_VALUE;
well_segment_type * ws = well_segment_alloc(89 , outlet_segment_id , branch_nr, rseg_data);
well_segment_collection_add( sc , ws );
test_assert_int_equal( well_segment_collection_get_size( sc ) , 1);
test_assert_ptr_equal( well_segment_collection_iget( sc , 0 ) , ws );
test_assert_false( well_segment_collection_has_segment( sc , 451 ));
test_assert_true( well_segment_collection_has_segment( sc , 89 ));
test_assert_ptr_equal( well_segment_collection_get( sc , 89 ) , ws );
}
{
int outlet_segment_id = ECLIPSE_WELL_SEGMENT_OUTLET_END_VALUE;
int branch_nr = ECLIPSE_WELL_SEGMENT_BRANCH_INACTIVE_VALUE;
well_segment_type * ws = well_segment_alloc(90 , outlet_segment_id , branch_nr , rseg_data);
well_segment_collection_add( sc , ws );
test_assert_int_equal( well_segment_collection_get_size( sc ) , 2);
test_assert_ptr_equal( well_segment_collection_iget( sc , 1 ) , ws );
test_assert_false( well_segment_collection_has_segment( sc , 451 ));
test_assert_true( well_segment_collection_has_segment( sc , 89 ));
test_assert_true( well_segment_collection_has_segment( sc , 90 ));
test_assert_ptr_equal( well_segment_collection_get( sc , 90 ) , ws );
test_assert_NULL( well_segment_collection_get( sc , 76 ));
}
{
int outlet_segment_id = ECLIPSE_WELL_SEGMENT_OUTLET_END_VALUE;
int branch_nr = ECLIPSE_WELL_SEGMENT_BRANCH_INACTIVE_VALUE;
well_segment_type * ws = well_segment_alloc(89 , outlet_segment_id , branch_nr, rseg_data);
well_segment_collection_add( sc , ws );
test_assert_int_equal( well_segment_collection_get_size( sc ) , 2);
test_assert_ptr_equal( well_segment_collection_iget( sc , 0 ) , ws );
test_assert_false( well_segment_collection_has_segment( sc , 451 ));
test_assert_true( well_segment_collection_has_segment( sc , 89 ));
test_assert_ptr_equal( well_segment_collection_get( sc , 89 ) , ws );
}
free( rseg_data );
well_segment_collection_free( sc );
exit(0);
}
void test_add_job() {
job_list_type * list = job_list_alloc();
job_queue_node_type * node = job_queue_node_alloc_simple("name" , "/tmp" , "/bin/ls" , 0 , NULL);
job_list_add_job( list , node );
test_assert_int_equal( job_list_get_size( list ) , 1 );
test_assert_int_equal( job_queue_node_get_queue_index(node) , 0 );
test_assert_ptr_equal( node , job_list_iget_job(list , 0));
{
arg_pack_type * arg_pack = arg_pack_alloc( );
arg_pack_append_ptr( arg_pack , list );
arg_pack_append_ptr( arg_pack , node );
test_assert_util_abort("job_queue_node_set_queue_index", call_add_job, arg_pack );
arg_pack_free( arg_pack );
}
test_assert_util_abort("job_list_iget_job", call_iget_job, list);
job_list_reset( list );
test_assert_int_equal( 0 , job_list_get_size( list ));
job_list_free( list );
}
void test_close_stream1(const char * src_file , const char * target_file ) {
util_copy_file( src_file , target_file );
ecl_file_type * ecl_file = ecl_file_open( target_file , ECL_FILE_CLOSE_STREAM );
ecl_kw_type * kw0 = ecl_file_iget_kw( ecl_file , 0 );
ecl_kw_type * kw1 = ecl_file_iget_kw( ecl_file , 1 );
unlink( target_file );
ecl_kw_type * kw1b = ecl_file_iget_kw( ecl_file , 1 );
test_assert_not_NULL( kw0 );
test_assert_not_NULL( kw1 );
test_assert_ptr_equal( kw1 , kw1b );
ecl_kw_type * kw2 = ecl_file_iget_kw( ecl_file , 2 );
test_assert_NULL( kw2 );
test_assert_false( ecl_file_writable( ecl_file ));
ecl_file_close( ecl_file );
}
int main(int argc , char ** argv) {
local_obsdata_type * obsdata;
obsdata = local_obsdata_alloc( "KEY");
test_assert_true( local_obsdata_is_instance( obsdata ));
test_assert_int_equal( 0 , local_obsdata_get_size( obsdata ));
test_assert_string_equal( "KEY" , local_obsdata_get_name( obsdata ));
{
local_obsdata_node_type * obsnode = local_obsdata_node_alloc( "KEY" );
test_assert_true( local_obsdata_add_node( obsdata , obsnode ) );
test_assert_false( local_obsdata_add_node( obsdata , obsnode ) );
test_assert_int_equal( 1 , local_obsdata_get_size( obsdata ));
test_assert_ptr_equal( obsnode , local_obsdata_iget( obsdata , 0));
}
local_obsdata_free( obsdata );
test_wrapper();
exit(0);
}
// Hardcoded GURBAT values
void test_rft( const char * rft_file ) {
ecl_rft_file_type * rft = ecl_rft_file_alloc( rft_file );
ecl_rft_node_type * rft_node = ecl_rft_file_iget_node( rft , 0 );
test_assert_true( ecl_rft_node_is_RFT( rft_node ));
test_assert_int_equal( 14 , ecl_rft_node_get_size( rft_node ));
test_assert_false( ecl_rft_node_is_MSW( rft_node ));
test_assert_double_equal( 260.6111 , ecl_rft_node_iget_pressure( rft_node , 0 ));
test_assert_double_equal( 0.0581993 , ecl_rft_node_iget_soil( rft_node , 0 ));
test_assert_double_equal( 0.9405648 , ecl_rft_node_iget_swat( rft_node , 0 ));
test_assert_double_equal( 0.00123579 , ecl_rft_node_iget_sgas( rft_node , 0 ));
{
int i,j,k;
ecl_rft_node_iget_ijk( rft_node , 0 , &i , &j , &k );
test_assert_int_equal( 32 , i );
test_assert_int_equal( 53 , j );
test_assert_int_equal( 0 , k );
ecl_rft_node_iget_ijk( rft_node , 13 , &i , &j , &k );
test_assert_int_equal( 32 , i );
test_assert_int_equal( 54 , j );
test_assert_int_equal( 12 , k );
for (i=0; i < ecl_rft_node_get_size( rft_node ); i++) {
const ecl_rft_cell_type * cell1 = ecl_rft_node_iget_cell( rft_node , i );
const ecl_rft_cell_type * cell2 = ecl_rft_node_iget_cell_sorted( rft_node , i );
test_assert_ptr_equal( cell1 , cell2 );
}
}
ecl_rft_node_inplace_sort_cells( rft_node );
ecl_rft_file_free( rft );
}
// Hardcoded values from a test case with a PLT.
void test_plt( const char * plt_file ) {
ecl_rft_file_type * plt = ecl_rft_file_alloc( plt_file );
ecl_rft_node_type * plt_node = ecl_rft_file_iget_node( plt , 11 );
test_assert_true( ecl_rft_node_is_PLT( plt_node ));
test_assert_false( ecl_rft_node_is_MSW( plt_node ));
test_assert_int_equal( 22 , ecl_rft_node_get_size( plt_node ));
test_assert_double_equal( 244.284 , ecl_rft_node_iget_pressure( plt_node , 0 ));
test_assert_double_equal( 167.473 , ecl_rft_node_iget_orat( plt_node , 0 ));
test_assert_double_equal( 41682.2 , ecl_rft_node_iget_grat( plt_node , 0 ));
test_assert_double_equal( 0.958927 , ecl_rft_node_iget_wrat( plt_node , 0 ));
{
int i,j,k;
ecl_rft_node_iget_ijk( plt_node , 0 , &i , &j , &k );
test_assert_int_equal( 39 , i );
test_assert_int_equal( 33 , j );
test_assert_int_equal( 16 , k );
ecl_rft_node_iget_ijk( plt_node , 21 , &i , &j , &k );
test_assert_int_equal( 44 , i );
test_assert_int_equal( 34 , j );
test_assert_int_equal( 7 , k );
for (i=0; i < ecl_rft_node_get_size( plt_node ); i++) {
const ecl_rft_cell_type * cell1 = ecl_rft_node_iget_cell( plt_node , i );
const ecl_rft_cell_type * cell2 = ecl_rft_node_iget_cell_sorted( plt_node , i );
test_assert_ptr_equal( cell1 , cell2 );
}
ecl_rft_node_inplace_sort_cells( plt_node );
}
ecl_rft_file_free( plt );
}
int main(int argc , char ** argv) {
const char * Xfile = argv[1];
bool MSW;
ecl_file_type * rst_file = ecl_file_open( Xfile , 0 );
ecl_rsthead_type * rst_head = ecl_rsthead_alloc( ecl_file_get_global_view(rst_file) , ecl_util_filename_report_nr( Xfile ));
test_install_SIGNALS();
test_assert_true( util_sscanf_bool( argv[2] , &MSW ));
test_assert_not_NULL( rst_file );
test_assert_not_NULL( rst_head );
{
int iwell;
const ecl_kw_type * iwel_kw = ecl_file_iget_named_kw( rst_file , IWEL_KW , 0 );
const ecl_kw_type * icon_kw = ecl_file_iget_named_kw( rst_file , ICON_KW , 0 );
ecl_kw_type * scon_kw = NULL;
bool caseMSW = false;
for (iwell = 0; iwell < rst_head->nwells; iwell++) {
const int iwel_offset = rst_head->niwelz * iwell;
int num_connections = ecl_kw_iget_int( iwel_kw , iwel_offset + IWEL_CONNECTIONS_INDEX );
int iconn;
well_conn_collection_type * wellcc = well_conn_collection_alloc( );
well_conn_collection_type * wellcc_ref = well_conn_collection_alloc();
for (iconn = 0; iconn < num_connections; iconn++) {
well_conn_type * conn = well_conn_alloc_from_kw( icon_kw , scon_kw , rst_head , iwell , iconn );
test_assert_true( well_conn_is_instance( conn ));
test_assert_not_NULL( conn );
if (!MSW)
test_assert_bool_equal( well_conn_MSW( conn ) , MSW);
else
caseMSW |= well_conn_MSW( conn );
well_conn_collection_add( wellcc , conn );
well_conn_collection_add_ref( wellcc_ref , conn );
test_assert_int_equal( iconn + 1 , well_conn_collection_get_size( wellcc ));
test_assert_ptr_equal( well_conn_collection_iget_const( wellcc , iconn) , conn);
test_assert_ptr_equal( well_conn_collection_iget_const( wellcc_ref , iconn) , conn);
}
well_conn_collection_free( wellcc_ref );
{
int i;
for (i=0; i < well_conn_collection_get_size( wellcc ); i++)
test_assert_true( well_conn_is_instance( well_conn_collection_iget_const( wellcc , i )));
}
{
well_conn_collection_type * wellcc2 = well_conn_collection_alloc();
int i;
test_assert_int_equal( well_conn_collection_get_size( wellcc ) ,
well_conn_collection_load_from_kw( wellcc2 , iwel_kw , icon_kw , scon_kw , iwell , rst_head));
for (i=0; i < well_conn_collection_get_size( wellcc2 ); i++) {
test_assert_true( well_conn_is_instance( well_conn_collection_iget_const( wellcc2 , i )));
test_assert_true( well_conn_equal( well_conn_collection_iget_const( wellcc2 , i ) , well_conn_collection_iget_const( wellcc , i )));
}
well_conn_collection_free( wellcc2 );
}
well_conn_collection_free( wellcc );
}
test_assert_bool_equal( caseMSW , MSW);
}
exit( 0 );
}
