star-meteo

test_stardis_smeteo.c (5616B)

---

 /* Copyright (C) 2025 |Méso|Star> (contact@meso-star.com)
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is dismshbuted in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>. */
 
 #define _POSIX_C_SOURCE 200809L /* strdup */
 
 #include "smeteo.h"
 #include "stardis_smeteo.h"
 
 #include <rsys/mem_allocator.h>
 
 /* FIXME required by the UINT_MAX constant used in the stardis-prog-properties
  * header. It should by stardis, not by the caller. */
 #include <limits.h>
 
 #include <string.h> /* strdup */
 
 /*******************************************************************************
  * Helper functions
  ******************************************************************************/
 static void*
 check_lib_api(const char* filename)
 {
   struct stardis_program_context ctx = {0};
   char* argv[2] = {NULL};
   void* lib = NULL;
 
   /* Input strings cannot be constants, so they must be duplicated */
   CHK(argv[0] = strdup("stardis-plugin")); /* dummy string */
   CHK(argv[1] = strdup(filename));
 
   ctx.name = argv[0];
   ctx.verbosity_level = 3;
 
   /* Invalid function calls */
   CHK(stardis_create_library_data(NULL, 2, argv) == NULL);
   CHK(stardis_create_library_data(&ctx, 1, argv) == NULL);
   CHK(stardis_create_library_data(&ctx, 2, NULL) == NULL);
 
   /* Valid function call */
   CHK((lib = stardis_create_library_data(&ctx, 2, argv)) != NULL);
 
   /* Verify that, on a valid lib, the legal functions return a valid result */
   CHK(get_copyright_notice(lib) != NULL);
   CHK(get_license_short(lib) != NULL);
   CHK(get_license_text(lib) != NULL);
 
   CHK(stardis_finalize_library_data(lib) == STARDIS_SUCCESS);
 
   /* Check for error if file is invalid */
   free(argv[1]);
   CHK(argv[1] = strdup("invalid_filename.txt"));
   CHK(stardis_create_library_data(&ctx, 2, argv) == NULL);
 
   /* Clean-up allocated memory */
   free(argv[0]);
   free(argv[1]);
 
   return lib; /* Return the created library */
 }
 
 static void*
 check_data_api(void* lib)
 {
   struct stardis_description_create_context ctx = {0};
   char* argv[2] = {"smeteo", "-hls"};
   size_t argc = sizeof(argv)/sizeof(char*);
   void* data = NULL;
 
   /* The input string cannot be constant, so it must be duplicated */
   CHK(argv[0] = strdup("boundary-condition")); /* dummy string */
   ctx.name = argv[0];
 
   /* Invalid function calls */
   CHK(stardis_create_data(NULL, lib, argc, argv) == NULL);
   CHK(stardis_create_data(&ctx, NULL, argc, argv) == NULL);
   CHK(stardis_create_data(&ctx, lib, 0, argv) == NULL);
   CHK(stardis_create_data(&ctx, lib, argc, NULL) == NULL);
 
   /* Valid function call */
   CHK((data = stardis_create_data(&ctx, lib, argc, argv)) != NULL);
 
   free(argv[0]);
 
   return data;
 }
 
 static double /* in [0-1[ */
 rand_canonical(void)
 {
   return rand() / (double)(RAND_MAX-1);
 }
 
 static void
 check_getters(void* data, const struct smeteo* smeteo)
 {
   struct smeteo_desc desc = SMETEO_DESC_NULL;
   double interval_duration = 0; /* [s] */
 
   size_t i = 0;
   size_t nqueries = 1000;
 
   struct stardis_vertex vtx = {0};
   struct stardis_interface_fragment frag = {0};
 
   CHK(smeteo_get_desc(smeteo, &desc) == RES_OK);
 
   /* Multiplier to convert a time in day_1850 to seconds */
   #define M_DAY1850_TO_H (24/*[h]*/ * 3600/*[s]*/)
 
   /* The dates of the intervals are relative to midnight on January 1, 1850.  In
    * addition, their time is defined at the center of the interval. Thus, for
    * the first interval, calculate its duration by multiplying its date relative
    * to January 1, 1850 by 2 */
   interval_duration = desc.entries[0].day_1850 * 2 * M_DAY1850_TO_H;
 
   FOR_EACH(i, 0, nqueries) {
     /* Randomly select a time interval */
     const size_t ientry = (size_t)(rand_canonical() * (double)desc.nentries);
     const struct smeteo_entry* entry = desc.entries + ientry;
 
     /* Randomly sample a time [s] in the selected interval */
     const double start = entry->day_1850*M_DAY1850_TO_H - interval_duration*0.5;
     const double time = start + rand_canonical() * interval_duration;
 
     vtx.time = frag.time = time;
 
     /* query data */
     CHK(stardis_convection_coefficient(&frag, data) == entry->H);
     CHK(stardis_reference_temperature(&frag, data) == entry->Tsrf);
     CHK(stardis_boundary_temperature(&frag, data) == entry->Tsrf);
     CHK(stardis_medium_temperature(&vtx, data) == entry->Tatm);
     CHK(stardis_emissivity(&frag, STARDIS_INTERN_SOURCE_ID, data) == 1.0);
   }
 
   #undef M_DAY1850_TO_H
 }
 
 /*******************************************************************************
  * The test
  ******************************************************************************/
 int
 main(void)
 {
   const char* filename = "samples/star-meteo_input.txt";
 
   struct smeteo* smeteo = NULL;
   void* lib = NULL;
   void* data = NULL;
 
   CHK(smeteo_create(&SMETEO_CREATE_ARGS_DEFAULT, &smeteo) == RES_OK);
   CHK(smeteo_load(smeteo, filename) == RES_OK);
 
   lib = check_lib_api(filename);
   data = check_data_api(lib);
 
   check_getters(data, smeteo);
 
   stardis_release_library_data(lib);
   stardis_release_data(data);
 
   CHK(smeteo_ref_put(smeteo) == RES_OK);
 
   CHK(mem_allocated_size() == 0);
 
   return 0;
 }