Example #1
0
void test_read_erroneous_gen_kw_file() {
  const char * parameter_filename = "MULTFLT_with_errors.txt";
  const char * tmpl_filename = "MULTFLT.tmpl";

  {
    FILE * stream = util_fopen(parameter_filename, "w");
    const char * data = util_alloc_sprintf("MULTFLT1 NORMAL 0\nMULTFLT2 RAW\nMULTFLT3 NORMAL 0");
    util_fprintf_string(data, 30, true, stream);
    util_fclose(stream);

    FILE * tmpl_stream = util_fopen(tmpl_filename, "w");
    const char * tmpl_data = util_alloc_sprintf("<MULTFLT1> <MULTFLT2> <MULTFLT3>\n");
    util_fprintf_string(tmpl_data, 30, true, tmpl_stream);
    util_fclose(tmpl_stream);
  }

  gen_kw_config_type * gen_kw_config = gen_kw_config_alloc_empty("MULTFLT", "<%s>");
  vector_type * arg = vector_alloc_new();
  vector_append_ref( arg , gen_kw_config );
  vector_append_ref(arg, parameter_filename);

  test_assert_util_abort("arg_pack_fscanf", read_erroneous_gen_kw_file,  arg);

  vector_free(arg);
  gen_kw_config_free(gen_kw_config);
}
Example #2
0
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 );
}
Example #3
0
void test_run_workflow(const char * config_file , const char * job_file) {
  ert_test_context_type * test_context = ert_test_context_alloc("INSTALL_WORKFLOW" , config_file , NULL );
  test_assert_false( ert_test_context_run_worklow( test_context , "No-does.not.exist"));
  
  ert_test_context_install_workflow_job( test_context , "JOB" , job_file );
  {
    FILE * stream1 = util_fopen( "WFLOW1", "w");
    FILE * stream2 = util_fopen( "WFLOW2", "w");
    stringlist_type * args = stringlist_alloc_new( );
    ert_test_context_fwrite_workflow_job( stream1 , "JOB" , args);
    stringlist_append_ref( args , "NewCase");
    ert_test_context_fwrite_workflow_job( stream2 , "JOB" , args);
        
    stringlist_free( args );
    fclose( stream1 );
    fclose( stream2 );
  }
  test_assert_true( ert_test_context_install_workflow( test_context , "WFLOW1" , "WFLOW1"));
  test_assert_true( ert_test_context_install_workflow( test_context , "WFLOW2" , "WFLOW2"));
  
  test_assert_true( ert_test_context_run_worklow( test_context , "WFLOW2"));
  test_assert_false( ert_test_context_run_worklow( test_context , "WFLOW1"));

  ert_test_context_free( test_context );
}
Example #4
0
static int mmap_simple (const char *path)
{
	char fname[MAXSIZ_PATH];
	sprintf (fname,"%s/file",path);
	FILE *f = util_fopen(fname,"w",Rmmap_simple);
	if (f != NULL){
		short int buf[10000];
		int i;
		for (i=0; (unsigned int) i<sizeof(buf)/sizeof(buf[0]); i++)buf[i] = i;
		if (fwrite (buf,1,sizeof(buf),f)!=sizeof(buf)){
			Rmmap_simple.prterr ("Can't write %d bytes\n",sizeof(buf));
		}else{
			fclose (f);
			Rmmap_simple.verbose ("%d bytes were written to %s\n"
				,sizeof(buf),fname);
			f = util_fopen(fname,"r",Rmmap_simple);
			int mmap_size = sizeof(buf) * 2;
			short int *ptm = (short int*)mmap(0,mmap_size
				,PROT_READ,MAP_SHARED,fileno(f),0);
			if (ptm == (short int*)-1){
				Rmmap_simple.prterr ("Can't mmap: errno = %d %s\n"
					,errno,strerror(errno));
			}else{
				/*
					This test try to prove that mmaping beyong
					eof yields all 0s.
					It does not work, so I changed
					the target of the loop so it test
					only below eof.
				*/
				Rmmap_simple.verbose ("mmap returned %p\n",ptm);
				int nbelm_buf = sizeof(buf)/sizeof(buf[0]);
				//for (i=0; i<mmap_size/sizeof(buf[0]); i++){
				for (i=0; i<nbelm_buf; i++){
					Rmmap_simple.verbose ("%d ",i); fflush(stdout);
					if (i > nbelm_buf){
						if (ptm[i] != 0){
							Rmmap_simple.prterr("Error reading beyond eof at offset %d\n"
								,i*sizeof(buf[0]));
							break;
						}
					}else if (ptm[i] != i){
						Rmmap_simple.prterr("Error reading at offset %d\n"
							,i*sizeof(buf[0]));
						break;
					}
				}
				if (munmap((char*)ptm,sizeof(buf))==-1){
					Rmmap_simple.prterr ("Can't munmap\n");
				}
			}
		}
		fclose (f);
		util_unlink(fname,Rmmap_simple,0);
	}
	return Rmmap_simple.getnberr();
}
Example #5
0
/* Save play list to M3U format */
bool_t plist_save_m3u( plist_t *pl, char *filename )
{
	FILE *fd;
	int i;

	/* Try to create file */
	fd = util_fopen(filename, "wt");
	if (fd == NULL)
		return FALSE;
	
	/* Write list head */
	fprintf(fd, "#EXTM3U\n");
	for ( i = 0; i < pl->m_len; i ++ )
	{
		song_t *s = pl->m_list[i];
		fprintf(fd, "#EXTINF:%i", TIME_TO_SECONDS(s->m_len));
		if (s->m_start_time >= 0)
			fprintf(fd, "-%i", TIME_TO_SECONDS(s->m_start_time));

		fprintf(fd, ",%s\n%s\n", STR_TO_CPTR(s->m_title), song_get_name(s));
	}

	/* Close file */
	fclose(fd);
	return TRUE;
} /* End of 'plist_save_m3u' function */
Example #6
0
rng_type * rng_config_init_rng__(const rng_config_type * rng_config, rng_type * rng) {
    const char * seed_load  = rng_config_get_seed_load_file( rng_config );
    const char * seed_store = rng_config_get_seed_store_file( rng_config );

    if (seed_load != NULL) {
        if (util_file_exists( seed_load)) {
            FILE * stream = util_fopen( seed_load , "r");
            rng_fscanf_state( rng , stream );
            fclose( stream );
        } else {
            /*
               In the special case that seed_load == seed_store; we accept a
               seed_load argument pointing to a non-existant file.
            */
            if (seed_store) {
                if (util_string_equal( seed_store , seed_load))
                    rng_init( rng , INIT_DEV_URANDOM );
                else
                    util_abort("%s: tried to load random seed from non-existing file:%s \n",__func__ , seed_load);
            }
        }
    } else
        rng_init( rng , INIT_DEV_URANDOM );


    if (seed_store != NULL) {
        FILE * stream = util_mkdir_fopen( seed_store , "w");
        rng_fprintf_state( rng , stream );
        fclose( stream );
    }

    return rng;
}
Example #7
0
void create_submit_script_script_according_to_input() {
  char ** args = util_calloc(2, sizeof * args);
  args[0] = "/tmp/jaja/";
  args[1] = "number2arg";
  char * script_filename = util_alloc_filename("/tmp/", "qsub_script", "sh");
  torque_job_create_submit_script(script_filename, "job_program.py", 2, (const char **) args);
  printf("Create submit script OK\n");

  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);
}
vector_type * load_expected( const ecl_grid_type * grid, const char * filename ) {
  FILE * stream = util_fopen( filename , "r");
  vector_type * expected = vector_alloc_new();

  while (true) {
    double x,y,z;
    int i,j,k,skip;

    if (fscanf( stream , "%lg %lg %lg %d %d %d %d" , &x,&y,&z,&i,&j,&k,&skip) == 7) {
      point_type * p = util_malloc( sizeof * p );
      p->x = x;
      p->y = y;
      p->z = z;

      p->i = i-1;
      p->j = j-1;
      p->k = k-1;
      p->skip = skip;
      p->g = ecl_grid_get_global_index3(grid,    p->i, p->j, p->k);
      vector_append_owned_ref( expected, p , free );
    } else
      break;
  }

  fclose( stream );
  test_assert_int_equal( 10 , vector_get_size( expected ));
  return expected;
}
Example #9
0
static void gen_data_ecl_write_ASCII(const gen_data_type * gen_data , const char * file , gen_data_file_format_type export_format) {
  FILE * stream   = util_fopen(file , "w");
  char * template_buffer;
  int    template_data_offset, template_buffer_size , template_data_skip;

  if (export_format == ASCII_TEMPLATE) {
    gen_data_config_get_template_data( gen_data->config , &template_buffer , &template_data_offset , &template_buffer_size , &template_data_skip);
    util_fwrite( template_buffer , 1 , template_data_offset , stream , __func__);
  }

  {
    ecl_data_type internal_type = gen_data_config_get_internal_data_type(gen_data->config);
    const int size              = gen_data_config_get_data_size( gen_data->config , gen_data->current_report_step );
    int i;
    if (ecl_type_is_float(internal_type)) {
      float * float_data = (float *) gen_data->data;
      for (i=0; i < size; i++)
        fprintf(stream , "%g\n",float_data[i]);
    } else if (ecl_type_is_double(internal_type)) {
      double * double_data = (double *) gen_data->data;
      for (i=0; i < size; i++)
        fprintf(stream , "%lg\n",double_data[i]);
    } else
      util_abort("%s: internal error - wrong type \n",__func__);
  }

  if (export_format == ASCII_TEMPLATE) {
    int new_offset = template_data_offset + template_data_skip;
    util_fwrite( &template_buffer[new_offset] , 1 , template_buffer_size - new_offset , stream , __func__);
  }
  fclose(stream);
}
Example #10
0
/*
	Initialise a file with a complex but computed pattern.
	It returns -1 if error, or the size written (which may be different
	from the size of the file in text mode).
*/
static int read_initfile (
	const char *fname,		// File to initialise
	UMSDOS_REGISTER &reg,
	int line_length)
{
	int ret = -1;
	FILE *fout = util_fopen (fname,"w",reg);
	if (fout != NULL){
		ret = 0;
		for (int i=0; i<500; i++){
			char buf[50];
			for (int j=0; j<50; j++,ret++){
				buf[j] = read_getvalue(ret,line_length);
			}
			if (fwrite (buf,1,sizeof(buf),fout) != sizeof(buf)){
				reg.prterr ("fwrite failed, errno %d '%s'\n"
					,errno,strerror(errno));
				ret = -1;
				break;
			}			
		}
		fclose (fout);
	}
	return ret;
}
Example #11
0
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 );
}
Example #12
0
geo_polygon_type * geo_polygon_fload_alloc_irap( const char * filename ) {
  geo_polygon_type * polygon = geo_polygon_alloc();
  {
    FILE * stream = util_fopen( filename , "r");
    double x , y , z;
    while (true) {
      if (fscanf(stream , "%lg %lg %lg" , &x, &y , &z) == 3) 
        geo_polygon_add_point( polygon , x , y );
      else
        break;
    } 
    fclose( stream );
    /*
      The irap format is a polygon which closes on itself by
      construction; i.e. the last point from file is not added to the
      polygon data structure. In addition the final '999' termination
      is not included.
    */
    double_vector_pop( polygon->xcoord );
    double_vector_pop( polygon->xcoord );
    double_vector_pop( polygon->ycoord );
    double_vector_pop( polygon->ycoord );
  }
  return polygon;
}
Example #13
0
FILE * text_fopen(const plot_driver_type * driver , const char * label) {
  text_state_type * state = driver->state;
  char * filename = text_alloc_filename( state->plot_path , label );
  FILE * stream   = util_fopen( filename , "w");
  free( filename );
  return stream;
}
Example #14
0
void model_config_set_case_table( model_config_type * model_config , int ens_size , const char * case_table_file ) {
  if (model_config->case_table_file != NULL) { /* Clear the current selection */
    free( model_config->case_table_file );
    stringlist_free( model_config->case_names );
    
    model_config->case_table_file = NULL;
    model_config->case_names      = NULL;
  }

  if (case_table_file != NULL) {
    bool atEOF = false;
    char casename[128];
    int  case_size = 0;
    FILE * stream = util_fopen( case_table_file , "r");
    model_config->case_names = stringlist_alloc_new();
    while (!atEOF) {
      if (fscanf( stream , "%s" , casename) == 1) {
        stringlist_append_copy( model_config->case_names , casename );
        case_size++;
      } else
        atEOF = true;
    }
    fclose( stream );

    if (case_size < ens_size) {
      for (int i = case_size; i < ens_size; i++)
        stringlist_append_owned_ref( model_config->case_names , util_alloc_sprintf("case_%04d" , i));
      fprintf(stderr, "** Warning: mismatch between NUM_REALIZATIONS:%d and size of CASE_TABLE:%d - using \'case_nnnn\' for the last cases %d.\n", ens_size , case_size , ens_size - case_size);
    } else if (case_size > ens_size) 
      fprintf(stderr, "** Warning: mismatch between NUM_REALIZATIONS:%d and CASE_TABLE:%d - only the %d realizations will be used.\n", ens_size , case_size , ens_size);

  }
}
Example #15
0
bool summary_key_set_fread(summary_key_set_type * set, const char * filename) {
    bool file_exists = false;
    pthread_rwlock_wrlock( &set->rw_lock );
    {
        hash_clear(set->key_set);

        if (util_file_exists(filename)) {
            FILE * stream = util_fopen(filename, "r");
            if (stream) {
                stringlist_type * key_set = stringlist_fread_alloc(stream);

                for (int i = 0; i < stringlist_get_size(key_set); i++) {
                    hash_insert_int(set->key_set, stringlist_iget(key_set, i), 1);
                }
                stringlist_free(key_set);
                fclose( stream );
            } else {
                util_abort("%s: failed to open: %s for reading \n",__func__ , filename );
            }
            file_exists = true;
        }
    }
    pthread_rwlock_unlock( &set->rw_lock );
    return file_exists;
}
Example #16
0
static geo_polygon_type * geo_polygon_fload_alloc_xyz( const char * filename , bool irap_format) {
  bool stop_on_999 = irap_format;
  bool skip_last_point = irap_format;

  geo_polygon_type * polygon = geo_polygon_alloc( filename );
  {
    FILE * stream = util_fopen( filename , "r");
    double x , y , z;
    while (true) {
      if (fscanf(stream , "%lg %lg %lg" , &x, &y , &z) == 3) {
        if (stop_on_999 && (x == 999) && (y == 999) && (z == 999))
          break;

        geo_polygon_add_point( polygon , x , y );
      } else
        break;
    }

    fclose( stream );

    if ((double_vector_size( polygon->xcoord ) > 1) && (skip_last_point)) {
      if ((double_vector_get_last(polygon->xcoord) == double_vector_get_first(polygon->xcoord)) &&
          (double_vector_get_last(polygon->ycoord) == double_vector_get_first(polygon->ycoord))) {

        double_vector_pop( polygon->xcoord );
        double_vector_pop( polygon->ycoord );
      }
    }
  }
  return polygon;
}
Example #17
0
sched_file_type * sched_file_alloc(time_t start_time)
{
  sched_file_type * sched_file = util_malloc(sizeof * sched_file);
  UTIL_TYPE_ID_INIT( sched_file , SCHED_FILE_TYPE_ID);
  sched_file->kw_list            = vector_alloc_new();
  sched_file->kw_list_by_type    = NULL;
  sched_file->blocks             = vector_alloc_new();
  sched_file->files              = stringlist_alloc_new();
  sched_file->start_time         = start_time;
  sched_file->fixed_length_table = hash_alloc();
  sched_file->hasEND             = false;
  sched_file_init_fixed_length( sched_file );
  {
    char * fixed_length_file = getenv("SCHEDULE_FIXED_LENGTH");
    if ((fixed_length_file != NULL) && (util_entry_readable( fixed_length_file ))) {
      FILE * stream = util_fopen(fixed_length_file , "r");
      char kw[32];
      int  len;
      bool OK = true;

      do {
        if (fscanf(stream , "%s %d" , kw , &len) == 2)
          sched_file_add_fixed_length_kw( sched_file , kw , len);
        else
          OK = false;
      } while (OK);
      fclose( stream);
    }
  }
  return sched_file;
}
Example #18
0
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 );
}
Example #19
0
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 );
}
Example #20
0
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);
}
Example #21
0
void test_empty_file() {
  const char * stdout_file = "bsub_empty";
  {
    FILE * stream = util_fopen(stdout_file , "w");
    fclose( stream );
  }
  test_assert_int_equal( lsf_job_parse_bsub_stdout("bsub" , stdout_file ) , 0);
}
Example #22
0
void test_kw_io_charlength() {
  test_work_area_type * work_area = test_work_area_alloc("ecl_kw_io_charlength");
  { 
    const char * KW0 = "QWERTYUI";
    const char * KW1 = "ABCDEFGHIJTTTTTTTTTTTTTTTTTTTTTTABCDEFGHIJKLMNOP";
    ecl_kw_type * ecl_kw_out0 = ecl_kw_alloc(KW0 , 5, ECL_FLOAT);
    ecl_kw_type * ecl_kw_out1 = ecl_kw_alloc(KW1 , 5, ECL_FLOAT);
    for (int i=0; i < ecl_kw_get_size( ecl_kw_out1); i++) {
       ecl_kw_iset_float( ecl_kw_out0 , i , i*1.5 );
       ecl_kw_iset_float( ecl_kw_out1 , i , i*1.5 );
    }

    {
       fortio_type * f = fortio_open_writer( "TEST1" , false, ECL_ENDIAN_FLIP );
       test_assert_true( ecl_kw_fwrite( ecl_kw_out0, f ));
       test_assert_false(ecl_kw_fwrite( ecl_kw_out1, f ));
       fortio_fclose( f );
    }

    {
       test_assert_false( util_file_exists( "TEST1"));
    }
   
    {
       FILE * file = util_fopen("TEST2", "w");
       ecl_kw_fprintf_grdecl(ecl_kw_out1 , file);
       fclose(file);
    }
    
    {
       FILE * file = util_fopen("TEST2", "r");
       ecl_kw_type * ecl_kw_in = ecl_kw_fscanf_alloc_grdecl( file , KW1 , -1 , ECL_FLOAT);
       test_assert_string_equal(KW1, ecl_kw_get_header(ecl_kw_in) );
       test_assert_int_equal(5, ecl_kw_get_size( ecl_kw_in) );

       test_assert_double_equal(ecl_kw_iget_as_double(ecl_kw_in, 0), 0.0);
       test_assert_double_equal(ecl_kw_iget_as_double(ecl_kw_in, 4), 6.0);

       fclose(file);
    }
    
    ecl_kw_free( ecl_kw_out0 );
    ecl_kw_free( ecl_kw_out1 );
  }
  test_work_area_free( work_area );
}
Example #23
0
int test_grdecl_loader() {
  FILE * stream = util_fopen("/private/joaho/ERT/NR/python/ctypes/test/data/eclipse/case/PERMX.grdecl" , "r");
  ecl_kw_type * kw = ecl_kw_fscanf_alloc_grdecl_dynamic( stream , "PERMX" , ECL_FLOAT_TYPE );
  ecl_kw_free( kw );
  fclose( stream );
  
  return 1;
}
Example #24
0
void cases_config_fread( cases_config_type * config , const char * filename) {
  if (util_file_exists( filename )) {
    FILE * stream = util_fopen( filename , "r");
    int iteration_number = util_fread_int( stream );
    cases_config_set_iteration_number(config,iteration_number);
    fclose( stream );
  }
}
Example #25
0
void create_error_workflow( const char * workflow_file , const char * tmp_file , int value) {
  FILE * stream  = util_fopen( workflow_file , "w");
  fprintf(stream , "CREATE_FILE   %s   %d\n" , tmp_file , value);
  fprintf(stream , "XREAD_FILE     %s\n" , tmp_file );
  fclose( stream );
  
  printf("Have created:%s \n",workflow_file );
}
bool check_original_exported_data_equal(const enkf_node_type * field_node) {
  FILE * original_stream = util_fopen( "petro.grdecl" , "r");
  ecl_kw_type * kw_original = ecl_kw_fscanf_alloc_grdecl_dynamic( original_stream , "PORO" , ECL_DOUBLE_TYPE );

  enkf_node_ecl_write(field_node, "tmp", NULL, 0); 
  FILE * exported_stream = util_fopen( "tmp/PORO.grdecl" , "r");
  ecl_kw_type * kw_exported = ecl_kw_fscanf_alloc_grdecl_dynamic( exported_stream , "PORO" , ECL_DOUBLE_TYPE );

  bool ret = ecl_kw_numeric_equal(kw_original, kw_exported, 1e-5);

  util_fclose(original_stream); 
  util_fclose(exported_stream); 
  ecl_kw_free(kw_original); 
  ecl_kw_free(kw_exported); 
  
  return ret; 
}
Example #27
0
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;
}
Example #28
0
File: enkf_fs.c Project: shulNN/ert
static int enkf_fs_get_fs_version__(const char * config_file) {
  int version = -1;
  if (util_file_exists(config_file)) {
    FILE * stream = util_fopen(config_file , "r");
    version = enkf_fs_fread_fs_version__(stream);
    fclose(stream);
  } 
  return version;
}
Example #29
0
static bool util_addr2line_lookup__(const void * bt_addr , char ** func_name , char ** file_name , int * line_nr, bool subtract_base_adress) {
  *func_name = NULL;    // If dladdr() succeeds, but addr2line fails the func_name pointer will be set, but the function will return false anyway.
  *file_name = NULL;
  *line_nr   = 0;
  {
    bool  address_found = false;
    Dl_info dl_info;
#if defined(__APPLE__)
    return false;
#else
    if (dladdr(bt_addr , &dl_info)) {
      const char * executable = dl_info.dli_fname;
      *func_name = util_alloc_string_copy( dl_info.dli_sname );
      if (util_file_exists( executable )) {
        char *stdout_file = util_alloc_tmp_file("/tmp" , "addr2line" , true);
        /* 1: Run addr2line application */
        {
          char ** argv = util_calloc(3 , sizeof * argv );
          argv[0] = util_alloc_string_copy("--functions");
          argv[1] = util_alloc_sprintf("--exe=%s" , executable );
          {
            char * rel_address = (char *) bt_addr;
            if (subtract_base_adress)
              rel_address -= (size_t) dl_info.dli_fbase;
            argv[2] = util_alloc_sprintf("%p" , (void *) rel_address);
          }
          util_spawn_blocking("addr2line", 3, (const char **) argv, stdout_file, NULL);
          util_free_stringlist(argv , 3);
        }

        /* 2: Parse stdout output */
        {
          bool at_eof;
          FILE * stream = util_fopen(stdout_file , "r");
          char * tmp_fname = util_fscanf_alloc_line(stream , &at_eof);

          if (strcmp(tmp_fname , UNDEFINED_FUNCTION) != 0) {
            char * stdout_file_name = util_fscanf_alloc_line(stream , &at_eof);
            char * line_string = NULL;
            util_binary_split_string( stdout_file_name , ":" , false , file_name , &line_string);
            if (line_string && util_sscanf_int( line_string , line_nr))
              address_found = true;

            free( stdout_file_name );
            util_safe_free( line_string );
          }
          free( tmp_fname );
          fclose(stream);
        }
        util_unlink_existing(stdout_file);
        free( stdout_file );
      }
    }
    return address_found;
#endif
  }
}
Example #30
0
void buffer_fread_realloc(buffer_type * buffer , const char * filename) {
  size_t file_size     = util_file_size( filename );
  FILE * stream        = util_fopen( filename , "r");  
  
  buffer_clear( buffer );    /* Setting: content_size = 0; pos = 0;  */
  buffer_stream_fread( buffer , file_size , stream );
  buffer_rewind( buffer );   /* Setting: pos = 0; */
  fclose( stream );
}