void test_update_store() {
{
test_work_area_type * work_area = test_work_area_alloc( "update-store1" );
char * work_cwd = util_alloc_string_copy( test_work_area_get_cwd( work_area ));
test_work_area_set_store( work_area , true );
test_work_area_free( work_area );
test_assert_true( util_entry_exists( work_cwd ));
}
{
test_work_area_type * work_area = test_work_area_alloc( "update-store2" );
char * work_cwd = util_alloc_string_copy( test_work_area_get_cwd( work_area ));
test_work_area_free( work_area );
test_assert_false( util_entry_exists( work_cwd ));
}
{
test_work_area_type * work_area = test_work_area_alloc( "update-store3" );
char * work_cwd = util_alloc_string_copy( test_work_area_get_cwd( work_area ));
test_work_area_set_store( work_area , false );
test_work_area_free( work_area );
test_assert_false( util_entry_exists( work_cwd ));
}
{
test_work_area_type * work_area = test_work_area_alloc( "update-store4" );
char * work_cwd = util_alloc_string_copy( test_work_area_get_cwd( work_area ));
test_work_area_set_store( work_area , true);
test_work_area_free( work_area );
test_assert_true( util_entry_exists( work_cwd ));
}
}
void test_create_simple() {
test_work_area_type * work_area = test_work_area_alloc("nnc-INIT");
{
int nx = 10;
int ny = 10;
int nz = 10;
ecl_grid_type * grid0 = ecl_grid_alloc_rectangular(nx,ny,nz,1,1,1,NULL);
ecl_grid_add_self_nnc(grid0, 0 ,nx*ny + 0, 0 );
ecl_grid_add_self_nnc(grid0, 1 ,nx*ny + 1, 1 );
ecl_grid_add_self_nnc(grid0, 2 ,nx*ny + 2, 2 );
{
ecl_nnc_geometry_type * nnc_geo = ecl_nnc_geometry_alloc( grid0 );
test_assert_int_equal( ecl_nnc_geometry_size( nnc_geo ) , 3 );
/*
Create a dummy INIT file which *ony* contains a TRANNC keyword with the correct size.
*/
{
ecl_kw_type * trann_nnc = ecl_kw_alloc(TRANNNC_KW , ecl_nnc_geometry_size( nnc_geo ), ECL_FLOAT);
fortio_type * f = fortio_open_writer( "TEST.INIT" , false, ECL_ENDIAN_FLIP );
for (int i=0; i < ecl_kw_get_size( trann_nnc); i++)
ecl_kw_iset_float( trann_nnc , i , i*1.0 );
ecl_kw_fwrite( trann_nnc , f );
fortio_fclose( f );
ecl_kw_free( trann_nnc );
}
}
ecl_grid_free( grid0 );
}
test_work_area_free( work_area );
}
int main(int argc , char ** argv) {
bool ok;
const char * input_path = argv[1];
const char * tex_file = argv[2];
test_work_area_type * work_area = test_work_area_alloc("latex-test");
test_work_area_copy_parent_content(work_area , input_path );
{
bool in_place = false;
latex_type * latex = latex_alloc( tex_file , in_place);
ok = latex_compile( latex , true , true , true);
test_assert_true( in_place == latex_compile_in_place( latex ));
latex_free( latex );
test_assert_true( ok );
}
{
latex_type * latex = latex_alloc( tex_file , false );
test_latex_link( latex );
latex_free( latex );
}
{
bool in_place = true;
latex_type * latex = latex_alloc( tex_file , in_place);
test_assert_true( in_place == latex_compile_in_place( latex ));
test_latex_link( latex );
latex_free( latex );
}
test_work_area_free(work_area);
exit(0);
}
void test_get_original_cwd() {
char * cwd = util_alloc_cwd();
test_work_area_type * work_area = test_work_area_alloc( "CWD-ORG-TEST");
test_assert_string_equal( cwd , test_work_area_get_original_cwd( work_area ));
free( cwd );
test_work_area_free( work_area );
}
void create_submit_script_script_according_to_input() {
test_work_area_type * work_area = test_work_area_alloc("job_torque_test" , true);
const char * script_filename = "qsub_script.sh";
{
char ** args = util_calloc(2, sizeof * args);
args[0] = "/tmp/jaja/";
args[1] = "number2arg";
torque_job_create_submit_script(script_filename, "job_program.py", 2, (const char **) args);
free( args );
}
{
FILE* file_stream = util_fopen(script_filename, "r");
bool at_eof = false;
char * line = util_fscanf_alloc_line(file_stream, &at_eof);
test_assert_string_equal("#!/bin/sh", line);
free(line);
line = util_fscanf_alloc_line(file_stream, &at_eof);
test_assert_string_equal("job_program.py /tmp/jaja/ number2arg", line);
free(line);
line = util_fscanf_alloc_line(file_stream, &at_eof);
free(line);
test_assert_true(at_eof);
fclose(file_stream);
}
test_work_area_free( work_area );
}
int main( int argc , char ** argv) {
util_install_signals();
{
const char * file = argv[1];
test_fortio_is_instance( file );
test_fortio_safe_cast( file );
test_assert_util_abort("fortio_safe_cast", test_fortio_unsafe_cast, NULL);
test_existing_read( file );
test_not_existing_read( );
test_open_close_read( file );
test_wrapper( file );
test_fread_truncated_head();
test_fread_truncated_data();
test_fread_truncated_tail();
test_fread_invalid_tail();
test_fseek();
test_at_eof();
test_write( "/tmp/path/does/not/exist" , false );
{
test_work_area_type * work_area = test_work_area_alloc("ecl_fortio.write" );
util_make_path("path");
test_write( "path/file.x" , true );
test_work_area_free( work_area );
}
exit(0);
}
}
void test_fortio_kw() {
test_work_area_type * work_area = test_work_area_alloc("fortio_kw");
ERT::EclKW<int> kw("XYZ" , 1000);
for (size_t i =0 ; i < kw.size(); i++)
kw[i] = i;
{
ERT::FortIO fortio("new_file" , std::fstream::out );
kw.fwrite( fortio );
fortio.close();
}
{
ERT::FortIO fortio("new_file" , std::fstream::in );
ERT::EclKW<int> kw2 = ERT::EclKW<int>::load( fortio );
fortio.close( );
for (size_t i =0 ; i < kw.size(); i++)
test_assert_int_equal( kw[i] , kw2[i]);
fortio = ERT::FortIO("new_file" , std::fstream::in );
test_assert_throw( ERT::EclKW<float>::load(fortio) , std::invalid_argument );
fortio.close();
}
test_work_area_free( work_area );
}
void test_copy_parent_content( const char * path ) {
char * full_path = util_alloc_abs_path( path );
char * parent_path = util_alloc_parent_path( full_path );
test_work_area_type * work_area = test_work_area_alloc( "copy-parent-content" );
test_assert_false( test_work_area_copy_parent_content( work_area , "Does/not/exist") );
test_assert_true( test_work_area_copy_parent_content( work_area , path ) );
{
struct dirent ** src_namelist;
struct dirent ** target_namelist;
int src_size = scandir( parent_path , &src_namelist , NULL , alphasort);
int target_size = scandir( test_work_area_get_cwd( work_area ) , &target_namelist , NULL , alphasort);
test_assert_int_equal( src_size , target_size );
for (int i=0; i < src_size; i++) {
test_assert_string_equal( src_namelist[i]->d_name , target_namelist[i]->d_name);
free( src_namelist[i] );
free( target_namelist[i] );
}
free( src_namelist );
free( target_namelist );
}
free( parent_path );
free( full_path );
test_work_area_free( work_area );
}
void simple_test() {
time_map_type * time_map = time_map_alloc( );
test_work_area_type * work_area = test_work_area_alloc("enkf_time_map" , true);
const char * mapfile = "map";
test_assert_true( time_map_update( time_map , 0 , 100 ) );
test_assert_true( time_map_update( time_map , 1 , 200 ) );
test_assert_true( time_map_update( time_map , 1 , 200 ) );
test_assert_false( time_map_update( time_map , 1 , 250 ) );
test_assert_true( time_map_equal( time_map , time_map ) );
time_map_fwrite( time_map , mapfile);
{
time_map_type * time_map2 = time_map_alloc( );
test_assert_false( time_map_equal( time_map , time_map2 ) );
time_map_fread( time_map2 , mapfile );
test_assert_true( time_map_equal( time_map , time_map2 ) );
time_map_free( time_map2 );
}
{
time_t mtime1 = util_file_mtime( mapfile );
sleep(2);
time_map_fwrite( time_map , mapfile);
test_assert_time_t_equal( mtime1 , util_file_mtime( mapfile ) );
time_map_update( time_map , 2 , 300 );
time_map_fwrite( time_map , mapfile);
test_assert_time_t_not_equal( mtime1 , util_file_mtime( mapfile ) );
}
test_work_area_free( work_area );
}
void test_fortio() {
test_work_area_type * work_area = test_work_area_alloc("fortio");
ERT::FortIO fortio("new_file" , std::fstream::out );
{
std::vector<int> data;
for (size_t i=0; i < 1000; i++)
data.push_back(i);
fortio_fwrite_record( fortio.getPointer() , reinterpret_cast<char *>(data.data()) , 1000 * 4 );
}
fortio.close();
fortio = ERT::FortIO("new_file" , std::fstream::in );
{
std::vector<int> data;
for (size_t i=0; i < 1000; i++)
data.push_back(99);
test_assert_true( fortio_fread_buffer( fortio.getPointer() , reinterpret_cast<char *>(data.data()) , 1000 * 4 ) );
for (size_t i =0; i < 1000; i++)
test_assert_size_t_equal(data[i], i);
}
fortio.close();
test_work_area_free( work_area );
test_assert_throw( ERT::FortIO fortio("file/does/not/exists" , std::fstream::in) , std::invalid_argument );
}
void test_filter_file1() {
subst_list_type * subst_list = subst_list_alloc( NULL );
test_work_area_type * work_area = test_work_area_alloc("subst_list/filter1");
{
FILE * stream = util_fopen("template" , "w");
fprintf(stream , "<KEY1>\n<KEY2>\n<KEY3>\n<KEY4>\n");
fclose(stream);
}
subst_list_append_copy( subst_list , "<KEY1>" , "Value1" , NULL);
subst_list_append_copy( subst_list , "<KEY2>" , "Value2" , NULL);
subst_list_append_copy( subst_list , "<KEY3>" , "Value3" , NULL);
subst_list_append_copy( subst_list , "<KEY4>" , "Value4" , NULL);
subst_list_filter_file( subst_list , "template" , "target");
{
FILE * stream = util_fopen("target" , "r");
char s1[128],s2[128],s3[128],s4[128];
test_assert_int_equal( 4 , fscanf( stream , "%s %s %s %s" , s1,s2,s3,s4));
fclose(stream);
test_assert_string_equal( s1 , "Value1");
test_assert_string_equal( s2 , "Value2");
test_assert_string_equal( s3 , "Value3");
test_assert_string_equal( s4 , "Value4");
}
test_work_area_free( work_area );
subst_list_free( subst_list );
}
void test_get_cwd() {
test_work_area_type * work_area = test_work_area_alloc( "CWD-TEST", false);
char * cwd = util_alloc_cwd();
test_assert_string_equal( cwd , test_work_area_get_cwd( work_area ));
free( cwd );
test_work_area_free( work_area );
}
void test_min_realizations_percent(const char * num_realizations_str, const char * min_realizations_str, int min_realizations){
test_work_area_type * work_area = test_work_area_alloc("test_min_realizations");
{
FILE * config_file_stream = util_mkdir_fopen("config_file", "w");
test_assert_not_NULL(config_file_stream);
fprintf(config_file_stream, num_realizations_str);
fprintf(config_file_stream, min_realizations_str);
fclose(config_file_stream);
config_type * c = config_alloc();
config_schema_item_type * item = config_add_schema_item(c , NUM_REALIZATIONS_KEY , true );
config_schema_item_set_default_type(item, CONFIG_INT);
config_schema_item_set_argc_minmax( item , 1 , 1);
item = config_add_schema_item(c , MIN_REALIZATIONS_KEY , false );
config_schema_item_set_argc_minmax( item , 1 , 2);
test_assert_true(config_parse(c , "config_file" , "--" , NULL , NULL , false , true ));
analysis_config_type * ac = create_analysis_config( );
analysis_config_init(ac, c);
test_assert_int_equal( min_realizations , analysis_config_get_min_realisations( ac ) );
analysis_config_free( ac );
config_free( c );
}
test_work_area_free(work_area);
}
void test_truncated() {
test_work_area_type * work_area = test_work_area_alloc("ecl_file_truncated" );
{
ecl_grid_type * grid = ecl_grid_alloc_rectangular(20,20,20,1,1,1,NULL);
ecl_grid_fwrite_EGRID2( grid , "TEST.EGRID", ECL_METRIC_UNITS );
ecl_grid_free( grid );
}
{
ecl_file_type * ecl_file = ecl_file_open("TEST.EGRID" , 0 );
test_assert_true( ecl_file_is_instance( ecl_file ) );
ecl_file_close( ecl_file );
}
{
offset_type file_size = util_file_size( "TEST.EGRID");
FILE * stream = util_fopen("TEST.EGRID" , "r+");
util_ftruncate( stream , file_size / 2 );
fclose( stream );
}
{
ecl_file_type * ecl_file = ecl_file_open("TEST.EGRID" , 0 );
test_assert_NULL( ecl_file );
}
test_work_area_free( work_area );
}
void test_fread_alloc() {
test_work_area_type * work_area = test_work_area_alloc("ecl_kw_fread" );
{
ecl_kw_type * kw1 = ecl_kw_alloc( "INT" , 100 , ECL_INT );
int i;
for (i=0; i < 100; i++)
ecl_kw_iset_int( kw1 , i , i );
{
fortio_type * fortio = fortio_open_writer("INT" , false , true );
ecl_kw_fwrite( kw1 , fortio );
fortio_fclose( fortio );
}
{
fortio_type * fortio = fortio_open_reader("INT" , false , true );
ecl_kw_type * kw2 = ecl_kw_fread_alloc( fortio );
test_assert_true( ecl_kw_is_instance( kw2 ));
test_assert_true( ecl_kw_equal( kw1 , kw2 ));
ecl_kw_free( kw2 );
fortio_fclose( fortio );
}
{
offset_type file_size = util_file_size("INT");
test_truncated("INT" , file_size - 4 );
test_truncated("INT" , file_size - 25 );
test_truncated("INT" , 5 );
test_truncated("INT" , 0 );
}
ecl_kw_free( kw1 );
}
test_work_area_free( work_area );
}
void test_fseek() {
test_work_area_type * work_area = test_work_area_alloc("fortio_fseek" );
{
fortio_type * fortio = fortio_open_writer("PRESSURE" , false , true);
void * buffer = util_malloc( 100 );
fortio_fwrite_record( fortio , buffer , 100);
free( buffer );
fortio_fclose( fortio );
}
{
fortio_type * fortio = fortio_open_reader("PRESSURE" , false , true);
printf("Starting fssek test \n");
test_assert_true( fortio_fseek( fortio , 0 , SEEK_SET ));
test_assert_true( fortio_fseek( fortio , 0 , SEEK_END ));
test_assert_false( fortio_fseek( fortio , 100000 , SEEK_END));
test_assert_false( fortio_fseek( fortio , 100000 , SEEK_SET));
fortio_fclose( fortio );
}
test_work_area_free( work_area );
}
void test_at_eof() {
test_work_area_type * work_area = test_work_area_alloc("fortio_truncated2" );
{
fortio_type * fortio = fortio_open_writer("PRESSURE" , false , true);
void * buffer = util_malloc( 100 );
fortio_fwrite_record( fortio , buffer , 100);
free( buffer );
fortio_fclose( fortio );
}
{
fortio_type * fortio = fortio_open_reader("PRESSURE" , false , true);
test_assert_false( fortio_read_at_eof( fortio ));
fortio_fseek( fortio , 50 , SEEK_SET );
test_assert_false( fortio_read_at_eof( fortio ));
fortio_fseek( fortio , 0 , SEEK_END );
test_assert_true( fortio_read_at_eof( fortio ));
fortio_fclose( fortio );
}
test_work_area_free( work_area );
}
void test_fread_invalid_tail() {
test_work_area_type * work_area = test_work_area_alloc("fortio_invalid" );
int record_size = 10;
void * buffer = util_malloc( record_size );
{
FILE * stream = util_fopen("PRESSURE" , "w");
util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__);
util_fwrite(buffer , 1 , record_size , stream , __func__);
util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__);
util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__);
util_fwrite(buffer , 1 , record_size , stream , __func__);
record_size += 1;
util_fwrite(&record_size , sizeof record_size , 1 , stream , __func__);
fclose(stream);
}
{
fortio_type * fortio = fortio_open_reader( "PRESSURE" , false , false );
record_size -= 1;
test_assert_true( fortio_fread_buffer( fortio , buffer , record_size ));
test_assert_false( fortio_fread_buffer( fortio , buffer , record_size ));
fortio_fclose( fortio );
}
free( buffer );
test_work_area_free( work_area );
}
void test_fread_truncated_tail() {
test_work_area_type * work_area = test_work_area_alloc("fortio_truncated2" );
{
const size_t buffer_size = 1000;
void * buffer = util_malloc( buffer_size );
{
fortio_type * fortio = fortio_open_writer( "PRESSURE" , false , true );
fortio_fwrite_record( fortio , buffer , buffer_size );
fortio_fseek( fortio , 0 , SEEK_SET);
util_ftruncate( fortio_get_FILE(fortio) , buffer_size + 4);
fortio_fclose( fortio );
}
test_assert_long_equal( util_file_size( "PRESSURE") , buffer_size + 4);
{
fortio_type * fortio = fortio_open_reader( "PRESSURE" , false , true );
test_assert_false( fortio_fread_buffer( fortio , buffer , buffer_size ));
fortio_fclose( fortio );
}
free( buffer );
}
test_work_area_free( work_area );
}
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_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 test_install_file_exists(const char * filename ) {
char * abs_input_path = util_alloc_abs_path( filename );
test_work_area_type * work_area = test_work_area_alloc( "FILE-TEST" );
test_work_area_install_file( work_area , filename );
test_assert_true( util_files_equal( abs_input_path , filename ));
test_work_area_free( work_area );
free( abs_input_path );
}
int main(int argc, char ** argv) {
test_work_area_type * work_area = test_work_area_alloc( "bsub_parse_stdout");
{
test_empty_file();
test_file_does_not_exist( );
test_OK();
test_parse_fail_abort();
}
test_work_area_free( work_area );
}
void test_copy_file( const char * src_file ) {
char * filename = util_split_alloc_filename( src_file );
test_work_area_type * work_area = test_work_area_alloc( "copy-file" );
test_work_area_copy_file( work_area , src_file );
test_assert_true( util_file_exists( filename ));
test_work_area_free( work_area );
free( filename );
}
void test_write_header() {
int nx = 10;
int ny = 10;
int nz = 5;
int_vector_type * actnum = int_vector_alloc( nx*ny*nz , 1 );
test_work_area_type * test_area = test_work_area_alloc( "ecl_init_file" );
time_t start_time = util_make_date(15 , 12 , 2010 );
ecl_grid_type * ecl_grid;
int_vector_iset( actnum , 10 , 0 );
int_vector_iset( actnum , 100 , 0 );
ecl_grid = ecl_grid_alloc_rectangular(nx, ny, nz, 1, 1, 1, int_vector_get_ptr( actnum ));
// Write poro with global size.
{
fortio_type * f = fortio_open_writer( "FOO1.INIT" , false , ECL_ENDIAN_FLIP );
ecl_kw_type * poro = ecl_kw_alloc( "PORO" , ecl_grid_get_global_size( ecl_grid ) , ECL_FLOAT_TYPE );
ecl_kw_scalar_set_float( poro , 0.10 );
ecl_init_file_fwrite_header( f , ecl_grid , poro , 7 , start_time );
ecl_kw_free( poro );
fortio_fclose( f );
}
// Write poro with nactive size.
{
fortio_type * f = fortio_open_writer( "FOO2.INIT" , false , ECL_ENDIAN_FLIP );
ecl_kw_type * poro = ecl_kw_alloc( "PORO" , ecl_grid_get_global_size( ecl_grid ) , ECL_FLOAT_TYPE );
ecl_kw_scalar_set_float( poro , 0.10 );
ecl_init_file_fwrite_header( f , ecl_grid , poro , 7 , start_time );
ecl_kw_free( poro );
fortio_fclose( f );
}
{
ecl_file_type * file1 = ecl_file_open( "FOO1.INIT" , 0 );
ecl_file_type * file2 = ecl_file_open( "FOO2.INIT" , 0 );
test_assert_true( ecl_kw_equal( ecl_file_iget_named_kw( file1 , "PORV" , 0 ) ,
ecl_file_iget_named_kw( file2 , "PORV" , 0)));
ecl_file_close( file2 );
ecl_file_close( file1 );
}
// Poro == NULL
{
fortio_type * f = fortio_open_writer( "FOO3.INIT" , false , ECL_ENDIAN_FLIP );
ecl_init_file_fwrite_header( f , ecl_grid , NULL , 7 , start_time );
fortio_fclose( f );
}
test_work_area_free( test_area );
}
void test_chdir() {
test_work_area_type * work_area = test_work_area_alloc("test-area");
const char * cwd = test_work_area_get_cwd( work_area );
test_assert_false( util_chdir_file( "/file/does/not/exist"));
test_assert_false( util_chdir_file( cwd ));
{
FILE * stream = util_mkdir_fopen("path/FILE","w");
fclose( stream );
}
test_assert_true( util_chdir_file( "path/FILE" ));
test_assert_string_equal( util_alloc_cwd() , util_alloc_filename( cwd, "path", NULL));
test_work_area_free( work_area );
}
int main(int argc , char ** argv) {
enkf_main_install_SIGNALS();
const char * root_path = argv[1];
const char * config_file = argv[2];
const char * init_file = argv[3];
const char * forward_init_string = argv[4];
test_work_area_type * work_area = test_work_area_alloc(config_file );
test_work_area_copy_directory_content( work_area , root_path );
test_work_area_install_file( work_area , init_file );
test_work_area_set_store(work_area, true);
bool strict = true;
enkf_main_type * enkf_main = enkf_main_bootstrap( NULL , config_file , strict , true );
enkf_fs_type * init_fs = enkf_main_get_fs(enkf_main);
enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 );
run_arg_type * run_arg = run_arg_alloc_ENSEMBLE_EXPERIMENT( init_fs , 0 ,0 , "simulations/run0");
enkf_node_type * field_node = enkf_state_get_node( state , "PORO" );
bool forward_init;
test_assert_true( util_sscanf_bool( forward_init_string , &forward_init));
test_assert_bool_equal( enkf_node_use_forward_init( field_node ) , forward_init );
test_assert_bool_equal( forward_init, ensemble_config_have_forward_init( enkf_main_get_ensemble_config( enkf_main )));
util_clear_directory( "Storage" , true , true );
create_runpath( enkf_main );
test_assert_true( util_is_directory( "simulations/run0" ));
if (forward_init)
util_copy_file( init_file , "simulations/run0/petro.grdecl");
{
bool_vector_type * iactive = bool_vector_alloc( enkf_main_get_ensemble_size(enkf_main) , true);
int error = 0;
stringlist_type * msg_list = stringlist_alloc_new();
enkf_state_load_from_forward_model( state , run_arg , &error , false , msg_list );
stringlist_free( msg_list );
bool_vector_free( iactive );
test_assert_int_equal(error, 0);
}
test_assert_true(check_original_exported_data_equal(field_node));
run_arg_free( run_arg );
enkf_main_free(enkf_main);
test_work_area_free(work_area);
}
void test_with_prefix() {
test_work_area_type * work_area = test_work_area_alloc( "with-prefix" );
util_make_path( "PREFIX" );
{
test_work_area_type * sub_area = test_work_area_alloc_relative("PREFIX" , "sub-work" );
test_assert_true( test_work_area_is_instance( sub_area ));
test_work_area_free( sub_area );
test_assert_true( util_entry_exists("PREFIX/sub-work"));
}
{
test_work_area_type * sub_area = test_work_area_alloc_relative("DoesNotExist" , "sub-work" );
test_assert_NULL( sub_area );
}
test_work_area_free( work_area );
}
void test_case_initialized() {
test_work_area_type * work_area = test_work_area_alloc("enkf_main_case_initialized" );
{
enkf_main_type * enkf_main = enkf_main_alloc_empty();
model_config_type * model_config = enkf_main_get_model_config(enkf_main);
const char * new_case = "fs/case";
char * mount_point = util_alloc_sprintf("%s/%s" , model_config_get_enspath(model_config) , new_case);
enkf_fs_create_fs(mount_point , BLOCK_FS_DRIVER_ID , NULL);
test_assert_false(enkf_main_case_is_initialized(enkf_main , "does/not/exist" , NULL));
test_assert_true(enkf_main_case_is_initialized(enkf_main , new_case , NULL));
enkf_main_free(enkf_main);
}
test_work_area_free(work_area);
}
int main(int argc , char ** argv) {
int i;
ecl_kw_type * ecl_kw = ecl_kw_alloc("HEAD" , 10 , ECL_INT_TYPE);
for (i=0; i < 10; i++)
ecl_kw_iset_int(ecl_kw , i , i );
{
test_work_area_type * work_area = test_work_area_alloc("ecl_kw_grdecl" , true);
FILE * stream = util_fopen( "FILE.grdecl" , "w");
ecl_kw_fprintf_grdecl(ecl_kw , stream );
fclose(stream);
stream = util_fopen( "FILE.grdecl" , "r");
{
ecl_kw_type * ecl_kw2 = ecl_kw_fscanf_alloc_grdecl( stream , "HEAD" , 10 , ECL_INT_TYPE);
test_assert_not_NULL( ecl_kw2 );
test_assert_true( ecl_kw_equal( ecl_kw , ecl_kw2));
ecl_kw_free( ecl_kw2 );
}
fclose( stream );
stream = util_fopen( "FILE.grdecl" , "w");
ecl_kw_fprintf_grdecl__(ecl_kw , "HEAD1234" , stream );
fclose( stream );
stream = util_fopen( "FILE.grdecl" , "r");
{
ecl_kw_type * ecl_kw2 = ecl_kw_fscanf_alloc_grdecl( stream , "HEAD" , 10 , ECL_INT_TYPE);
test_assert_NULL( ecl_kw2 );
ecl_kw2 = ecl_kw_fscanf_alloc_grdecl( stream , "HEAD1234" , 10 , ECL_INT_TYPE);
test_assert_not_NULL( ecl_kw2 );
test_assert_string_equal( ecl_kw_get_header( ecl_kw2 ) , "HEAD1234" );
test_assert_true( ecl_kw_content_equal( ecl_kw , ecl_kw2 ));
ecl_kw_free( ecl_kw2 );
}
fclose( stream );
test_work_area_free( work_area );
}
ecl_kw_free( ecl_kw );
exit(0);
}
