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_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 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 );
}
static enkf_fs_type * enkf_fs_alloc_empty( const char * mount_point , bool read_only) {
enkf_fs_type * fs = util_malloc(sizeof * fs );
UTIL_TYPE_ID_INIT( fs , ENKF_FS_TYPE_ID );
fs->time_map = time_map_alloc();
fs->cases_config = cases_config_alloc();
fs->state_map = state_map_alloc();
fs->misfit_ensemble = misfit_ensemble_alloc();
fs->index = NULL;
fs->eclipse_static = NULL;
fs->parameter = NULL;
fs->dynamic_forecast = NULL;
fs->dynamic_analyzed = NULL;
fs->read_only = read_only;
fs->mount_point = util_alloc_string_copy( mount_point );
fs->refcount = 0;
fs->lock_fd = 0;
if (mount_point == NULL)
util_abort("%s: fatal internal error: mount_point == NULL \n",__func__);
{
char ** path_tmp;
int path_len;
util_path_split( fs->mount_point , &path_len , &path_tmp);
fs->case_name = util_alloc_string_copy( path_tmp[path_len - 1]);
fs->root_path = util_alloc_joined_string( (const char **) path_tmp , path_len , UTIL_PATH_SEP_STRING);
fs->lock_file = util_alloc_filename( fs->mount_point , fs->case_name , "lock");
util_free_stringlist( path_tmp , path_len );
}
return fs;
}
state_map_type * state_map_alloc_copy( state_map_type * map ) {
state_map_type * copy = state_map_alloc();
pthread_rwlock_rdlock( &map->rw_lock );
{
int_vector_memcpy( copy->state , map->state );
}
pthread_rwlock_unlock( &map->rw_lock );
return copy;
}
state_map_type * state_map_fread_alloc( const char * filename ) {
state_map_type * map = state_map_alloc();
if (util_file_exists( filename )) {
FILE * stream = util_fopen( filename , "r");
int_vector_fread( map->state , stream );
fclose( stream );
}
return map;
}
void test_equal() {
state_map_type * state_map1 = state_map_alloc();
state_map_type * state_map2 = state_map_alloc();
test_assert_true( state_map_equal( state_map1 , state_map2 ));
for (int i =0; i < 25; i++) {
state_map_iset( state_map1 , i , STATE_INITIALIZED );
state_map_iset( state_map2 , i , STATE_INITIALIZED );
}
test_assert_true( state_map_equal( state_map1 , state_map2 ));
state_map_iset( state_map2 , 15 , STATE_HAS_DATA );
test_assert_false( state_map_equal( state_map1 , state_map2 ));
state_map_iset( state_map2 , 15 , STATE_LOAD_FAILURE );
state_map_iset( state_map2 , 15 , STATE_INITIALIZED );
test_assert_true( state_map_equal( state_map1 , state_map2 ));
state_map_iset( state_map2 , 150 , STATE_INITIALIZED );
test_assert_false( state_map_equal( state_map1 , state_map2 ));
}
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 test_copy() {
state_map_type * state_map = state_map_alloc();
state_map_iset( state_map , 0 , STATE_INITIALIZED );
state_map_iset( state_map , 100 , STATE_INITIALIZED );
{
state_map_type * copy = state_map_alloc_copy( state_map );
test_assert_true( state_map_equal( copy , state_map ));
state_map_iset( state_map , 10 , STATE_INITIALIZED );
test_assert_false( state_map_equal( copy , state_map ));
state_map_free( copy );
}
state_map_free( state_map );
}
void test_update_undefined( ) {
state_map_type * map = state_map_alloc( );
state_map_iset( map , 10 , STATE_INITIALIZED );
test_assert_int_equal( STATE_UNDEFINED , state_map_iget( map , 5 ) );
test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map , 10 ) );
state_map_update_undefined( map , 5 , STATE_INITIALIZED );
test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map , 5 ) );
state_map_update_undefined( map , 10 , STATE_INITIALIZED );
test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map , 10 ) );
state_map_free( map );
}
void test_count_matching() {
state_map_type * map1 = state_map_alloc();
state_map_iset(map1 , 10 , STATE_INITIALIZED );
state_map_iset(map1 , 15 , STATE_INITIALIZED );
state_map_iset(map1 , 15 , STATE_HAS_DATA );
state_map_iset(map1 , 16 , STATE_INITIALIZED );
state_map_iset(map1 , 16 , STATE_HAS_DATA );
state_map_iset(map1 , 16 , STATE_LOAD_FAILURE );
test_assert_int_equal( 1 , state_map_count_matching( map1 , STATE_HAS_DATA));
test_assert_int_equal( 2 , state_map_count_matching( map1 , STATE_HAS_DATA | STATE_LOAD_FAILURE));
test_assert_int_equal( 3 , state_map_count_matching( map1 , STATE_HAS_DATA | STATE_LOAD_FAILURE | STATE_INITIALIZED));
state_map_free( map1 );
}
void test_update_matching( ) {
state_map_type * map = state_map_alloc( );
state_map_iset( map , 10 , STATE_INITIALIZED );
state_map_iset( map , 3 , STATE_PARENT_FAILURE );
test_assert_int_equal( STATE_UNDEFINED , state_map_iget( map , 5 ) );
test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map , 10 ) );
state_map_update_matching( map , 5 , STATE_UNDEFINED | STATE_LOAD_FAILURE , STATE_INITIALIZED );
state_map_update_matching( map , 10 , STATE_UNDEFINED | STATE_LOAD_FAILURE , STATE_INITIALIZED );
state_map_update_matching( map , 3 , STATE_UNDEFINED | STATE_LOAD_FAILURE , STATE_INITIALIZED );
test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map , 5 ) );
test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map , 10 ) );
test_assert_int_equal( STATE_PARENT_FAILURE , state_map_iget( map , 3 ) );
state_map_update_undefined( map , 10 , STATE_INITIALIZED );
test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map , 10 ) );
state_map_free( map );
}
void get_test( ) {
state_map_type * state_map = state_map_alloc();
test_assert_int_equal( STATE_UNDEFINED , state_map_iget( state_map , 0 ));
test_assert_int_equal( STATE_UNDEFINED , state_map_iget( state_map , 100 ));
state_map_free( state_map );
}
