void test_set_from_mask() {
int i;
state_map_type * map1 = state_map_alloc();
state_map_type * map2 = state_map_alloc();
bool_vector_type * mask = bool_vector_alloc(0, false);
bool_vector_iset(mask , 10 , true);
bool_vector_iset(mask , 20 , true);
state_map_set_from_mask(map1 , mask , STATE_INITIALIZED);
state_map_set_from_inverted_mask(map2 , mask , STATE_INITIALIZED);
test_assert_int_equal(21 , state_map_get_size(map1));
test_assert_int_equal(21 , state_map_get_size(map2));
for (i = 0; i < state_map_get_size(map1); i++) {
if (i == 10 || i== 20) {
test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map1 , i) );
test_assert_int_equal( STATE_UNDEFINED , state_map_iget(map2 , i));
}
else {
test_assert_int_equal(STATE_UNDEFINED , state_map_iget(map1 , i ));
test_assert_int_equal( STATE_INITIALIZED , state_map_iget(map2 , i));
}
}
}
void test_init_case_job(ert_test_context_type * test_context, const char * job_name , const char * job_file) {
stringlist_type * args = stringlist_alloc_new();
enkf_main_type * enkf_main = ert_test_context_get_main(test_context);
test_assert_true( ert_test_context_install_workflow_job( test_context , "JOB" , job_file ) );
//Test init current case from existing
{
enkf_fs_type * cur_fs = enkf_main_mount_alt_fs( enkf_main , "new_current_case" , true );
enkf_main_select_fs(enkf_main, "new_current_case");
test_assert_ptr_not_equal(cur_fs , enkf_main_get_fs( enkf_main ));
stringlist_append_copy( args, "default"); //case to init from
test_assert_true( ert_test_context_run_worklow_job( test_context , "JOB" , args) );
enkf_fs_decref(cur_fs);
}
{
const char * current_case = enkf_main_get_current_fs( enkf_main );
test_assert_string_equal(current_case, "new_current_case");
test_assert_true(enkf_fs_has_node(enkf_main_get_fs(enkf_main), "PERMZ", PARAMETER, 0, 0, ANALYZED));
enkf_fs_type * default_fs = enkf_main_mount_alt_fs( enkf_main , "default" , true );
state_map_type * default_state_map = enkf_fs_get_state_map(default_fs);
state_map_type * current_state_map = enkf_fs_get_state_map(enkf_main_get_fs(enkf_main));
test_assert_int_equal(state_map_get_size(default_state_map), state_map_get_size(current_state_map));
enkf_fs_decref(default_fs);
}
//Test init case from existing case:
stringlist_clear(args);
stringlist_append_copy(args, "default"); //case to init from
stringlist_append_copy(args, "new_not_current_case");
test_assert_true( ert_test_context_run_worklow_job( test_context , "JOB" , args) );
{
enkf_fs_type * fs = enkf_main_mount_alt_fs(enkf_main, "new_not_current_case", true);
test_assert_not_NULL( fs );
test_assert_true( enkf_fs_has_node(fs, "PERMZ", PARAMETER, 0, 0, ANALYZED ));
enkf_fs_type * default_fs = enkf_main_mount_alt_fs( enkf_main , "default" , true );
state_map_type * default_state_map = enkf_fs_get_state_map(default_fs);
state_map_type * new_state_map = enkf_fs_get_state_map(fs);
test_assert_int_equal(state_map_get_size(default_state_map), state_map_get_size(new_state_map));
enkf_fs_decref(fs);
}
stringlist_free( args );
}
void create_test() {
state_map_type * state_map = state_map_alloc();
test_assert_true( state_map_is_instance( state_map ));
test_assert_int_equal( 0 , state_map_get_size( state_map ));
test_assert_false( state_map_is_readonly( state_map ));
state_map_free( state_map );
}
void test_readonly() {
{
state_map_type * map1 = state_map_fread_alloc_readonly("FileDoesNotExist");
test_assert_true(state_map_is_instance(map1));
test_assert_int_equal(0 , state_map_get_size( map1 ));
test_assert_true( state_map_is_readonly( map1 ));
state_map_free(map1);
}
{
test_work_area_type * work_area = test_work_area_alloc("state-map");
state_map_type * map1 = state_map_alloc();
state_map_iset(map1 , 5 , STATE_INITIALIZED);
state_map_iset(map1 , 9 , STATE_INITIALIZED);
state_map_fwrite(map1 , "map1");
{
state_map_type * map2 = state_map_fread_alloc_readonly("map1");
test_assert_true(state_map_equal(map1 , map2));
state_map_free(map2);
}
test_work_area_free( work_area );
state_map_free(map1);
}
}
void test_deselect_matching( ) {
state_map_type * map = state_map_alloc( );
bool_vector_type * mask1 = bool_vector_alloc(0 , false);
bool_vector_type * mask2 = bool_vector_alloc(1000 , true);
state_map_iset( map , 10 , STATE_INITIALIZED );
state_map_iset( map , 10 , STATE_HAS_DATA );
state_map_iset( map , 20 , STATE_INITIALIZED );
state_map_deselect_matching( map , mask1 , STATE_HAS_DATA | STATE_INITIALIZED );
state_map_deselect_matching( map , mask2 , STATE_HAS_DATA | STATE_INITIALIZED );
test_assert_int_equal( state_map_get_size( map ) , bool_vector_size( mask1 ));
for (int i=0; i < bool_vector_size( mask1 ); i++) {
if (i==10)
test_assert_false( bool_vector_iget( mask1 , i ));
else if (i== 20)
test_assert_false( bool_vector_iget( mask2 , i ));
else {
test_assert_false( bool_vector_iget( mask1 , i ));
test_assert_true( bool_vector_iget( mask2 , i ));
}
}
bool_vector_free( mask1 );
bool_vector_free( mask2 );
state_map_free( map );
}
void test_io( ) {
test_work_area_type * work_area = test_work_area_alloc( "enkf-state-map" );
{
state_map_type * state_map = state_map_alloc();
state_map_type * copy1 , *copy2;
state_map_iset( state_map , 0 , STATE_INITIALIZED );
state_map_iset( state_map , 100 , STATE_INITIALIZED );
state_map_fwrite( state_map , "map");
copy1 = state_map_fread_alloc( "map" );
test_assert_true( state_map_equal( state_map , copy1 ));
copy2 = state_map_alloc();
state_map_fread( copy2 , "map" );
test_assert_true( state_map_equal( state_map , copy2 ));
state_map_iset( copy2 , 67 , STATE_INITIALIZED );
test_assert_false(state_map_equal( state_map , copy2 ));
state_map_fread( copy2 , "map");
test_assert_true( state_map_equal( state_map , copy2 ));
state_map_fread( copy2 , "DoesNotExis");
test_assert_int_equal( 0 , state_map_get_size( copy2 ));
}
test_work_area_free( work_area );
}
void enkf_plot_gen_kw_load( enkf_plot_gen_kw_type * plot_gen_kw,
enkf_fs_type * fs,
bool transform_data ,
int report_step,
const bool_vector_type * input_mask ) {
state_map_type * state_map = enkf_fs_get_state_map( fs );
int ens_size = state_map_get_size( state_map );
bool_vector_type * mask;
if (input_mask)
mask = bool_vector_alloc_copy( input_mask );
else
mask = bool_vector_alloc( ens_size , true );
enkf_plot_gen_kw_resize( plot_gen_kw , ens_size );
{
int iens;
for (iens = 0; iens < ens_size; ++iens) {
if (bool_vector_iget( mask , iens)) {
enkf_plot_gen_kw_vector_type * vector = enkf_plot_gen_kw_iget( plot_gen_kw , iens );
enkf_plot_gen_kw_vector_load( vector , fs , transform_data , report_step );
}
}
}
}
void set_test( ) {
state_map_type * state_map = state_map_alloc();
state_map_iset( state_map , 0 , STATE_INITIALIZED );
test_assert_int_equal( STATE_INITIALIZED , state_map_iget( state_map , 0 ));
state_map_iset( state_map , 100 , STATE_INITIALIZED );
test_assert_int_equal( STATE_INITIALIZED , state_map_iget( state_map , 100 ));
test_assert_int_equal( STATE_UNDEFINED , state_map_iget( state_map , 50 ));
test_assert_int_equal( 101 , state_map_get_size( state_map ));
state_map_free( state_map );
}
void load_empty_test() {
state_map_type * state_map = state_map_fread_alloc( "File/does/not/exists" );
test_assert_true( state_map_is_instance( state_map ));
test_assert_int_equal( 0 , state_map_get_size( state_map ));
state_map_free( state_map );
}
