Fix deprecations introduced by RSys 0.6 - solstice - Compute collected power and efficiencies of a solar plant

commit fd1d5edf3769a68d05ae84a258822ed0d352cbc3
parent c7d8821dc379c443d29216558ea8dc206af3f2fb
Author: Vincent Forest <vincent.forest@meso-star.com>
Date:   Mon, 11 Dec 2017 12:17:30 +0100

Fix deprecations introduced by RSys 0.6

Diffstat:
M cmake/CMakeLists.txt  | 2 +-
M src/parser/test_solparser.c  | 18 +++++++++---------
M src/parser/test_solparser2.c  | 160 ++++++++++++++++++++++++++++++++++++++++----------------------------------------
M src/parser/test_solparser3.c  | 192 ++++++++++++++++++++++++++++++++++++++++----------------------------------------
M src/parser/test_solparser4.c  | 110 ++++++++++++++++++++++++++++++++++++++++----------------------------------------
M src/parser/test_solparser5.c  | 44 ++++++++++++++++++++++----------------------
M src/parser/test_solparser6.c  | 102 ++++++++++++++++++++++++++++++++++++++++----------------------------------------
M src/parser/test_solparser7.c  | 78 +++++++++++++++++++++++++++++++++++++++---------------------------------------
M src/parser/test_solparser8.c  | 76 ++++++++++++++++++++++++++++++++++++++--------------------------------------
M src/parser/test_solparser_normal_map.c  | 154 ++++++++++++++++++++++++++++++++++++++++----------------------------------------
M src/parser/test_solparser_spectrum.c  | 214 ++++++++++++++++++++++++++++++++++++++++----------------------------------------
M src/receivers/test_srcvl.c  | 18 +++++++++---------
M src/receivers/test_srcvl2.c  | 70 +++++++++++++++++++++++++++++++++++-----------------------------------
M src/solstice.c  | 4 ++--
M src/solstice_solve.c  | 2 +-
M src/test_solstice_args.c  | 414 ++++++++++++++++++++++++++++++++++++++++----------------------------------------
M src/test_solstice_simulation.c  | 127 ++++++++++++++++++++++++++++++++++++++-----------------------------------------

17 files changed, 890 insertions(+), 895 deletions(-)
diff --git a/cmake/CMakeLists.txt b/cmake/CMakeLists.txt
@@ -43,7 +43,7 @@ set(LibYAML_DIR ${_current_source_dir}/)
 
 find_package(LibYAML REQUIRED)
 find_package(RCMake 0.2.3 REQUIRED)
-find_package(RSys 0.4 REQUIRED)
+find_package(RSys 0.6 REQUIRED)
 find_package(SolAnim 0.2 REQUIRED)
 find_package(SolSolver 0.6.1 REQUIRED)
 find_package(Star3DUT 0.2 REQUIRED)
diff --git a/src/parser/test_solparser.c b/src/parser/test_solparser.c
@@ -44,26 +44,26 @@ main(int argc, char** argv)
     }
   }
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
   solparser_create(&allocator, &parser);
 
-  CHECK(solparser_setup(parser, NULL, tmpfile()), RES_OK);
-  CHECK(solparser_setup(parser, "yop", tmpfile()), RES_OK);
-  CHECK(solparser_load(parser), RES_BAD_OP); /* Empty stream */
+  CHK(solparser_setup(parser, NULL, tmpfile()) == RES_OK);
+  CHK(solparser_setup(parser, "yop", tmpfile()) == RES_OK);
+  CHK(solparser_load(parser) == RES_BAD_OP); /* Empty stream */
 
   FOR_EACH(i, ifile, argc) {
     FILE* file = fopen(argv[i], "rb");
     int count = 0;
-    NCHECK(file, NULL);
-    CHECK(solparser_setup(parser, argv[i], file), RES_OK);
+    CHK(file != NULL);
+    CHK(solparser_setup(parser, argv[i], file) == RES_OK);
     for(;;) {
       const res_T res = solparser_load(parser);
       if(count == 0 && load_res == RES_OK) {
-        CHECK(res, RES_OK);
+        CHK(res == RES_OK);
       } else if(res == RES_BAD_OP) {
         break;
       }
-      CHECK(res, load_res);
+      CHK(res == load_res);
       ++count;
     }
     fclose(file);
@@ -75,6 +75,6 @@ main(int argc, char** argv)
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
diff --git a/src/parser/test_solparser2.c b/src/parser/test_solparser2.c
@@ -48,11 +48,11 @@ main(int argc, char** argv)
   FILE* stream;
   (void)argc, (void)argv;
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
   solparser_create(&allocator, &parser);
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
 
   fprintf(stream, "- geometry: &sphere\n");
   fprintf(stream, "    - sphere: { radius: 1  }\n");
@@ -64,22 +64,22 @@ main(int argc, char** argv)
   fp = ftell(stream);
   fprintf(stream, "    name: invalid name\n");
   rewind(stream);
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_BAD_ARG);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_BAD_ARG);
 
-  NCHECK(fseek(stream, fp, SEEK_SET), -1);
+  CHK(fseek(stream, fp, SEEK_SET) != -1);
   fprintf(stream, "    name: invalid\tname\n");
   rewind(stream);
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_BAD_ARG);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_BAD_ARG);
 
-  NCHECK(fseek(stream, fp, SEEK_SET), -1);
+  CHK(fseek(stream, fp, SEEK_SET) != -1);
   fprintf(stream, "    name: invalid.name\n");
   rewind(stream);
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_BAD_ARG);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_BAD_ARG);
 
-  NCHECK(fseek(stream, fp, SEEK_SET), -1);
+  CHK(fseek(stream, fp, SEEK_SET) != -1);
   fprintf(stream, "    name: \t\t\t lvl0  \t \n");
   fprintf(stream, "    transform: { translation: [1,2,3], rotation: [4,5,6]}\n");
   fprintf(stream, "    children:\n");
@@ -104,146 +104,146 @@ main(int argc, char** argv)
   fprintf(stream, "    extinction: 0\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_geometry_iterator_begin(parser, &geom_it);
   solparser_geometry_iterator_end(parser, &geom_it_end);
   ngeoms = 0;
   while(!solparser_geometry_iterator_eq(&geom_it, &geom_it_end)) {
-    CHECK(ngeoms < 2, 1);
+    CHK(ngeoms < 2);
     geom_id = solparser_geometry_iterator_get(&geom_it);
     solparser_geometry_iterator_next(&geom_it);
     geoms[ngeoms] = solparser_get_geometry(parser, geom_id);
     ++ngeoms;
   }
-  CHECK(ngeoms, 2);
+  CHK(ngeoms == 2);
 
   solparser_material_iterator_begin(parser, &mtl_it);
   solparser_material_iterator_end(parser, &mtl_it_end);
   nmtls = 0;
   while(!solparser_material_iterator_eq(&mtl_it, &mtl_it_end)) {
     struct solparser_material_id mtl_id;
-    CHECK(nmtls < 2, 1);
+    CHK(nmtls < 2);
     mtl_id = solparser_material_iterator_get(&mtl_it);
     solparser_material_iterator_next(&mtl_it);
     mtls[nmtls] = solparser_get_material(parser, mtl_id);
     ++nmtls;
   }
-  CHECK(nmtls, 2);
+  CHK(nmtls == 2);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &end);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 0);
 
   entity_id = solparser_entity_iterator_get(&it);
   entity = solparser_get_entity(parser, entity_id);
 
-  CHECK(strcmp("lvl0", str_cget(&entity->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity), 2);
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
+  CHK(strcmp("lvl0", str_cget(&entity->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity) == 2);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
   geom_id = entity->data.geometry;
   geom = solparser_get_geometry(parser, entity->data.geometry);
-  CHECK(geom == geoms[0] || geom == geoms[1], 1);
-  CHECK(solparser_geometry_get_objects_count(geom), 1);
+  CHK(geom == geoms[0] || geom == geoms[1]);
+  CHK(solparser_geometry_get_objects_count(geom) == 1);
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
-  CHECK(d3_eq(obj->rotation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(obj->translation, d3_splat(tmp, 0)), 1);
+  CHK(d3_eq(obj->rotation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(obj->translation, d3_splat(tmp, 0)) == 1);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_SPHERE);
+  CHK(shape->type == SOLPARSER_SHAPE_SPHERE);
   sphere = solparser_get_shape_sphere(parser, shape->data.sphere);
-  CHECK(sphere->radius, 1);
+  CHK(sphere->radius == 1);
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  CHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i == mtl2->back.i);
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl == mtls[0] || mtl == mtls[1], 1);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_MATTE);
+  CHK(mtl == mtls[0] || mtl == mtls[1]);
+  CHK(mtl->type == SOLPARSER_MATERIAL_MATTE);
   matte = solparser_get_material_matte(parser, mtl->data.matte);
-  CHECK(matte->reflectivity.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(matte->reflectivity.value.real, 1);
+  CHK(matte->reflectivity.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(matte->reflectivity.value.real == 1);
 
   entity_id = solparser_entity_get_child(entity, 0);
   entity1a = solparser_get_entity(parser, entity_id);
-  CHECK(d3_eq(entity1a->translation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(entity1a->rotation, d3_splat(tmp, 0)), 1);
-  CHECK(strcmp("lvl1a", str_cget(&entity1a->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity1a), 0);
-  CHECK(entity1a->type, SOLPARSER_ENTITY_GEOMETRY);
-  CHECK(entity1a->primary, 1);
-  NCHECK(entity1a->data.geometry.i, geom_id.i);
+  CHK(d3_eq(entity1a->translation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(entity1a->rotation, d3_splat(tmp, 0)) == 1);
+  CHK(strcmp("lvl1a", str_cget(&entity1a->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity1a) == 0);
+  CHK(entity1a->type == SOLPARSER_ENTITY_GEOMETRY);
+  CHK(entity1a->primary == 1);
+  CHK(entity1a->data.geometry.i != geom_id.i);
   geom = solparser_get_geometry(parser, entity1a->data.geometry);
-  CHECK(geom == geoms[0] || geom == geoms[1], 1);
-  CHECK(solparser_geometry_get_objects_count(geom), 1);
+  CHK(geom == geoms[0] || geom == geoms[1]);
+  CHK(solparser_geometry_get_objects_count(geom) == 1);
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
-  CHECK(d3_eq(obj->rotation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(obj->translation, d3_splat(tmp, 0)), 1);
+  CHK(d3_eq(obj->rotation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(obj->translation, d3_splat(tmp, 0)) == 1);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_SPHERE);
+  CHK(shape->type == SOLPARSER_SHAPE_SPHERE);
   sphere = solparser_get_shape_sphere(parser, shape->data.sphere);
-  CHECK(sphere->radius, 2);
+  CHK(sphere->radius == 2);
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  CHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i == mtl2->back.i);
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl == mtls[0] || mtl == mtls[1], 1);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_MIRROR);
+  CHK(mtl == mtls[0] || mtl == mtls[1]);
+  CHK(mtl->type == SOLPARSER_MATERIAL_MIRROR);
   mirror = solparser_get_material_mirror(parser, mtl->data.mirror);
-  CHECK(mirror->reflectivity.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(mirror->reflectivity.value.real, 0.9);
-  CHECK(mirror->roughness.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(mirror->roughness.value.real, 0.1);
+  CHK(mirror->reflectivity.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(mirror->reflectivity.value.real == 0.9);
+  CHK(mirror->roughness.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(mirror->roughness.value.real == 0.1);
 
   entity_id = solparser_entity_get_child(entity, 1);
   entity1b = solparser_get_entity(parser, entity_id);
-  CHECK(d3_eq(entity1b->translation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq_eps(entity1b->rotation, d3(tmp, 3.14, 0, -1), 1.e-6), 1);
-  CHECK(strcmp("lvl1b", str_cget(&entity1b->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity1b), 1);
-  CHECK(entity1b->type, SOLPARSER_ENTITY_GEOMETRY);
-  CHECK(entity1b->primary, 0);
-  CHECK(entity1b->data.geometry.i, geom_id.i);
+  CHK(d3_eq(entity1b->translation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq_eps(entity1b->rotation, d3(tmp, 3.14, 0, -1), 1.e-6) == 1);
+  CHK(strcmp("lvl1b", str_cget(&entity1b->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity1b) == 1);
+  CHK(entity1b->type == SOLPARSER_ENTITY_GEOMETRY);
+  CHK(entity1b->primary == 0);
+  CHK(entity1b->data.geometry.i == geom_id.i);
 
   entity_id = solparser_entity_get_child(entity1b, 0);
   entity2 = solparser_get_entity(parser, entity_id);
-  CHECK(d3_eq(entity2->translation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(entity2->rotation, d3_splat(tmp, 0)), 1);
-  CHECK(strcmp("lvl2", str_cget(&entity2->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity2), 0);
-  CHECK(entity2->type, SOLPARSER_ENTITY_GEOMETRY);
-  CHECK(entity2->data.geometry.i, geom_id.i);
+  CHK(d3_eq(entity2->translation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(entity2->rotation, d3_splat(tmp, 0)) == 1);
+  CHK(strcmp("lvl2", str_cget(&entity2->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity2) == 0);
+  CHK(entity2->type == SOLPARSER_ENTITY_GEOMETRY);
+  CHK(entity2->data.geometry.i == geom_id.i);
 
   entity3 = solparser_find_entity(parser, "lvl0");
-  CHECK(entity3, entity);
+  CHK(entity3 == entity);
   entity3 = solparser_find_entity(parser, "lvl1a");
-  CHECK(entity3, NULL);
+  CHK(entity3 == NULL);
   entity3 = solparser_find_entity(parser, "lvl0.lvl1a");
-  CHECK(entity3, entity1a);
+  CHK(entity3 == entity1a);
   entity3 = solparser_find_entity(parser, "lvl0.lvl1b");
-  CHECK(entity3, entity1b);
+  CHK(entity3 == entity1b);
   entity3 = solparser_find_entity(parser, "lvl0.lvl1b.lvl2");
-  CHECK(entity3, entity2);
+  CHK(entity3 == entity2);
   entity3 = solparser_find_entity(parser,"lvl0.lvl1b.bad_name");
-  CHECK(entity3, NULL);
+  CHK(entity3 == NULL);
 
   sun = solparser_get_sun(parser);
-  NCHECK(sun, NULL);
-  CHECK(sun->dni, 1.0);
-  CHECK(sun->radang_distrib_type, SOLPARSER_SUN_RADANG_DISTRIB_DIRECTIONAL);
-  CHECK(SOLPARSER_ID_IS_VALID(sun->spectrum), 1);
+  CHK(sun != NULL);
+  CHK(sun->dni == 1.0);
+  CHK(sun->radang_distrib_type == SOLPARSER_SUN_RADANG_DISTRIB_DIRECTIONAL);
+  CHK(SOLPARSER_ID_IS_VALID(sun->spectrum) == 1);
   spectrum = solparser_get_spectrum(parser, sun->spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 1);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 1.0);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 1.0);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 1);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 1.0);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 1.0);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   solparser_ref_put(parser);
 
   fclose(stream);
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
 
diff --git a/src/parser/test_solparser3.c b/src/parser/test_solparser3.c
@@ -116,105 +116,105 @@ check_entity0
   const struct solparser_shape_cylinder* cylinder;
   double tmp[3];
 
-  NCHECK(parser, NULL);
-  NCHECK(entity0, NULL);
+  CHK(parser != NULL);
+  CHK(entity0 != NULL);
 
-  CHECK(strcmp(str_cget(&entity0->name), "entity0"), 0);
-  CHECK(d3_eq(entity0->rotation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(entity0->translation, d3_splat(tmp, 0)), 1);
-  CHECK(entity0->type, SOLPARSER_ENTITY_GEOMETRY);
+  CHK(strcmp(str_cget(&entity0->name), "entity0") == 0);
+  CHK(d3_eq(entity0->rotation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(entity0->translation, d3_splat(tmp, 0)) == 1);
+  CHK(entity0->type == SOLPARSER_ENTITY_GEOMETRY);
 
   geom = solparser_get_geometry(parser, entity0->data.geometry);
-  CHECK(solparser_geometry_get_objects_count(geom), 1);
+  CHK(solparser_geometry_get_objects_count(geom) == 1);
 
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
-  CHECK(d3_eq(obj->rotation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(obj->translation, d3_splat(tmp, 0)), 1);
+  CHK(d3_eq(obj->rotation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(obj->translation, d3_splat(tmp, 0)) == 1);
 
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_CYLINDER);
+  CHK(shape->type == SOLPARSER_SHAPE_CYLINDER);
 
   cylinder = solparser_get_shape_cylinder(parser, shape->data.cylinder);
-  CHECK(cylinder->height, 10);
-  CHECK(cylinder->radius, 1);
-  CHECK(cylinder->nslices, 128);
+  CHK(cylinder->height == 10);
+  CHK(cylinder->radius == 1);
+  CHK(cylinder->nslices == 128);
 
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  CHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i == mtl2->back.i);
 
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_MATTE);
+  CHK(mtl->type == SOLPARSER_MATERIAL_MATTE);
 
   matte = solparser_get_material_matte(parser, mtl->data.matte);
-  CHECK(matte->reflectivity.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(matte->reflectivity.value.real, 0.5);
+  CHK(matte->reflectivity.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(matte->reflectivity.value.real == 0.5);
 
-  CHECK(solparser_entity_get_children_count(entity0), 4);
-  CHECK(solparser_entity_get_anchors_count(entity0), 3);
+  CHK(solparser_entity_get_children_count(entity0) == 4);
+  CHK(solparser_entity_get_anchors_count(entity0) == 3);
 
   anchor_id = solparser_entity_get_anchor(entity0, 0);
   entity0_anchor0 = solparser_get_anchor(parser, anchor_id);
-  CHECK(strcmp(str_cget(&entity0_anchor0->name), "anchor0"), 0);
-  CHECK(d3_eq(entity0_anchor0->position, d3(tmp, 1, 2, 3)), 1);
+  CHK(strcmp(str_cget(&entity0_anchor0->name), "anchor0") == 0);
+  CHK(d3_eq(entity0_anchor0->position, d3(tmp, 1, 2, 3)) == 1);
 
   anchor_id = solparser_entity_get_anchor(entity0, 1);
   entity0_anchor1 = solparser_get_anchor(parser, anchor_id);
-  CHECK(strcmp(str_cget(&entity0_anchor1->name), "anchor1"), 0);
-  CHECK(d3_eq(entity0_anchor1->position, d3(tmp, 4, 5, 6)), 1);
+  CHK(strcmp(str_cget(&entity0_anchor1->name), "anchor1") == 0);
+  CHK(d3_eq(entity0_anchor1->position, d3(tmp, 4, 5, 6)) == 1);
 
   entity_id = solparser_entity_get_child(entity0, 0);
   entity0a = solparser_get_entity(parser, entity_id);
-  CHECK(strcmp(str_cget(&entity0a->name), "entity0a"), 0);
-  CHECK(entity0a->type, SOLPARSER_ENTITY_GEOMETRY);
-  NCHECK(entity0->data.geometry.i, entity0a->data.geometry.i);
-  CHECK(solparser_entity_get_anchors_count(entity0a), 0);
-  CHECK(solparser_entity_get_children_count(entity0a), 0);
+  CHK(strcmp(str_cget(&entity0a->name), "entity0a") == 0);
+  CHK(entity0a->type == SOLPARSER_ENTITY_GEOMETRY);
+  CHK(entity0->data.geometry.i != entity0a->data.geometry.i);
+  CHK(solparser_entity_get_anchors_count(entity0a) == 0);
+  CHK(solparser_entity_get_children_count(entity0a) == 0);
 
   geom = solparser_get_geometry(parser, entity0a->data.geometry);
-  CHECK(solparser_geometry_get_objects_count(geom), 1);
+  CHK(solparser_geometry_get_objects_count(geom) == 1);
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_CYLINDER);
+  CHK(shape->type == SOLPARSER_SHAPE_CYLINDER);
   cylinder = solparser_get_shape_cylinder(parser, shape->data.cylinder);
-  CHECK(cylinder->height, 10);
-  CHECK(cylinder->radius, 1);
-  CHECK(cylinder->nslices, 16);
+  CHK(cylinder->height == 10);
+  CHK(cylinder->radius == 1);
+  CHK(cylinder->nslices == 16);
 
   entity_id = solparser_entity_get_child(entity0, 1);
   entity0b = solparser_get_entity(parser, entity_id);
-  CHECK(strcmp(str_cget(&entity0b->name), "entity0b"), 0);
-  CHECK(entity0b->type, SOLPARSER_ENTITY_GEOMETRY);
-  CHECK(entity0->data.geometry.i, entity0b->data.geometry.i);
-  CHECK(solparser_entity_get_anchors_count(entity0b), 2);
-  CHECK(solparser_entity_get_children_count(entity0b), 0);
+  CHK(strcmp(str_cget(&entity0b->name), "entity0b") == 0);
+  CHK(entity0b->type == SOLPARSER_ENTITY_GEOMETRY);
+  CHK(entity0->data.geometry.i == entity0b->data.geometry.i);
+  CHK(solparser_entity_get_anchors_count(entity0b) == 2);
+  CHK(solparser_entity_get_children_count(entity0b) == 0);
 
   anchor_id = solparser_entity_get_anchor(entity0b, 0);
   entity0_entity0b_anchor0 = solparser_get_anchor(parser, anchor_id);
-  CHECK(strcmp(str_cget(&entity0_entity0b_anchor0->name), "anchor0"), 0);
-  CHECK(d3_eq(entity0_entity0b_anchor0->position, d3(tmp, 4, 5, 6)), 1);
+  CHK(strcmp(str_cget(&entity0_entity0b_anchor0->name), "anchor0") == 0);
+  CHK(d3_eq(entity0_entity0b_anchor0->position, d3(tmp, 4, 5, 6)) == 1);
 
   anchor_id = solparser_entity_get_anchor(entity0b, 1);
   entity0_entity0b_entity0b = solparser_get_anchor(parser, anchor_id);
-  CHECK(strcmp(str_cget(&entity0_entity0b_entity0b->name), "entity0b"), 0);
-  CHECK(d3_eq(entity0_entity0b_entity0b->position, d3(tmp, 7, 8, 9)), 1);
+  CHK(strcmp(str_cget(&entity0_entity0b_entity0b->name), "entity0b") == 0);
+  CHK(d3_eq(entity0_entity0b_entity0b->position, d3(tmp, 7, 8, 9)) == 1);
 
   entity_id = solparser_entity_get_child(entity0, 2);
   entity0c = solparser_get_entity(parser, entity_id);
-  CHECK(strcmp(str_cget(&entity0c->name), "entity0c"), 0);
-  CHECK(entity0c->type, SOLPARSER_ENTITY_GEOMETRY);
-  NCHECK(entity0->data.geometry.i, entity0c->data.geometry.i);
-  CHECK(solparser_entity_get_anchors_count(entity0c), 0);
-  CHECK(solparser_entity_get_children_count(entity0c), 0);
+  CHK(strcmp(str_cget(&entity0c->name), "entity0c") == 0);
+  CHK(entity0c->type == SOLPARSER_ENTITY_GEOMETRY);
+  CHK(entity0->data.geometry.i != entity0c->data.geometry.i);
+  CHK(solparser_entity_get_anchors_count(entity0c) == 0);
+  CHK(solparser_entity_get_children_count(entity0c) == 0);
 
   entity_id = solparser_entity_get_child(entity0, 3);
   entity0d = solparser_get_entity(parser, entity_id);
-  CHECK(strcmp(str_cget(&entity0d->name), "entity0d"), 0);
-  CHECK(entity0d->type, SOLPARSER_ENTITY_GEOMETRY);
-  NCHECK(entity0->data.geometry.i, entity0d->data.geometry.i);
-  CHECK(solparser_entity_get_anchors_count(entity0d), 0);
-  CHECK(solparser_entity_get_children_count(entity0d), 0);
+  CHK(strcmp(str_cget(&entity0d->name), "entity0d") == 0);
+  CHK(entity0d->type == SOLPARSER_ENTITY_GEOMETRY);
+  CHK(entity0->data.geometry.i != entity0d->data.geometry.i);
+  CHK(solparser_entity_get_anchors_count(entity0d) == 0);
+  CHK(solparser_entity_get_children_count(entity0d) == 0);
 }
 
 static void
@@ -223,18 +223,18 @@ check_entity1
 {
   double tmp[3];
 
-  NCHECK(parser, NULL);
-  NCHECK(entity1, NULL);
+  CHK(parser != NULL);
+  CHK(entity1 != NULL);
 
-  CHECK(strcmp(str_cget(&entity1->name), "entity1"), 0);
-  CHECK(entity1->type, SOLPARSER_ENTITY_X_PIVOT);
-  CHECK(solparser_entity_get_anchors_count(entity1), 0);
-  CHECK(solparser_entity_get_children_count(entity1), 0);
+  CHK(strcmp(str_cget(&entity1->name), "entity1") == 0);
+  CHK(entity1->type == SOLPARSER_ENTITY_X_PIVOT);
+  CHK(solparser_entity_get_anchors_count(entity1) == 0);
+  CHK(solparser_entity_get_children_count(entity1) == 0);
 
   x_pivot = solparser_get_x_pivot(parser, entity1->data.x_pivot);
-  NCHECK(x_pivot, NULL);
-  CHECK(d3_eq(x_pivot->ref_point, d3(tmp, 1, 2, 3)), 1);
-  CHECK(x_pivot->target.type, SOLPARSER_TARGET_ANCHOR);
+  CHK(x_pivot != NULL);
+  CHK(d3_eq(x_pivot->ref_point, d3(tmp, 1, 2, 3)) == 1);
+  CHK(x_pivot->target.type == SOLPARSER_TARGET_ANCHOR);
 }
 
 static void
@@ -243,19 +243,19 @@ check_entity2
 {
   double tmp[3];
 
-  NCHECK(parser, NULL);
-  NCHECK(entity2, NULL);
+  CHK(parser != NULL);
+  CHK(entity2 != NULL);
 
-  CHECK(strcmp(str_cget(&entity2->name), "entity2"), 0);
-  CHECK(entity2->type, SOLPARSER_ENTITY_ZX_PIVOT);
-  CHECK(solparser_entity_get_anchors_count(entity2), 0);
-  CHECK(solparser_entity_get_children_count(entity2), 0);
+  CHK(strcmp(str_cget(&entity2->name), "entity2") == 0);
+  CHK(entity2->type == SOLPARSER_ENTITY_ZX_PIVOT);
+  CHK(solparser_entity_get_anchors_count(entity2) == 0);
+  CHK(solparser_entity_get_children_count(entity2) == 0);
 
   zx_pivot = solparser_get_zx_pivot(parser, entity2->data.zx_pivot);
-  NCHECK(zx_pivot, NULL);
-  CHECK(zx_pivot->spacing, 1);
-  CHECK(d3_eq(zx_pivot->ref_point, d3(tmp, 1, 2, 3)), 1);
-  CHECK(zx_pivot->target.type, SOLPARSER_TARGET_ANCHOR);
+  CHK(zx_pivot != NULL);
+  CHK(zx_pivot->spacing == 1);
+  CHK(d3_eq(zx_pivot->ref_point, d3(tmp, 1, 2, 3)) == 1);
+  CHK(zx_pivot->target.type == SOLPARSER_TARGET_ANCHOR);
 }
 
 static void
@@ -264,18 +264,18 @@ check_entity3
 {
   double tmp[3];
 
-  NCHECK(parser, NULL);
-  NCHECK(entity3, NULL);
+  CHK(parser != NULL);
+  CHK(entity3 != NULL);
 
-  CHECK(strcmp(str_cget(&entity3->name), "entity3"), 0);
-  CHECK(entity3->type, SOLPARSER_ENTITY_X_PIVOT);
-  CHECK(solparser_entity_get_anchors_count(entity3), 0);
-  CHECK(solparser_entity_get_children_count(entity3), 0);
+  CHK(strcmp(str_cget(&entity3->name), "entity3") == 0);
+  CHK(entity3->type == SOLPARSER_ENTITY_X_PIVOT);
+  CHK(solparser_entity_get_anchors_count(entity3) == 0);
+  CHK(solparser_entity_get_children_count(entity3) == 0);
 
   x_pivot = solparser_get_x_pivot(parser, entity3->data.x_pivot);
-  NCHECK(x_pivot, NULL);
-  CHECK(d3_eq(x_pivot->ref_point, d3(tmp, 4, 2, 3)), 1);
-  CHECK(x_pivot->target.type, SOLPARSER_TARGET_ANCHOR);
+  CHK(x_pivot != NULL);
+  CHK(d3_eq(x_pivot->ref_point, d3(tmp, 4, 2, 3)) == 1);
+  CHK(x_pivot->target.type == SOLPARSER_TARGET_ANCHOR);
 }
 
 int
@@ -289,25 +289,25 @@ main(int argc, char** argv)
   size_t i;
   (void)argc, (void)argv;
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
   solparser_create(&allocator, &parser);
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
   i = 0;
   while(input[i]) {
     const size_t len = strlen(input[i]);
-    CHECK(fwrite(input[i], 1, len, stream), len);
+    CHK(fwrite(input[i], 1, len, stream) == len);
     ++i;
   }
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &it_end);
-  CHECK(solparser_entity_iterator_eq(&it, &it_end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &it_end) == 0);
 
   while(!solparser_entity_iterator_eq(&it, &it_end)) {
     struct solparser_entity_id entity_id;
@@ -335,29 +335,29 @@ main(int argc, char** argv)
   }
 
   anchor = solparser_get_anchor(parser, x_pivot->target.data.anchor);
-  CHECK(anchor, entity0_entity0b_anchor0);
+  CHK(anchor == entity0_entity0b_anchor0);
 
   anchor = solparser_find_anchor(parser, "entity0");
-  CHECK(anchor, NULL);
+  CHK(anchor == NULL);
   anchor = solparser_find_anchor(parser, "entity0.anchor0");
-  CHECK(anchor, entity0_anchor0);
+  CHK(anchor == entity0_anchor0);
   anchor = solparser_find_anchor(parser, "entity0.anchor1");
-  CHECK(anchor, entity0_anchor1);
+  CHK(anchor == entity0_anchor1);
   anchor = solparser_find_anchor(parser, "entity0.entity0a.anchor0");
-  CHECK(anchor, NULL);
+  CHK(anchor == NULL);
   anchor = solparser_find_anchor(parser, "entity0.entity0b.anchor0");
-  CHECK(anchor, entity0_entity0b_anchor0);
+  CHK(anchor == entity0_entity0b_anchor0);
   anchor = solparser_find_anchor(parser, "entity0.entity0b.entity0b");
-  CHECK(anchor, entity0_entity0b_entity0b);
+  CHK(anchor == entity0_entity0b_entity0b);
   anchor = solparser_find_anchor(parser, "entity1.entity0b.anchor1");
-  CHECK(anchor, NULL);
+  CHK(anchor == NULL);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   solparser_ref_put(parser);
   fclose(stream);
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
diff --git a/src/parser/test_solparser4.c b/src/parser/test_solparser4.c
@@ -50,26 +50,26 @@ check_entity0
   struct solparser_entity_id entity_id;
   double tmp[3];
 
-  NCHECK(parser, NULL);
-  NCHECK(entity0, NULL);
+  CHK(parser != NULL);
+  CHK(entity0 != NULL);
 
-  CHECK(strcmp(str_cget(&entity0->name), "entity0"), 0);
-  CHECK(d3_eq(entity0->rotation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(entity0->translation, d3(tmp, 1, 2, 3)), 1);
-  CHECK(entity0->type, SOLPARSER_ENTITY_EMPTY);
+  CHK(strcmp(str_cget(&entity0->name), "entity0") == 0);
+  CHK(d3_eq(entity0->rotation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(entity0->translation, d3(tmp, 1, 2, 3)) == 1);
+  CHK(entity0->type == SOLPARSER_ENTITY_EMPTY);
 
-  CHECK(solparser_entity_get_children_count(entity0), 1);
-  CHECK(solparser_entity_get_anchors_count(entity0), 0);
+  CHK(solparser_entity_get_children_count(entity0) == 1);
+  CHK(solparser_entity_get_anchors_count(entity0) == 0);
 
   entity_id = solparser_entity_get_child(entity0, 0);
   entity = solparser_get_entity(parser, entity_id);
-  CHECK(strcmp(str_cget(&entity->name), "template0"), 0);
-  CHECK(d3_eq(entity->translation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(entity->rotation, d3_splat(tmp, 0)), 1);
+  CHK(strcmp(str_cget(&entity->name), "template0") == 0);
+  CHK(d3_eq(entity->translation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(entity->rotation, d3_splat(tmp, 0)) == 1);
 
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
-  CHECK(solparser_get_geometry(parser, entity->data.geometry), geometry);
-  CHECK(solparser_find_entity(parser, "entity0.template0"), entity);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
+  CHK(solparser_get_geometry(parser, entity->data.geometry) == geometry);
+  CHK(solparser_find_entity(parser, "entity0.template0") == entity);
 }
 
 static void
@@ -80,26 +80,26 @@ check_entity1
   struct solparser_entity_id entity_id;
   double tmp[3];
 
-  NCHECK(parser, NULL);
-  NCHECK(entity1, NULL);
+  CHK(parser != NULL);
+  CHK(entity1 != NULL);
 
-  CHECK(strcmp(str_cget(&entity1->name), "entity1"), 0);
-  CHECK(d3_eq(entity1->rotation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(entity1->translation, d3(tmp, 3, 4, 5)), 1);
-  CHECK(entity1->type, SOLPARSER_ENTITY_EMPTY);
+  CHK(strcmp(str_cget(&entity1->name), "entity1") == 0);
+  CHK(d3_eq(entity1->rotation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(entity1->translation, d3(tmp, 3, 4, 5)) == 1);
+  CHK(entity1->type == SOLPARSER_ENTITY_EMPTY);
 
-  CHECK(solparser_entity_get_children_count(entity1), 1);
-  CHECK(solparser_entity_get_anchors_count(entity1), 0);
+  CHK(solparser_entity_get_children_count(entity1) == 1);
+  CHK(solparser_entity_get_anchors_count(entity1) == 0);
 
   entity_id = solparser_entity_get_child(entity1, 0);
   entity = solparser_get_entity(parser, entity_id);
-  CHECK(strcmp(str_cget(&entity->name), "template0"), 0);
-  CHECK(d3_eq(entity->rotation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(entity->translation, d3_splat(tmp, 0)), 1);
+  CHK(strcmp(str_cget(&entity->name), "template0") == 0);
+  CHK(d3_eq(entity->rotation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(entity->translation, d3_splat(tmp, 0)) == 1);
 
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
-  CHECK(solparser_get_geometry(parser, entity->data.geometry), geometry);
-  CHECK(solparser_find_entity(parser, "entity1.template0"), entity);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
+  CHK(solparser_get_geometry(parser, entity->data.geometry) == geometry);
+  CHK(solparser_find_entity(parser, "entity1.template0") == entity);
 }
 
 int
@@ -124,56 +124,56 @@ main(int argc, char** argv)
   int entity1 = 0;
   (void)argc, (void)argv;
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
   solparser_create(&allocator, &parser);
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
   i = 0;
   while(input[i]) {
     const size_t len = strlen(input[i]);
-    CHECK(fwrite(input[i], 1, len, stream), len);
+    CHK(fwrite(input[i], 1, len, stream) == len);
     ++i;
   }
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_geometry_iterator_begin(parser, &it_geom);
   solparser_geometry_iterator_end(parser, &it_end_geom);
-  CHECK(solparser_geometry_iterator_eq(&it_geom, &it_end_geom), 0);
+  CHK(solparser_geometry_iterator_eq(&it_geom, &it_end_geom) == 0);
   geom_id = solparser_geometry_iterator_get(&it_geom);
   geometry = solparser_get_geometry(parser, geom_id);
   solparser_geometry_iterator_next(&it_geom);
-  CHECK(solparser_geometry_iterator_eq(&it_geom, &it_end_geom), 1);
+  CHK(solparser_geometry_iterator_eq(&it_geom, &it_end_geom) == 1);
 
-  CHECK(solparser_geometry_get_objects_count(geometry), 1);
+  CHK(solparser_geometry_get_objects_count(geometry) == 1);
   obj_id = solparser_geometry_get_object(geometry, 0);
   obj = solparser_get_object(parser, obj_id);
-  CHECK(d3_eq(obj->rotation, d3_splat(tmp, 0)), 1);
-  CHECK(d3_eq(obj->translation, d3_splat(tmp, 0)), 1);
+  CHK(d3_eq(obj->rotation, d3_splat(tmp, 0)) == 1);
+  CHK(d3_eq(obj->translation, d3_splat(tmp, 0)) == 1);
 
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  CHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i == mtl2->back.i);
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_MIRROR);
+  CHK(mtl->type == SOLPARSER_MATERIAL_MIRROR);
   mirror = solparser_get_material_mirror(parser, mtl->data.mirror);
-  CHECK(mirror->reflectivity.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(mirror->reflectivity.value.real, 0.2);
-  CHECK(mirror->roughness.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(mirror->roughness.value.real, 0.1);
+  CHK(mirror->reflectivity.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(mirror->reflectivity.value.real == 0.2);
+  CHK(mirror->roughness.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(mirror->roughness.value.real == 0.1);
 
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_CUBOID);
+  CHK(shape->type == SOLPARSER_SHAPE_CUBOID);
   cuboid = solparser_get_shape_cuboid(parser, shape->data.cuboid);
-  CHECK(cuboid->size[0], 1);
-  CHECK(cuboid->size[1], 2);
-  CHECK(cuboid->size[2], 3);
+  CHK(cuboid->size[0] == 1);
+  CHK(cuboid->size[1] == 2);
+  CHK(cuboid->size[2] == 3);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &it_end);
-  CHECK(solparser_entity_iterator_eq(&it, &it_end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &it_end) == 0);
 
   while(!solparser_entity_iterator_eq(&it, &it_end)) {
     struct solparser_entity_id entity_id;
@@ -183,11 +183,11 @@ main(int argc, char** argv)
     entity = solparser_get_entity(parser, entity_id);
 
     if(!strcmp(str_cget(&entity->name), "entity0")) {
-      CHECK(entity0, 0);
+      CHK(entity0 == 0);
       entity0 = 1;
       check_entity0(parser, entity);
     } else if(!strcmp(str_cget(&entity->name), "entity1")) {
-      CHECK(entity1, 0);
+      CHK(entity1 == 0);
       entity1 = 1;
       check_entity1(parser, entity);
     } else {
@@ -196,16 +196,16 @@ main(int argc, char** argv)
 
     solparser_entity_iterator_next(&it);
   }
-  CHECK(entity0, 1);
-  CHECK(entity1, 1);
+  CHK(entity0 == 1);
+  CHK(entity1 == 1);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   solparser_ref_put(parser);
   fclose(stream);
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
 
diff --git a/src/parser/test_solparser5.c b/src/parser/test_solparser5.c
@@ -53,27 +53,27 @@ check_entity(struct solparser* parser, const struct solparser_entity* entity)
   struct solparser_entity_id entity_id;
   double tmp[3];
 
-  CHECK(entity->type, SOLPARSER_ENTITY_EMPTY);
+  CHK(entity->type == SOLPARSER_ENTITY_EMPTY);
 
-  CHECK(solparser_entity_get_children_count(entity), 1);
+  CHK(solparser_entity_get_children_count(entity) == 1);
   entity_id = solparser_entity_get_child(entity, 0);
   entity = solparser_get_entity(parser, entity_id);
-  CHECK(strcmp(str_cget(&entity->name), "lvl1"), 0);
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
+  CHK(strcmp(str_cget(&entity->name), "lvl1") == 0);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
 
-  CHECK(solparser_entity_get_children_count(entity), 1);
+  CHK(solparser_entity_get_children_count(entity) == 1);
   entity_id = solparser_entity_get_child(entity, 0);
   entity = solparser_get_entity(parser, entity_id);
-  CHECK(strcmp(str_cget(&entity->name), "lvl2"), 0);
-  CHECK(entity->type, SOLPARSER_ENTITY_X_PIVOT);
+  CHK(strcmp(str_cget(&entity->name), "lvl2") == 0);
+  CHK(entity->type == SOLPARSER_ENTITY_X_PIVOT);
 
   x_pivot = solparser_get_x_pivot(parser, entity->data.x_pivot);
-  CHECK(d3_eq(x_pivot->ref_point, d3(tmp, 1, 2, 3)), 1);
-  CHECK(x_pivot->target.type, SOLPARSER_TARGET_ANCHOR);
+  CHK(d3_eq(x_pivot->ref_point, d3(tmp, 1, 2, 3)) == 1);
+  CHK(x_pivot->target.type == SOLPARSER_TARGET_ANCHOR);
 
   anchor = solparser_get_anchor(parser, x_pivot->target.data.anchor);
-  CHECK(strcmp(str_cget(&anchor->name), "anchor0"), 0);
-  CHECK(d3_eq(anchor->position, d3(tmp, 1, 2, 3)), 1);
+  CHK(strcmp(str_cget(&anchor->name), "anchor0") == 0);
+  CHK(d3_eq(anchor->position, d3(tmp, 1, 2, 3)) == 1);
 }
 
 int
@@ -90,35 +90,35 @@ main(int argc, char** argv)
   FILE* stream;
   (void)argc, (void)argv;
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
   solparser_create(&allocator, &parser);
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
   i = 0;
   while(input[i]) {
     const size_t len = strlen(input[i]);
-    CHECK(fwrite(input[i], 1, len, stream), len);
+    CHK(fwrite(input[i], 1, len, stream) == len);
     ++i;
   }
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &it_end);
-  CHECK(solparser_entity_iterator_eq(&it, &it_end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &it_end) == 0);
 
   while(!solparser_entity_iterator_eq(&it, &it_end)) {
     entity_id = solparser_entity_iterator_get(&it);
     entity = solparser_get_entity(parser, entity_id);
     if(!strcmp(str_cget(&entity->name), "entity0")) {
-      CHECK(entity0, 0);
+      CHK(entity0 == 0);
       entity0 = 1;
       check_entity(parser, entity);
     } else if(!strcmp(str_cget(&entity->name), "entity1")) {
-      CHECK(entity1, 0);
+      CHK(entity1 == 0);
       entity1 = 1;
       check_entity(parser, entity);
     } else {
@@ -126,15 +126,15 @@ main(int argc, char** argv)
     }
     solparser_entity_iterator_next(&it);
   }
-  CHECK(entity0, 1);
-  CHECK(entity1, 1);
+  CHK(entity0 == 1);
+  CHK(entity1 == 1);
 
   solparser_ref_put(parser);
   fclose(stream);
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
 
diff --git a/src/parser/test_solparser6.c b/src/parser/test_solparser6.c
@@ -41,11 +41,11 @@ main(int argc, char** argv)
   FILE* stream;
   (void)argc, (void)argv;
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
   solparser_create(&allocator, &parser);
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
 
   fprintf(stream, "- sun: { dni: 1, spectrum: [{wavelength: 1, data: 1 }] }\n");
   fprintf(stream, "- entity:\n");
@@ -81,106 +81,106 @@ main(int argc, char** argv)
   fprintf(stream, "      material: { ?virtual }\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &end);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 0);
 
   entity_id = solparser_entity_iterator_get(&it);
   entity = solparser_get_entity(parser, entity_id);
 
-  CHECK(strcmp("test",  str_cget(&entity->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity), 0);
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
+  CHK(strcmp("test",  str_cget(&entity->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity) == 0);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
   geom = solparser_get_geometry(parser, entity->data.geometry);
-  CHECK(solparser_geometry_get_objects_count(geom), 5);
+  CHK(solparser_geometry_get_objects_count(geom) == 5);
 
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_SPHERE);
+  CHK(shape->type == SOLPARSER_SHAPE_SPHERE);
   sphere = solparser_get_shape_sphere(parser, shape->data.sphere);
-  CHECK(sphere->radius, 1);
-  CHECK(sphere->nslices, 16);
+  CHK(sphere->radius == 1);
+  CHK(sphere->nslices == 16);
 
   obj_id = solparser_geometry_get_object(geom, 1);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_PARABOL);
+  CHK(shape->type == SOLPARSER_SHAPE_PARABOL);
   parabol = solparser_get_shape_parabol(parser, shape->data.parabol);
-  CHECK(parabol->focal, 10);
-  CHECK(parabol->nslices, 10);
-  CHECK(darray_polyclip_size_get(&parabol->polyclips), 1);
+  CHK(parabol->focal == 10);
+  CHK(parabol->nslices == 10);
+  CHK(darray_polyclip_size_get(&parabol->polyclips) == 1);
   polyclip = darray_polyclip_cdata_get(&parabol->polyclips);
-  CHECK(polyclip->op, SOLPARSER_CLIP_OP_AND);
-  CHECK(polyclip->contour_type, SOLPARSER_CLIP_CONTOUR_POLY);
-  CHECK(solparser_polyclip_get_vertices_count(polyclip), 3);
+  CHK(polyclip->op == SOLPARSER_CLIP_OP_AND);
+  CHK(polyclip->contour_type == SOLPARSER_CLIP_CONTOUR_POLY);
+  CHK(solparser_polyclip_get_vertices_count(polyclip) == 3);
   solparser_polyclip_get_vertex(polyclip, 0, pos);
-  CHECK(pos[0], 1);
-  CHECK(pos[1], 2);
+  CHK(pos[0] == 1);
+  CHK(pos[1] == 2);
   solparser_polyclip_get_vertex(polyclip, 1, pos);
-  CHECK(pos[0], 3);
-  CHECK(pos[1], 4);
+  CHK(pos[0] == 3);
+  CHK(pos[1] == 4);
   solparser_polyclip_get_vertex(polyclip, 2, pos);
-  CHECK(pos[0], 6);
-  CHECK(pos[1], 7);
+  CHK(pos[0] == 6);
+  CHK(pos[1] == 7);
 
   obj_id = solparser_geometry_get_object(geom, 2);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_HYPERBOL);
+  CHK(shape->type == SOLPARSER_SHAPE_HYPERBOL);
   hyperbol = solparser_get_shape_hyperbol(parser, shape->data.hyperbol);
-  CHECK(hyperbol->focals.real, 10);
-  CHECK(hyperbol->focals.image, 2);
-  CHECK(hyperbol->nslices, 20);
+  CHK(hyperbol->focals.real == 10);
+  CHK(hyperbol->focals.image == 2);
+  CHK(hyperbol->nslices == 20);
 
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  CHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i == mtl2->back.i);
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_VIRTUAL);
+  CHK(mtl->type == SOLPARSER_MATERIAL_VIRTUAL);
 
   obj_id = solparser_geometry_get_object(geom, 3);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_PLANE);
+  CHK(shape->type == SOLPARSER_SHAPE_PLANE);
   plane = solparser_get_shape_plane(parser, shape->data.plane);
-  CHECK(plane->nslices, 1); /* Default value */
-  CHECK(darray_polyclip_size_get(&plane->polyclips), 1);
+  CHK(plane->nslices == 1); /* Default value */
+  CHK(darray_polyclip_size_get(&plane->polyclips) == 1);
   polyclip = darray_polyclip_cdata_get(&plane->polyclips);
-  CHECK(polyclip->contour_type, SOLPARSER_CLIP_CONTOUR_CIRCLE);
-  CHECK(polyclip->circle.radius, 1);
-  CHECK(polyclip->circle.center[0], -1);
-  CHECK(polyclip->circle.center[1], 1);
-  CHECK(polyclip->circle.segments, 8);
+  CHK(polyclip->contour_type == SOLPARSER_CLIP_CONTOUR_CIRCLE);
+  CHK(polyclip->circle.radius == 1);
+  CHK(polyclip->circle.center[0] == -1);
+  CHK(polyclip->circle.center[1] == 1);
+  CHK(polyclip->circle.segments == 8);
 
   obj_id = solparser_geometry_get_object(geom, 4);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_HEMISPHERE);
+  CHK(shape->type == SOLPARSER_SHAPE_HEMISPHERE);
   hemisphere = solparser_get_shape_hemisphere(parser, shape->data.hemisphere);;
-  CHECK(hemisphere->radius, 100);
-  CHECK(hemisphere->nslices, -1); /* Default value: auto */
-  CHECK(darray_polyclip_size_get(&hemisphere->polyclips), 1);
+  CHK(hemisphere->radius == 100);
+  CHK(hemisphere->nslices == -1); /* Default value: auto */
+  CHK(darray_polyclip_size_get(&hemisphere->polyclips) == 1);
   polyclip = darray_polyclip_cdata_get(&hemisphere->polyclips);
-  CHECK(polyclip->contour_type, SOLPARSER_CLIP_CONTOUR_CIRCLE);
-  CHECK(polyclip->circle.radius, 1);
-  CHECK(polyclip->circle.center[0], 0); /* default value */
-  CHECK(polyclip->circle.center[1], 0); /* default value */
-  CHECK(polyclip->circle.segments, 64); /* Default value */
+  CHK(polyclip->contour_type == SOLPARSER_CLIP_CONTOUR_CIRCLE);
+  CHK(polyclip->circle.radius == 1);
+  CHK(polyclip->circle.center[0] == 0); /* default value */
+  CHK(polyclip->circle.center[1] == 0); /* default value */
+  CHK(polyclip->circle.segments == 64); /* Default value */
 
   solparser_entity_iterator_next(&it);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 1);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 1);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   solparser_ref_put(parser);
 
   fclose(stream);
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
 
diff --git a/src/parser/test_solparser7.c b/src/parser/test_solparser7.c
@@ -37,11 +37,11 @@ main(int argc, char** argv)
   FILE* stream;
   (void)argc, (void)argv;
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
   solparser_create(&allocator, &parser);
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
 
   fprintf(stream, "- sun: { dni: 1, spectrum: [{wavelength: 1, data: 1 }] }\n");
   fprintf(stream, "- entity:\n");
@@ -68,71 +68,71 @@ main(int argc, char** argv)
   fprintf(stream, "              - {wavelength: 2, data: 2}\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &end);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 0);
 
   entity_id = solparser_entity_iterator_get(&it);
   entity = solparser_get_entity(parser, entity_id);
 
-  CHECK(strcmp("test",  str_cget(&entity->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity), 0);
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
+  CHK(strcmp("test",  str_cget(&entity->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity) == 0);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
   geom = solparser_get_geometry(parser, entity->data.geometry);
-  CHECK(solparser_geometry_get_objects_count(geom), 1);
+  CHK(solparser_geometry_get_objects_count(geom) == 1);
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_SPHERE);
+  CHK(shape->type == SOLPARSER_SHAPE_SPHERE);
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  CHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i == mtl2->back.i);
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_THIN_DIELECTRIC);
+  CHK(mtl->type == SOLPARSER_MATERIAL_THIN_DIELECTRIC);
   thin = solparser_get_material_thin_dielectric
     (parser, mtl->data.thin_dielectric);
-  CHECK(thin->thickness, 0.123);
+  CHK(thin->thickness == 0.123);
 
   medium = solparser_get_medium(parser, thin->medium_i);
-  CHECK(medium->refractive_index.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(medium->refractive_index.value.real, 1);
-  CHECK(medium->extinction.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(medium->extinction.value.real, 0);
+  CHK(medium->refractive_index.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(medium->refractive_index.value.real == 1);
+  CHK(medium->extinction.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(medium->extinction.value.real == 0);
   medium = solparser_get_medium(parser, thin->medium_t);
 
-  CHECK(medium->refractive_index.type, SOLPARSER_MTL_DATA_SPECTRUM);
+  CHK(medium->refractive_index.type == SOLPARSER_MTL_DATA_SPECTRUM);
   spectrum = solparser_get_spectrum(parser, medium->refractive_index.value.spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 3);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 0.5);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength, 1.2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength, 4.5);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 0.25);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data, 2.3);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data, 6.7);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 3);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 0.5);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength == 1.2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength == 4.5);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 0.25);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data == 2.3);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data == 6.7);
 
-  CHECK(medium->extinction.type, SOLPARSER_MTL_DATA_SPECTRUM);
+  CHK(medium->extinction.type == SOLPARSER_MTL_DATA_SPECTRUM);
   spectrum = solparser_get_spectrum(parser, medium->extinction.value.spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 5);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 1);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength, 2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength, 3);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[3].wavelength, 4);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[4].wavelength, 5);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 1);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data, 2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data, 3);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[3].data, 4);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[4].data, 5);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 5);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 1);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength == 2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength == 3);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[3].wavelength == 4);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[4].wavelength == 5);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 1);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data == 2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data == 3);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[3].data == 4);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[4].data == 5);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   solparser_ref_put(parser);
 
   fclose(stream);
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
diff --git a/src/parser/test_solparser8.c b/src/parser/test_solparser8.c
@@ -38,11 +38,11 @@ main(int argc, char** argv)
   FILE* stream;
   (void)argc, (void)argv;
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
-  CHECK(solparser_create(&allocator, &parser), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
+  CHK(solparser_create(&allocator, &parser) == RES_OK);
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
 
   fprintf(stream, "- sun: { dni: 1, spectrum: [{wavelength: 1, data: 1 }] }\n");
   fprintf(stream, "- medium: &vacuum {refractive_index: 1, extinction: 0}\n");
@@ -71,70 +71,70 @@ main(int argc, char** argv)
   fprintf(stream, "              medium_t: *vacuum\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &end);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 0);
 
   entity_id = solparser_entity_iterator_get(&it);
   entity = solparser_get_entity(parser, entity_id);
 
-  CHECK(strcmp("test",  str_cget(&entity->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity), 0);
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
+  CHK(strcmp("test",  str_cget(&entity->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity) == 0);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
   geom = solparser_get_geometry(parser, entity->data.geometry);
-  CHECK(solparser_geometry_get_objects_count(geom), 1);
+  CHK(solparser_geometry_get_objects_count(geom) == 1);
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_SPHERE);
+  CHK(shape->type == SOLPARSER_SHAPE_SPHERE);
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  NCHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i != mtl2->back.i);
 
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_DIELECTRIC);
+  CHK(mtl->type == SOLPARSER_MATERIAL_DIELECTRIC);
   dielec = solparser_get_material_dielectric(parser, mtl->data.dielectric);
   vacuum = solparser_get_medium(parser, dielec->medium_i);
-  CHECK(vacuum->refractive_index.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(vacuum->refractive_index.value.real, 1);
-  CHECK(vacuum->extinction.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(vacuum->extinction.value.real, 0);
+  CHK(vacuum->refractive_index.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(vacuum->refractive_index.value.real == 1);
+  CHK(vacuum->extinction.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(vacuum->extinction.value.real == 0);
 
   glass = solparser_get_medium(parser, dielec->medium_t);
-  CHECK(glass->refractive_index.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(glass->refractive_index.value.real, 1.5);
-  CHECK(glass->extinction.type, SOLPARSER_MTL_DATA_SPECTRUM);
+  CHK(glass->refractive_index.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(glass->refractive_index.value.real == 1.5);
+  CHK(glass->extinction.type == SOLPARSER_MTL_DATA_SPECTRUM);
   spectrum = solparser_get_spectrum(parser, glass->extinction.value.spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 6);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 1);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength, 2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength, 3);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[3].wavelength, 4);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[4].wavelength, 5);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[5].wavelength, 6);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 21);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data, 22);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data, 23);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[3].data, 24);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[4].data, 25);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[5].data, 26);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 6);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 1);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength == 2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength == 3);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[3].wavelength == 4);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[4].wavelength == 5);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[5].wavelength == 6);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 21);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data == 22);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data == 23);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[3].data == 24);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[4].data == 25);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[5].data == 26);
 
   mtl = solparser_get_material(parser, mtl2->back);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_DIELECTRIC);
+  CHK(mtl->type == SOLPARSER_MATERIAL_DIELECTRIC);
   dielec = solparser_get_material_dielectric(parser, mtl->data.dielectric);
-  CHECK(solparser_get_medium(parser, dielec->medium_i), glass);
-  CHECK(solparser_get_medium(parser, dielec->medium_t), vacuum);
+  CHK(solparser_get_medium(parser, dielec->medium_i) == glass);
+  CHK(solparser_get_medium(parser, dielec->medium_t) == vacuum);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   solparser_ref_put(parser);
 
   fclose(stream);
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
 
diff --git a/src/parser/test_solparser_normal_map.c b/src/parser/test_solparser_normal_map.c
@@ -33,7 +33,7 @@ test_dielectric(struct solparser* parser)
   FILE* stream;
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
 
   fprintf(stream, "- sun: {dni: 1, spectrum: [{wavelength: 1, data: 1} ]}\n");
   fprintf(stream, "\n");
@@ -53,45 +53,45 @@ test_dielectric(struct solparser* parser)
   fprintf(stream, "      material: *glass\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &end);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 0);
 
   entity_id = solparser_entity_iterator_get(&it);
   entity = solparser_get_entity(parser, entity_id);
 
-  CHECK(strcmp("foo",  str_cget(&entity->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity), 0);
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
-  CHECK(entity->primary, 1);
+  CHK(strcmp("foo",  str_cget(&entity->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity) == 0);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
+  CHK(entity->primary == 1);
   geom = solparser_get_geometry(parser, entity->data.geometry);
-  CHECK(solparser_geometry_get_objects_count(geom), 1);
+  CHK(solparser_geometry_get_objects_count(geom) == 1);
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_CYLINDER);
+  CHK(shape->type == SOLPARSER_SHAPE_CYLINDER);
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  NCHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i != mtl2->back.i);
 
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_DIELECTRIC);
+  CHK(mtl->type == SOLPARSER_MATERIAL_DIELECTRIC);
   dielectric = solparser_get_material_dielectric(parser, mtl->data.dielectric);
-  CHECK(SOLPARSER_ID_IS_VALID(dielectric->normal_map), 1);
+  CHK(SOLPARSER_ID_IS_VALID(dielectric->normal_map) == 1);
   img = solparser_get_image(parser, dielectric->normal_map);
-  CHECK(strcmp(str_cget(&img->filename), "my_normal_map"), 0);
+  CHK(strcmp(str_cget(&img->filename), "my_normal_map") == 0);
 
   mtl = solparser_get_material(parser, mtl2->back);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_DIELECTRIC);
+  CHK(mtl->type == SOLPARSER_MATERIAL_DIELECTRIC);
   dielectric = solparser_get_material_dielectric(parser, mtl->data.dielectric);
-  CHECK(SOLPARSER_ID_IS_VALID(dielectric->normal_map), 0);
+  CHK(SOLPARSER_ID_IS_VALID(dielectric->normal_map) == 0);
 
   solparser_entity_iterator_next(&it);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 1);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 1);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   fclose(stream);
 }
 
@@ -112,7 +112,7 @@ test_matte(struct solparser* parser)
   FILE* stream;
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
 
   fprintf(stream, "- sun: { dni: 1, spectrum: [{wavelength: 1, data: 1} ] }\n");
   fprintf(stream, "- entity:\n");
@@ -126,42 +126,42 @@ test_matte(struct solparser* parser)
   fprintf(stream, "            normal_map: { path: \"path to normal map\" }\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &end);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 0);
 
   entity_id = solparser_entity_iterator_get(&it);
   entity = solparser_get_entity(parser, entity_id);
 
-  CHECK(strcmp("test",  str_cget(&entity->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity), 0);
-  CHECK(entity->primary, 0);
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
+  CHK(strcmp("test",  str_cget(&entity->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity) == 0);
+  CHK(entity->primary == 0);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
   geom = solparser_get_geometry(parser, entity->data.geometry);
-  CHECK(solparser_geometry_get_objects_count(geom), 1);
+  CHK(solparser_geometry_get_objects_count(geom) == 1);
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_SPHERE);
+  CHK(shape->type == SOLPARSER_SHAPE_SPHERE);
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  CHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i == mtl2->back.i);
 
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_MATTE);
+  CHK(mtl->type == SOLPARSER_MATERIAL_MATTE);
   matte = solparser_get_material_matte(parser, mtl->data.matte);
-  CHECK(matte->reflectivity.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(matte->reflectivity.value.real, 0.123);
-  CHECK(SOLPARSER_ID_IS_VALID(matte->normal_map), 1);
+  CHK(matte->reflectivity.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(matte->reflectivity.value.real == 0.123);
+  CHK(SOLPARSER_ID_IS_VALID(matte->normal_map) == 1);
   img = solparser_get_image(parser, matte->normal_map);
-  CHECK(strcmp(str_cget(&img->filename), "path to normal map"), 0);
+  CHK(strcmp(str_cget(&img->filename), "path to normal map") == 0);
 
   solparser_entity_iterator_next(&it);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 1);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 1);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   fclose(stream);
 }
 
@@ -182,7 +182,7 @@ test_mirror(struct solparser* parser)
   FILE* stream;
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
 
   fprintf(stream, "- sun: { dni: 1, spectrum: [{wavelength: 1, data: 1} ] }\n");
   fprintf(stream, "- entity: \n");
@@ -197,44 +197,44 @@ test_mirror(struct solparser* parser)
   fprintf(stream, "            normal_map: { path: Normal map } \n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &end);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 0);
 
   entity_id = solparser_entity_iterator_get(&it);
   entity = solparser_get_entity(parser, entity_id);
 
-  CHECK(strcmp("my_entity",  str_cget(&entity->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity), 0);
-  CHECK(entity->primary, 0);
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
+  CHK(strcmp("my_entity",  str_cget(&entity->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity) == 0);
+  CHK(entity->primary == 0);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
   geom = solparser_get_geometry(parser, entity->data.geometry);
-  CHECK(solparser_geometry_get_objects_count(geom), 1);
+  CHK(solparser_geometry_get_objects_count(geom) == 1);
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_CUBOID);
+  CHK(shape->type == SOLPARSER_SHAPE_CUBOID);
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  CHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i == mtl2->back.i);
 
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_MIRROR);
+  CHK(mtl->type == SOLPARSER_MATERIAL_MIRROR);
   mirror = solparser_get_material_mirror(parser, mtl->data.mirror);
-  CHECK(mirror->reflectivity.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(mirror->reflectivity.value.real, 1);
-  CHECK(mirror->roughness.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(mirror->roughness.value.real, 0.1);
-  CHECK(SOLPARSER_ID_IS_VALID(mirror->normal_map), 1);
+  CHK(mirror->reflectivity.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(mirror->reflectivity.value.real == 1);
+  CHK(mirror->roughness.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(mirror->roughness.value.real == 0.1);
+  CHK(SOLPARSER_ID_IS_VALID(mirror->normal_map) == 1);
   img = solparser_get_image(parser, mirror->normal_map);
-  CHECK(strcmp(str_cget(&img->filename), "Normal map"), 0);
+  CHK(strcmp(str_cget(&img->filename), "Normal map") == 0);
 
   solparser_entity_iterator_next(&it);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 1);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 1);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   fclose(stream);
 }
 
@@ -255,7 +255,7 @@ test_thin_dielectric(struct solparser* parser)
   FILE* stream;
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
   fprintf(stream, "- sun: { dni: 1, spectrum: [{wavelength: 1, data: 1} ] }\n");
   fprintf(stream, "- entity:\n");
   fprintf(stream, "    name: test\n");
@@ -274,42 +274,42 @@ test_thin_dielectric(struct solparser* parser)
   fprintf(stream, "            normal_map: { path: Bump }\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_entity_iterator_begin(parser, &it);
   solparser_entity_iterator_end(parser, &end);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 0);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 0);
 
   entity_id = solparser_entity_iterator_get(&it);
   entity = solparser_get_entity(parser, entity_id);
 
-  CHECK(strcmp("test",  str_cget(&entity->name)), 0);
-  CHECK(solparser_entity_get_children_count(entity), 0);
-  CHECK(entity->primary, 0);
-  CHECK(entity->type, SOLPARSER_ENTITY_GEOMETRY);
+  CHK(strcmp("test",  str_cget(&entity->name)) == 0);
+  CHK(solparser_entity_get_children_count(entity) == 0);
+  CHK(entity->primary == 0);
+  CHK(entity->type == SOLPARSER_ENTITY_GEOMETRY);
   geom = solparser_get_geometry(parser, entity->data.geometry);
-  CHECK(solparser_geometry_get_objects_count(geom), 1);
+  CHK(solparser_geometry_get_objects_count(geom) == 1);
   obj_id = solparser_geometry_get_object(geom, 0);
   obj = solparser_get_object(parser, obj_id);
   shape = solparser_get_shape(parser, obj->shape);
-  CHECK(shape->type, SOLPARSER_SHAPE_SPHERE);
+  CHK(shape->type == SOLPARSER_SHAPE_SPHERE);
   mtl2 = solparser_get_material_double_sided(parser, obj->mtl2);
-  CHECK(mtl2->front.i, mtl2->back.i);
+  CHK(mtl2->front.i == mtl2->back.i);
 
   mtl = solparser_get_material(parser, mtl2->front);
-  CHECK(mtl->type, SOLPARSER_MATERIAL_THIN_DIELECTRIC);
+  CHK(mtl->type == SOLPARSER_MATERIAL_THIN_DIELECTRIC);
   thin = solparser_get_material_thin_dielectric(parser, mtl->data.thin_dielectric);
-  CHECK(thin->thickness, 0.1);
-  NCHECK(thin->medium_i.i, thin->medium_t.i);
-  CHECK(SOLPARSER_ID_IS_VALID(thin->normal_map), 1);
+  CHK(thin->thickness == 0.1);
+  CHK(thin->medium_i.i != thin->medium_t.i);
+  CHK(SOLPARSER_ID_IS_VALID(thin->normal_map) == 1);
   img = solparser_get_image(parser, thin->normal_map);
-  CHECK(strcmp(str_cget(&img->filename), "Bump"), 0);
+  CHK(strcmp(str_cget(&img->filename), "Bump") == 0);
 
   solparser_entity_iterator_next(&it);
-  CHECK(solparser_entity_iterator_eq(&it, &end), 1);
+  CHK(solparser_entity_iterator_eq(&it, &end) == 1);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   fclose(stream);
 }
 
@@ -320,8 +320,8 @@ main(int argc, char** argv)
   struct solparser* parser;
   (void)argc, (void)argv;
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
-  CHECK(solparser_create(&allocator, &parser), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
+  CHK(solparser_create(&allocator, &parser) == RES_OK);
 
   test_dielectric(parser);
   test_matte(parser);
@@ -332,7 +332,7 @@ main(int argc, char** argv)
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
 
diff --git a/src/parser/test_solparser_spectrum.c b/src/parser/test_solparser_spectrum.c
@@ -25,7 +25,7 @@ test_sun(struct solparser* parser)
   FILE* stream;
   size_t i;
 
-  NCHECK(stream = tmpfile(), NULL);
+  CHK((stream = tmpfile()) != NULL);
 
   fprintf(stream, "- spectrum: &my_spectrum\n");
   fprintf(stream, "  - { wavelength: 2, data: 2 }\n");
@@ -47,35 +47,35 @@ test_sun(struct solparser* parser)
   fprintf(stream, "    geometry: [{sphere: {radius: 1}, material: *matte}]\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   sun = solparser_get_sun(parser);
-  CHECK(sun->dni, 123.456);
-  CHECK(sun->radang_distrib_type, SOLPARSER_SUN_RADANG_DISTRIB_DIRECTIONAL);
-  CHECK(SOLPARSER_ID_IS_VALID(sun->spectrum), 1);
+  CHK(sun->dni == 123.456);
+  CHK(sun->radang_distrib_type == SOLPARSER_SUN_RADANG_DISTRIB_DIRECTIONAL);
+  CHK(SOLPARSER_ID_IS_VALID(sun->spectrum) == 1);
   spectrum = solparser_get_spectrum(parser, sun->spectrum);
 
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 9);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 9);
 
   FOR_EACH(i, 0, darray_spectrum_data_size_get(&spectrum->data)) {
-    CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[i].wavelength, i+1);
-    CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[i].wavelength, i+1);
+    CHK(darray_spectrum_data_cdata_get(&spectrum->data)[i].wavelength == i+1);
+    CHK(darray_spectrum_data_cdata_get(&spectrum->data)[i].wavelength == i+1);
   }
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   fclose(stream);
 
-  NCHECK(stream = tmpfile(), NULL);
+  CHK((stream = tmpfile()) != NULL);
   fprintf(stream, "- sun: {dni: 1}\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
-  CHECK(SOLPARSER_ID_IS_VALID(sun->spectrum), 0);
+  CHK(SOLPARSER_ID_IS_VALID(sun->spectrum) == 0);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   fclose(stream);
 }
 
@@ -88,7 +88,7 @@ test_matte(struct solparser* parser)
   const struct solparser_spectrum* spectrum;
   FILE* stream;
 
-  NCHECK(stream = tmpfile(), NULL);
+  CHK((stream = tmpfile()) != NULL);
 
   fprintf(stream, "- sun: { dni: 1 }\n");
   fprintf(stream, "- material:\n");
@@ -99,31 +99,31 @@ test_matte(struct solparser* parser)
   fprintf(stream, "      - { wavelength: 6.7, data: 0.125 }\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_material_iterator_begin(parser, &mtl_it);
   solparser_material_iterator_end(parser, &mtl_it_end);
-  CHECK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end), 0);
+  CHK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end) == 0);
 
   mtl = solparser_get_material(parser, solparser_material_iterator_get(&mtl_it));
-  CHECK(mtl->type, SOLPARSER_MATERIAL_MATTE);
+  CHK(mtl->type == SOLPARSER_MATERIAL_MATTE);
   matte = solparser_get_material_matte(parser, mtl->data.matte);
-  CHECK(matte->reflectivity.type, SOLPARSER_MTL_DATA_SPECTRUM);
-  CHECK(SOLPARSER_ID_IS_VALID(matte->normal_map), 0);
+  CHK(matte->reflectivity.type == SOLPARSER_MTL_DATA_SPECTRUM);
+  CHK(SOLPARSER_ID_IS_VALID(matte->normal_map) == 0);
   spectrum = solparser_get_spectrum(parser, matte->reflectivity.value.spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 3);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 1.2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength, 3.4);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength, 6.7);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 0.25);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data, 0.5);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data, 0.125);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 3);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 1.2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength == 3.4);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength == 6.7);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 0.25);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data == 0.5);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data == 0.125);
 
   solparser_material_iterator_next(&mtl_it);
-  CHECK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end), 1);
+  CHK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end) == 1);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   fclose(stream);
 }
 
@@ -136,7 +136,7 @@ test_mirror(struct solparser* parser)
   const struct solparser_spectrum* spectrum;
   FILE* stream;
 
-  NCHECK(stream = tmpfile(), NULL);
+  CHK((stream = tmpfile()) != NULL);
 
   fprintf(stream, "- sun: { dni: 1 }\n");
   fprintf(stream, "- material:\n");
@@ -150,40 +150,40 @@ test_mirror(struct solparser* parser)
   fprintf(stream, "      - { wavelength: 456, data: 1 }\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_material_iterator_begin(parser, &mtl_it);
   solparser_material_iterator_end(parser, &mtl_it_end);
-  CHECK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end), 0);
+  CHK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end) == 0);
 
   mtl = solparser_get_material(parser, solparser_material_iterator_get(&mtl_it));
-  CHECK(mtl->type, SOLPARSER_MATERIAL_MIRROR);
+  CHK(mtl->type == SOLPARSER_MATERIAL_MIRROR);
   mirror = solparser_get_material_mirror(parser, mtl->data.mirror);
-  CHECK(mirror->reflectivity.type, SOLPARSER_MTL_DATA_SPECTRUM);
-  CHECK(mirror->roughness.type, SOLPARSER_MTL_DATA_SPECTRUM);
-  CHECK(SOLPARSER_ID_IS_VALID(mirror->normal_map), 0);
+  CHK(mirror->reflectivity.type == SOLPARSER_MTL_DATA_SPECTRUM);
+  CHK(mirror->roughness.type == SOLPARSER_MTL_DATA_SPECTRUM);
+  CHK(SOLPARSER_ID_IS_VALID(mirror->normal_map) == 0);
 
   spectrum = solparser_get_spectrum(parser, mirror->reflectivity.value.spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 3);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 1.2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength, 3.4);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength, 6.7);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 0.25);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data, 0.5);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data, 0.125);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 3);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 1.2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength == 3.4);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength == 6.7);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 0.25);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data == 0.5);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data == 0.125);
 
   spectrum = solparser_get_spectrum(parser, mirror->roughness.value.spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 123);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength, 456);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 0);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data, 1);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 123);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength == 456);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 0);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data == 1);
 
   solparser_material_iterator_next(&mtl_it);
-  CHECK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end), 1);
+  CHK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end) == 1);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   fclose(stream);
 }
 
@@ -197,7 +197,7 @@ test_thin_dielectric(struct solparser* parser)
   const struct solparser_spectrum* spectrum;
   FILE* stream;
 
-  NCHECK(stream = tmpfile(), NULL);
+  CHK((stream = tmpfile()) != NULL);
 
   fprintf(stream, "- sun: { dni: 1 }\n");
   fprintf(stream, "- spectrum: &refractive_index\n");
@@ -216,46 +216,46 @@ test_thin_dielectric(struct solparser* parser)
   fprintf(stream, "        extinction: *absorption\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_material_iterator_begin(parser, &mtl_it);
   solparser_material_iterator_end(parser, &mtl_it_end);
-  CHECK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end), 0);
+  CHK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end) == 0);
 
   mtl = solparser_get_material(parser, solparser_material_iterator_get(&mtl_it));
-  CHECK(mtl->type, SOLPARSER_MATERIAL_THIN_DIELECTRIC);
+  CHK(mtl->type == SOLPARSER_MATERIAL_THIN_DIELECTRIC);
   thin = solparser_get_material_thin_dielectric(parser, mtl->data.thin_dielectric);
-  CHECK(thin->thickness, 1);
-  CHECK(SOLPARSER_ID_IS_VALID(thin->normal_map), 0);
+  CHK(thin->thickness == 1);
+  CHK(SOLPARSER_ID_IS_VALID(thin->normal_map) == 0);
 
   mdm = solparser_get_medium(parser, thin->medium_i);
-  CHECK(mdm->refractive_index.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(mdm->refractive_index.value.real, 1);
-  CHECK(mdm->extinction.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(mdm->extinction.value.real, 0);
+  CHK(mdm->refractive_index.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(mdm->refractive_index.value.real == 1);
+  CHK(mdm->extinction.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(mdm->extinction.value.real == 0);
 
   mdm = solparser_get_medium(parser, thin->medium_t);
-  CHECK(mdm->refractive_index.type, SOLPARSER_MTL_DATA_SPECTRUM);
+  CHK(mdm->refractive_index.type == SOLPARSER_MTL_DATA_SPECTRUM);
   spectrum = solparser_get_spectrum(parser, mdm->refractive_index.value.spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 3);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 123);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength, 456);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength, 789);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 1.1);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data, 2.2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data, 3.3);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 3);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 123);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength == 456);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength == 789);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 1.1);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data == 2.2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data == 3.3);
   spectrum = solparser_get_spectrum(parser, mdm->extinction.value.spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 0.123);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength, 0.456);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 0.1);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data, 0.2);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 0.123);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength == 0.456);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 0.1);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data == 0.2);
 
   solparser_material_iterator_next(&mtl_it);
-  CHECK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end), 1);
+  CHK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end) == 1);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   fclose(stream);
 }
 
@@ -269,7 +269,7 @@ test_dielectric(struct solparser* parser)
   const struct solparser_spectrum* spectrum;
   FILE* stream;
 
-  NCHECK(stream = tmpfile(), NULL);
+  CHK((stream = tmpfile()) != NULL);
 
   fprintf(stream, "- sun: { dni: 1 }\n");
   fprintf(stream, "- spectrum: &refractive_index\n");
@@ -287,45 +287,45 @@ test_dielectric(struct solparser* parser)
   fprintf(stream, "        extinction: *absorption\n");
   rewind(stream);
 
-  CHECK(solparser_setup(parser, NULL, stream), RES_OK);
-  CHECK(solparser_load(parser), RES_OK);
+  CHK(solparser_setup(parser, NULL, stream) == RES_OK);
+  CHK(solparser_load(parser) == RES_OK);
 
   solparser_material_iterator_begin(parser, &mtl_it);
   solparser_material_iterator_end(parser, &mtl_it_end);
-  CHECK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end), 0);
+  CHK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end) == 0);
 
   mtl = solparser_get_material(parser, solparser_material_iterator_get(&mtl_it));
-  CHECK(mtl->type, SOLPARSER_MATERIAL_DIELECTRIC);
+  CHK(mtl->type == SOLPARSER_MATERIAL_DIELECTRIC);
   dielec = solparser_get_material_dielectric(parser, mtl->data.dielectric);
-  CHECK(SOLPARSER_ID_IS_VALID(dielec->normal_map), 0);
+  CHK(SOLPARSER_ID_IS_VALID(dielec->normal_map) == 0);
 
   mdm = solparser_get_medium(parser, dielec->medium_i);
-  CHECK(mdm->refractive_index.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(mdm->refractive_index.value.real, 1);
-  CHECK(mdm->extinction.type, SOLPARSER_MTL_DATA_REAL);
-  CHECK(mdm->extinction.value.real, 0);
+  CHK(mdm->refractive_index.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(mdm->refractive_index.value.real == 1);
+  CHK(mdm->extinction.type == SOLPARSER_MTL_DATA_REAL);
+  CHK(mdm->extinction.value.real == 0);
 
   mdm = solparser_get_medium(parser, dielec->medium_t);
-  CHECK(mdm->refractive_index.type, SOLPARSER_MTL_DATA_SPECTRUM);
+  CHK(mdm->refractive_index.type == SOLPARSER_MTL_DATA_SPECTRUM);
   spectrum = solparser_get_spectrum(parser, mdm->refractive_index.value.spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 3);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 123);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength, 456);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength, 789);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 1.1);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data, 2.2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data, 3.3);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 3);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 123);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength == 456);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].wavelength == 789);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 1.1);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data == 2.2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[2].data == 3.3);
   spectrum = solparser_get_spectrum(parser, mdm->extinction.value.spectrum);
-  CHECK(darray_spectrum_data_size_get(&spectrum->data), 2);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength, 0.123);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength, 0.456);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data, 0.1);
-  CHECK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data, 0.2);
+  CHK(darray_spectrum_data_size_get(&spectrum->data) == 2);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].wavelength == 0.123);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].wavelength == 0.456);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[0].data == 0.1);
+  CHK(darray_spectrum_data_cdata_get(&spectrum->data)[1].data == 0.2);
 
   solparser_material_iterator_next(&mtl_it);
-  CHECK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end), 1);
+  CHK(solparser_material_iterator_eq(&mtl_it, &mtl_it_end) == 1);
 
-  CHECK(solparser_load(parser), RES_BAD_OP);
+  CHK(solparser_load(parser) == RES_BAD_OP);
   fclose(stream);
 }
 
@@ -336,8 +336,8 @@ main(int argc, char** argv)
   struct solparser* parser;
   (void)argc, (void)argv;
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
-  CHECK(solparser_create(&allocator, &parser), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
+  CHK(solparser_create(&allocator, &parser) == RES_OK);
 
   test_sun(parser);
   test_matte(parser);
@@ -349,7 +349,7 @@ main(int argc, char** argv)
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
 
diff --git a/src/receivers/test_srcvl.c b/src/receivers/test_srcvl.c
@@ -44,26 +44,26 @@ main(int argc, char** argv)
     }
   }
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
   srcvl_create(&allocator, &srcvl);
 
-  CHECK(srcvl_setup_stream(srcvl, NULL, tmpfile()), RES_OK);
-  CHECK(srcvl_setup_stream(srcvl, "yop", tmpfile()), RES_OK);
-  CHECK(srcvl_load(srcvl), RES_BAD_OP); /* Empty stream */
+  CHK(srcvl_setup_stream(srcvl, NULL, tmpfile()) == RES_OK);
+  CHK(srcvl_setup_stream(srcvl, "yop", tmpfile()) == RES_OK);
+  CHK(srcvl_load(srcvl) == RES_BAD_OP); /* Empty stream */
 
   FOR_EACH(i, ifile, argc) {
     FILE* file = fopen(argv[i], "rb");
     int count = 0;
-    NCHECK(file, NULL);
-    CHECK(srcvl_setup_stream(srcvl, argv[i], file), RES_OK);
+    CHK(file != NULL);
+    CHK(srcvl_setup_stream(srcvl, argv[i], file) == RES_OK);
     for(;;) {
       const res_T res = srcvl_load(srcvl);
       if(count == 0 && load_res == RES_OK) {
-        CHECK(res, RES_OK);
+        CHK(res == RES_OK);
       } else if(res == RES_BAD_OP) {
         break;
       }
-      CHECK(res, load_res);
+      CHK(res == load_res);
       ++count;
     }
     fclose(file);
@@ -74,7 +74,7 @@ main(int argc, char** argv)
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
 
diff --git a/src/receivers/test_srcvl2.c b/src/receivers/test_srcvl2.c
@@ -28,11 +28,11 @@ main(int argc, char** argv)
   int seek;
   (void)argc, (void)argv;
 
-  CHECK(mem_init_proxy_allocator(&allocator, &mem_default_allocator), RES_OK);
+  CHK(mem_init_proxy_allocator(&allocator, &mem_default_allocator) == RES_OK);
   srcvl_create(&allocator, &srcvl);
 
   stream = tmpfile();
-  NCHECK(stream, NULL);
+  CHK(stream != NULL);
   fprintf(stream, "- { name: entity0 }\n");
   fprintf(stream, "- { name: \"entity1\" }\n");
   fprintf(stream, "- { name: entity2, side: FRONT }\n");
@@ -43,69 +43,69 @@ main(int argc, char** argv)
   fprintf(stream, "- { name: entity6, per_primitive: 0, side: FRONT }\n");
   rewind(stream);
 
-  CHECK(srcvl_setup_stream(srcvl, NULL, stream), RES_OK);
-  CHECK(srcvl_load(srcvl), RES_OK);
-  CHECK(srcvl_count(srcvl), 7);
+  CHK(srcvl_setup_stream(srcvl, NULL, stream) == RES_OK);
+  CHK(srcvl_load(srcvl) == RES_OK);
+  CHK(srcvl_count(srcvl) == 7);
 
   srcvl_get(srcvl, 0, &receiver);
-  CHECK(strcmp(receiver.name, "entity0"), 0);
-  CHECK(receiver.side, SRCVL_FRONT_AND_BACK);
-  CHECK(receiver.per_primitive, 0);
+  CHK(strcmp(receiver.name, "entity0") == 0);
+  CHK(receiver.side == SRCVL_FRONT_AND_BACK);
+  CHK(receiver.per_primitive == 0);
 
   srcvl_get(srcvl, 1, &receiver);
-  CHECK(strcmp(receiver.name, "entity1"), 0);
-  CHECK(receiver.side, SRCVL_FRONT_AND_BACK);
-  CHECK(receiver.per_primitive, 0);
+  CHK(strcmp(receiver.name, "entity1") == 0);
+  CHK(receiver.side == SRCVL_FRONT_AND_BACK);
+  CHK(receiver.per_primitive == 0);
 
   srcvl_get(srcvl, 2, &receiver);
-  CHECK(strcmp(receiver.name, "entity2"), 0);
-  CHECK(receiver.side, SRCVL_FRONT);
-  CHECK(receiver.per_primitive, 0);
+  CHK(strcmp(receiver.name, "entity2") == 0);
+  CHK(receiver.side == SRCVL_FRONT);
+  CHK(receiver.per_primitive == 0);
 
   srcvl_get(srcvl, 3, &receiver);
-  CHECK(strcmp(receiver.name, "entity3"), 0);
-  CHECK(receiver.side, SRCVL_BACK);
-  CHECK(receiver.per_primitive, 0);
+  CHK(strcmp(receiver.name, "entity3") == 0);
+  CHK(receiver.side == SRCVL_BACK);
+  CHK(receiver.per_primitive == 0);
 
   srcvl_get(srcvl, 4, &receiver);
-  CHECK(strcmp(receiver.name, "entity4"), 0);
-  CHECK(receiver.side, SRCVL_FRONT_AND_BACK);
-  CHECK(receiver.per_primitive, 0);
+  CHK(strcmp(receiver.name, "entity4") == 0);
+  CHK(receiver.side == SRCVL_FRONT_AND_BACK);
+  CHK(receiver.per_primitive == 0);
 
   srcvl_get(srcvl, 5, &receiver);
-  CHECK(strcmp(receiver.name, "entity5"), 0);
-  CHECK(receiver.side, SRCVL_BACK);
-  CHECK(receiver.per_primitive, 1);
+  CHK(strcmp(receiver.name, "entity5") == 0);
+  CHK(receiver.side == SRCVL_BACK);
+  CHK(receiver.per_primitive == 1);
 
   srcvl_get(srcvl, 6, &receiver);
-  CHECK(strcmp(receiver.name, "entity6"), 0);
-  CHECK(receiver.side, SRCVL_FRONT);
-  CHECK(receiver.per_primitive, 0);
+  CHK(strcmp(receiver.name, "entity6") == 0);
+  CHK(receiver.side == SRCVL_FRONT);
+  CHK(receiver.per_primitive == 0);
 
-  CHECK(srcvl_load(srcvl), RES_BAD_OP);
+  CHK(srcvl_load(srcvl) == RES_BAD_OP);
 
   seek = (int)ftell(stream);
   fprintf(stream, "---\n");
   fprintf(stream, "[{name: test 0, side: FRONT}, {name: test 1, side: BACK}]\n");
   fseek(stream, seek, SEEK_SET);
 
-  CHECK(srcvl_setup_stream(srcvl, NULL, stream), RES_OK);
-  CHECK(srcvl_load(srcvl), RES_OK);
-  CHECK(srcvl_count(srcvl), 2);
+  CHK(srcvl_setup_stream(srcvl, NULL, stream) == RES_OK);
+  CHK(srcvl_load(srcvl) == RES_OK);
+  CHK(srcvl_count(srcvl) == 2);
 
   srcvl_get(srcvl, 0, &receiver);
-  CHECK(strcmp(receiver.name, "test 0"), 0);
-  CHECK(receiver.side, SRCVL_FRONT);
+  CHK(strcmp(receiver.name, "test 0") == 0);
+  CHK(receiver.side == SRCVL_FRONT);
 
   srcvl_get(srcvl, 1, &receiver);
-  CHECK(strcmp(receiver.name, "test 1"), 0);
-  CHECK(receiver.side, SRCVL_BACK);
+  CHK(strcmp(receiver.name, "test 1") == 0);
+  CHK(receiver.side == SRCVL_BACK);
 
   fclose(stream);
   srcvl_ref_put(srcvl);
 
   check_memory_allocator(&allocator);
   mem_shutdown_proxy_allocator(&allocator);
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
diff --git a/src/solstice.c b/src/solstice.c
@@ -560,10 +560,10 @@ exit:
 error:
   res = RES_IO_ERR;
   if(fp) {
-    CHECK(fclose(fp), 0);
+    CHK(fclose(fp) == 0);
     fp = NULL;
   } else if(fd >= 0) {
-    CHECK(close(fd), 0);
+    CHK(close(fd) == 0);
   }
   goto exit;
 }
diff --git a/src/solstice_solve.c b/src/solstice_solve.c
@@ -337,7 +337,7 @@ write_per_receiver_mc_primitive
     htable_receiver_iterator_next(&it);
 
     SSOL(instance_is_receiver(inst, &mask, &prim));
-    NCHECK(mask, 0);
+    CHK(mask != 0);
     if(!prim) continue;
 
     SSOL(instance_get_shaded_shapes_count(inst, &nshapes));
diff --git a/src/test_solstice_args.c b/src/test_solstice_args.c
@@ -42,11 +42,11 @@ cmd_create(int dummy, ...)
   while((str = va_arg(ap, const char*))) ++n;
   va_end(ap);
 
-  NCHECK(cmd = sa_add(cmd, n), NULL);
+  CHK((cmd = sa_add(cmd, n)) != NULL);
   i = 0;
   while((str = va_arg(ap_cp, const char*))) {
     cmd[i] = NULL;
-    NCHECK(cmd[i] = sa_add(cmd[i], strlen(str)+1), NULL);
+    CHK((cmd[i] = sa_add(cmd[i], strlen(str)+1)) != NULL);
     strcpy(cmd[i], str);
     ++i;
   }
@@ -81,156 +81,156 @@ test_rendering(void)
   double tmp[3];
 
   cmd = cmd_create(0, "test", "-r", "img=1280x720", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.rendering, 1);
-  CHECK(args.nexperiments, SOLSTICE_ARGS_DEFAULT.nexperiments);
-  CHECK(d3_eq(args.camera.pos, SOLSTICE_ARGS_DEFAULT.camera.pos), 1);
-  CHECK(d3_eq(args.camera.tgt, SOLSTICE_ARGS_DEFAULT.camera.tgt), 1);
-  CHECK(d3_eq(args.camera.up, SOLSTICE_ARGS_DEFAULT.camera.up), 1);
-  CHECK(args.camera.fov_x, SOLSTICE_ARGS_DEFAULT.camera.fov_x);
-  CHECK(args.img.width, 1280);
-  CHECK(args.img.height, 720);
-  CHECK(args.img.spp, SOLSTICE_ARGS_DEFAULT.img.spp);
-  CHECK(args.render_mode, SOLSTICE_ARGS_DEFAULT.render_mode);
-  CHECK(args.quiet, 0);
-  CHECK(args.output_filename, NULL);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.rendering == 1);
+  CHK(args.nexperiments == SOLSTICE_ARGS_DEFAULT.nexperiments);
+  CHK(d3_eq(args.camera.pos, SOLSTICE_ARGS_DEFAULT.camera.pos) == 1);
+  CHK(d3_eq(args.camera.tgt, SOLSTICE_ARGS_DEFAULT.camera.tgt) == 1);
+  CHK(d3_eq(args.camera.up, SOLSTICE_ARGS_DEFAULT.camera.up) == 1);
+  CHK(args.camera.fov_x == SOLSTICE_ARGS_DEFAULT.camera.fov_x);
+  CHK(args.img.width == 1280);
+  CHK(args.img.height == 720);
+  CHK(args.img.spp == SOLSTICE_ARGS_DEFAULT.img.spp);
+  CHK(args.render_mode == SOLSTICE_ARGS_DEFAULT.render_mode);
+  CHK(args.quiet == 0);
+  CHK(args.output_filename == NULL);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-q", "-r", "img=640x480:fov=70:pos=1,2,3", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.rendering, 1);
-  CHECK(args.nexperiments, SOLSTICE_ARGS_DEFAULT.nexperiments);
-  CHECK(d3_eq(args.camera.pos, d3(tmp, 1, 2, 3)), 1);
-  CHECK(d3_eq(args.camera.tgt, SOLSTICE_ARGS_DEFAULT.camera.tgt), 1);
-  CHECK(d3_eq(args.camera.up, SOLSTICE_ARGS_DEFAULT.camera.up), 1);
-  CHECK(args.img.width, 640);
-  CHECK(args.img.height, 480);
-  CHECK(args.img.spp, SOLSTICE_ARGS_DEFAULT.img.spp);
-  CHECK(args.render_mode, SOLSTICE_ARGS_DEFAULT.render_mode);
-  CHECK(args.quiet, 1);
-  CHECK(eq_eps(args.camera.fov_x, 70, 1.e-6), 1);
-  CHECK(args.output_filename, NULL);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.rendering == 1);
+  CHK(args.nexperiments == SOLSTICE_ARGS_DEFAULT.nexperiments);
+  CHK(d3_eq(args.camera.pos, d3(tmp, 1, 2, 3)) == 1);
+  CHK(d3_eq(args.camera.tgt, SOLSTICE_ARGS_DEFAULT.camera.tgt) == 1);
+  CHK(d3_eq(args.camera.up, SOLSTICE_ARGS_DEFAULT.camera.up) == 1);
+  CHK(args.img.width == 640);
+  CHK(args.img.height == 480);
+  CHK(args.img.spp == SOLSTICE_ARGS_DEFAULT.img.spp);
+  CHK(args.render_mode == SOLSTICE_ARGS_DEFAULT.render_mode);
+  CHK(args.quiet == 1);
+  CHK(eq_eps(args.camera.fov_x, 70, 1.e-6) == 1);
+  CHK(args.output_filename == NULL);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "up=0,0,1:tgt=0,-10,0:rmode=draft", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nexperiments, SOLSTICE_ARGS_DEFAULT.nexperiments);
-  CHECK(d3_eq(args.camera.pos, SOLSTICE_ARGS_DEFAULT.camera.pos), 1);
-  CHECK(d3_eq(args.camera.tgt, d3(tmp, 0,-10, 0)), 1);
-  CHECK(d3_eq(args.camera.up, d3(tmp, 0, 0, 1)), 1);
-  CHECK(args.img.width, SOLSTICE_ARGS_DEFAULT.img.width);
-  CHECK(args.img.height, SOLSTICE_ARGS_DEFAULT.img.height);
-  CHECK(args.img.spp, SOLSTICE_ARGS_DEFAULT.img.spp);
-  CHECK(args.render_mode, SOLSTICE_ARGS_RENDER_DRAFT);
-  CHECK(args.rendering, 1);
-  CHECK(args.quiet, 0);
-  CHECK(args.output_filename, NULL);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nexperiments == SOLSTICE_ARGS_DEFAULT.nexperiments);
+  CHK(d3_eq(args.camera.pos, SOLSTICE_ARGS_DEFAULT.camera.pos) == 1);
+  CHK(d3_eq(args.camera.tgt, d3(tmp, 0,-10, 0)) == 1);
+  CHK(d3_eq(args.camera.up, d3(tmp, 0, 0, 1)) == 1);
+  CHK(args.img.width == SOLSTICE_ARGS_DEFAULT.img.width);
+  CHK(args.img.height == SOLSTICE_ARGS_DEFAULT.img.height);
+  CHK(args.img.spp == SOLSTICE_ARGS_DEFAULT.img.spp);
+  CHK(args.render_mode == SOLSTICE_ARGS_RENDER_DRAFT);
+  CHK(args.rendering == 1);
+  CHK(args.quiet == 0);
+  CHK(args.output_filename == NULL);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "up=0,0,1:rmode=pt:spp=4", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nexperiments, SOLSTICE_ARGS_DEFAULT.nexperiments);
-  CHECK(d3_eq(args.camera.up, d3(tmp, 0, 0, 1)), 1);
-  CHECK(args.img.width, SOLSTICE_ARGS_DEFAULT.img.width);
-  CHECK(args.img.height, SOLSTICE_ARGS_DEFAULT.img.height);
-  CHECK(args.rendering, 1);
-  CHECK(args.output_filename, NULL);
-  CHECK(args.img.spp, 4);
-  CHECK(args.render_mode, SOLSTICE_ARGS_RENDER_PATH_TRACING);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nexperiments == SOLSTICE_ARGS_DEFAULT.nexperiments);
+  CHK(d3_eq(args.camera.up, d3(tmp, 0, 0, 1)) == 1);
+  CHK(args.img.width == SOLSTICE_ARGS_DEFAULT.img.width);
+  CHK(args.img.height == SOLSTICE_ARGS_DEFAULT.img.height);
+  CHK(args.rendering == 1);
+  CHK(args.output_filename == NULL);
+  CHK(args.img.spp == 4);
+  CHK(args.render_mode == SOLSTICE_ARGS_RENDER_PATH_TRACING);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "up=0,10,0", "-o", "my_output", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(d3_eq(args.camera.up, d3(tmp, 0, 10, 0)), 1);
-  CHECK(args.rendering, 1);
-  CHECK(args.quiet, 0);
-  CHECK(strcmp(args.output_filename, "my_output"),  0);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(d3_eq(args.camera.up, d3(tmp, 0, 10, 0)) == 1);
+  CHK(args.rendering == 1);
+  CHK(args.quiet == 0);
+  CHK(strcmp(args.output_filename, "my_output") ==  0);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "spp=16", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.img.spp, 16);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.img.spp == 16);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "rmode=none", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "rmode", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
 
   cmd = cmd_create(0, "test", "-r", "up=0,1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "tgt=0:1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "pos=0,10,1a", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "pos=0,10,1:::::", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(d3_eq(args.camera.pos, d3(tmp, 0, 10, 1)), 1);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(d3_eq(args.camera.pos, d3(tmp, 0, 10, 1)) == 1);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "spp=0", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "img=32X32", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "img=32x32@12", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "img=0x64", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "img=64x0", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "img=32x32@12:up=0,0,1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "tgt=1,1,1:img=32x32:12", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "fov=123a", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "up", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "img=", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "fov::::", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-r", "::tgt", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 }
 
@@ -241,69 +241,69 @@ test_sun_dirs(void)
   char** cmd = NULL;
 
   cmd = cmd_create(0, "test", "-D", "0,1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nsun_dirs, 1);
-  CHECK(args.sun_dirs[0].azimuth, 0);
-  CHECK(eq_eps(args.sun_dirs[0].elevation, 1, 1.e-6), 1);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nsun_dirs == 1);
+  CHK(args.sun_dirs[0].azimuth == 0);
+  CHK(eq_eps(args.sun_dirs[0].elevation, 1, 1.e-6) == 1);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "1.2,3.4:3.14,0.123:", RES_OK);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nsun_dirs, 2);
-  CHECK(eq_eps(args.sun_dirs[0].azimuth, 1.2, 1.e-6), 1);
-  CHECK(eq_eps(args.sun_dirs[0].elevation, 3.4, 1.e-6), 1);
-  CHECK(eq_eps(args.sun_dirs[1].azimuth, 3.14, 1.e-6), 1);
-  CHECK(eq_eps(args.sun_dirs[1].elevation, 0.123, 1.e-6), 1);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nsun_dirs == 2);
+  CHK(eq_eps(args.sun_dirs[0].azimuth, 1.2, 1.e-6) == 1);
+  CHK(eq_eps(args.sun_dirs[0].elevation, 3.4, 1.e-6) == 1);
+  CHK(eq_eps(args.sun_dirs[1].azimuth, 3.14, 1.e-6) == 1);
+  CHK(eq_eps(args.sun_dirs[1].elevation, 0.123, 1.e-6) == 1);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "1.2,3.4:3.14,0.123:2.01,23.1", RES_OK);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nsun_dirs, 3);
-  CHECK(eq_eps(args.sun_dirs[0].azimuth, 1.2, 1.e-6), 1);
-  CHECK(eq_eps(args.sun_dirs[0].elevation, 3.4, 1.e-6), 1);
-  CHECK(eq_eps(args.sun_dirs[1].azimuth, 3.14, 1.e-6), 1);
-  CHECK(eq_eps(args.sun_dirs[1].elevation, 0.123, 1.e-6), 1);
-  CHECK(eq_eps(args.sun_dirs[2].azimuth, 2.01, 1.e-6), 1);
-  CHECK(eq_eps(args.sun_dirs[2].elevation, 23.1, 1.e-6), 1);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nsun_dirs == 3);
+  CHK(eq_eps(args.sun_dirs[0].azimuth, 1.2, 1.e-6) == 1);
+  CHK(eq_eps(args.sun_dirs[0].elevation, 3.4, 1.e-6) == 1);
+  CHK(eq_eps(args.sun_dirs[1].azimuth, 3.14, 1.e-6) == 1);
+  CHK(eq_eps(args.sun_dirs[1].elevation, 0.123, 1.e-6) == 1);
+  CHK(eq_eps(args.sun_dirs[2].azimuth, 2.01, 1.e-6) == 1);
+  CHK(eq_eps(args.sun_dirs[2].elevation, 23.1, 1.e-6) == 1);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "1.2,3.4,5", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "1.2,3.4:1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "1.2,3.4:5.2,A", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "-0.1,2", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "360,2", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,-1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,91", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
@@ -316,33 +316,33 @@ test_realisations_count(void)
   char** cmd = NULL;
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-n", "1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nexperiments, 1);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nexperiments == 1);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nexperiments, SOLSTICE_ARGS_DEFAULT.nexperiments);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nexperiments == SOLSTICE_ARGS_DEFAULT.nexperiments);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-n", "123", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nexperiments, 123);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nexperiments == 123);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-n", "0", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-n", "3.14", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-n", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 }
 
@@ -353,39 +353,39 @@ test_threads_count(void)
   char** cmd = NULL;
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-t", "1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nthreads, 1);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nthreads == 1);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-t", "123", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nthreads, 123);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nthreads == 123);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-t", "-1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nthreads, UINT_MAX);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nthreads == UINT_MAX);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.nthreads, SOLSTICE_ARGS_DEFAULT.nthreads);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.nthreads == SOLSTICE_ARGS_DEFAULT.nthreads);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-t", "0", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-t", "3.14", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-t", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
 }
@@ -397,25 +397,25 @@ test_output(void)
   char** cmd = NULL;
 
   cmd = cmd_create(0, "test", "-D", "0,90", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.output_filename, NULL);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.output_filename == NULL);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-o", "my_output", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(strcmp(args.output_filename, "my_output"), 0);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(strcmp(args.output_filename, "my_output") == 0);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-o", "hello_world", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(strcmp(args.output_filename, "hello_world"), 0);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(strcmp(args.output_filename, "hello_world") == 0);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-o", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 }
 
@@ -426,15 +426,15 @@ test_quiet(void)
   char** cmd = NULL;
 
   cmd = cmd_create(0, "test", "-D", "0,90", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.quiet, SOLSTICE_ARGS_DEFAULT.quiet);
-  CHECK(args.quiet, 0);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.quiet == SOLSTICE_ARGS_DEFAULT.quiet);
+  CHK(args.quiet == 0);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-q", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.quiet, 1);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.quiet == 1);
   solstice_args_release(&args);
   cmd_delete(cmd);
 }
@@ -446,15 +446,15 @@ test_verbose(void)
   char** cmd = NULL;
 
   cmd = cmd_create(0, "test", "-D", "0,90", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.verbose, SOLSTICE_ARGS_DEFAULT.verbose);
-  CHECK(args.verbose, 0);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.verbose == SOLSTICE_ARGS_DEFAULT.verbose);
+  CHK(args.verbose == 0);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-v", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.verbose, 1);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.verbose == 1);
   solstice_args_release(&args);
   cmd_delete(cmd);
 }
@@ -466,25 +466,25 @@ test_receivers(void)
   char** cmd = NULL;
 
   cmd = cmd_create(0, "test", "-D", "0,90", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.receivers_filename, SOLSTICE_ARGS_DEFAULT.receivers_filename);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.receivers_filename == SOLSTICE_ARGS_DEFAULT.receivers_filename);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-R", "my_receivers", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(strcmp(args.receivers_filename, "my_receivers"), 0);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(strcmp(args.receivers_filename, "my_receivers") == 0);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-R", "foo bar", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(strcmp(args.receivers_filename, "foo bar"), 0);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(strcmp(args.receivers_filename, "foo bar") == 0);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-R", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   solstice_args_release(&args);
   cmd_delete(cmd);
 }
@@ -496,15 +496,15 @@ test_input(void)
   char** cmd = NULL;
 
   cmd = cmd_create(0, "test", "-D", "0,90", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.input_filename, SOLSTICE_ARGS_DEFAULT.input_filename);
-  CHECK(args.input_filename, NULL);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.input_filename == SOLSTICE_ARGS_DEFAULT.input_filename);
+  CHK(args.input_filename == NULL);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "my_input", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(strcmp(args.input_filename, "my_input"), 0);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(strcmp(args.input_filename, "my_input") == 0);
   solstice_args_release(&args);
   cmd_delete(cmd);
 }
@@ -516,62 +516,62 @@ test_dump(void)
   char** cmd = NULL;
 
   cmd = cmd_create(0, "test", "-D", "0,90", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_format, SOLSTICE_ARGS_DUMP_NONE);
-  CHECK(args.dump_split_mode, SOLSTICE_ARGS_DUMP_SPLIT_NONE);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_format == SOLSTICE_ARGS_DUMP_NONE);
+  CHK(args.dump_split_mode == SOLSTICE_ARGS_DUMP_SPLIT_NONE);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-g", "format=obj", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_format, SOLSTICE_ARGS_DUMP_OBJ);
-  CHECK(args.dump_split_mode, SOLSTICE_ARGS_DUMP_SPLIT_NONE);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_format == SOLSTICE_ARGS_DUMP_OBJ);
+  CHK(args.dump_split_mode == SOLSTICE_ARGS_DUMP_SPLIT_NONE);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-g", "split=geometry:format=obj", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_format, SOLSTICE_ARGS_DUMP_OBJ);
-  CHECK(args.dump_split_mode, SOLSTICE_ARGS_DUMP_SPLIT_GEOMETRY);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_format == SOLSTICE_ARGS_DUMP_OBJ);
+  CHK(args.dump_split_mode == SOLSTICE_ARGS_DUMP_SPLIT_GEOMETRY);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-g", "format=obj:split=object", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_format, SOLSTICE_ARGS_DUMP_OBJ);
-  CHECK(args.dump_split_mode, SOLSTICE_ARGS_DUMP_SPLIT_OBJECT);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_format == SOLSTICE_ARGS_DUMP_OBJ);
+  CHK(args.dump_split_mode == SOLSTICE_ARGS_DUMP_SPLIT_OBJECT);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-g", "format=obj::::split=none", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_format, SOLSTICE_ARGS_DUMP_OBJ);
-  CHECK(args.dump_split_mode, SOLSTICE_ARGS_DUMP_SPLIT_NONE);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_format == SOLSTICE_ARGS_DUMP_OBJ);
+  CHK(args.dump_split_mode == SOLSTICE_ARGS_DUMP_SPLIT_NONE);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-g", "split=object", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-g", "format=stl", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-g", "format=obj:dummy", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-g", "format=obj:split", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-g", "format=obj", "-r", "up=0,0,1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-g", "format=obj", "-p", "default", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 }
 
@@ -582,91 +582,91 @@ test_dump_paths(void)
   char** cmd = NULL;
 
   cmd = cmd_create(0, "test", "-D", "0,90", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_paths, 0);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_paths == 0);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "default", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_paths, 1);
-  CHECK(args.infinite_ray_length, SOLSTICE_ARGS_DEFAULT.infinite_ray_length);
-  CHECK(args.sun_ray_length, SOLSTICE_ARGS_DEFAULT.sun_ray_length);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_paths == 1);
+  CHK(args.infinite_ray_length == SOLSTICE_ARGS_DEFAULT.infinite_ray_length);
+  CHK(args.sun_ray_length == SOLSTICE_ARGS_DEFAULT.sun_ray_length);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "irlen=3.14:srlen=1.23", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_paths, 1);
-  CHECK(eq_eps(args.infinite_ray_length, 3.14, 1.e-6), 1);
-  CHECK(eq_eps(args.sun_ray_length, 1.23, 1.e-6), 1);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_paths == 1);
+  CHK(eq_eps(args.infinite_ray_length, 3.14, 1.e-6) == 1);
+  CHK(eq_eps(args.sun_ray_length, 1.23, 1.e-6) == 1);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "irlen=0", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_paths, 1);
-  CHECK(eq_eps(args.infinite_ray_length, 0, 1.e-6), 1);
-  CHECK(args.sun_ray_length, SOLSTICE_ARGS_DEFAULT.sun_ray_length);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_paths == 1);
+  CHK(eq_eps(args.infinite_ray_length, 0, 1.e-6) == 1);
+  CHK(args.sun_ray_length == SOLSTICE_ARGS_DEFAULT.sun_ray_length);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "srlen=-4", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_paths, 1);
-  CHECK(args.infinite_ray_length, SOLSTICE_ARGS_DEFAULT.infinite_ray_length);
-  CHECK(eq_eps(args.sun_ray_length, -4, 1.e-6), 1);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_paths == 1);
+  CHK(args.infinite_ray_length == SOLSTICE_ARGS_DEFAULT.infinite_ray_length);
+  CHK(eq_eps(args.sun_ray_length, -4, 1.e-6) == 1);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "srlen=3.14:default", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_paths, 1);
-  CHECK(args.infinite_ray_length, SOLSTICE_ARGS_DEFAULT.infinite_ray_length);
-  CHECK(args.sun_ray_length, SOLSTICE_ARGS_DEFAULT.sun_ray_length);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_paths == 1);
+  CHK(args.infinite_ray_length == SOLSTICE_ARGS_DEFAULT.infinite_ray_length);
+  CHK(args.sun_ray_length == SOLSTICE_ARGS_DEFAULT.sun_ray_length);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "default:srlen=1:irlen=2:", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_OK);
-  CHECK(args.dump_paths, 1);
-  CHECK(args.sun_ray_length, 1);
-  CHECK(args.infinite_ray_length, 2);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_OK);
+  CHK(args.dump_paths == 1);
+  CHK(args.sun_ray_length == 1);
+  CHK(args.infinite_ray_length == 2);
   solstice_args_release(&args);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "srlen=", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "irlen=", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "srlen=abcd", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "irlen", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "=abcd", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "default:srlen=1:irlen=2:",
     "-r", "up=0,0,1", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 
   cmd = cmd_create(0, "test", "-D", "0,90", "-p", "default:srlen=1:irlen=2:",
     "-g", "format=obj", NULL);
-  CHECK(solstice_args_init(&args, cmd_size(cmd), cmd), RES_BAD_ARG);
+  CHK(solstice_args_init(&args, cmd_size(cmd), cmd) == RES_BAD_ARG);
   cmd_delete(cmd);
 }
 
@@ -685,7 +685,7 @@ main(int argc, char** argv)
   test_input();
   test_dump();
   test_dump_paths();
-  CHECK(mem_allocated_size(), 0);
+  CHK(mem_allocated_size() == 0);
   return 0;
 }
 
diff --git a/src/test_solstice_simulation.c b/src/test_solstice_simulation.c
@@ -78,8 +78,8 @@ struct counts {
 static int
 counts_ok(const struct counts* ref, const struct counts* c)
 {
-  CHECK(ref->global, GLOBAL_RESULTS_COUNT__);
-  CHECK(c->global, GLOBAL_RESULTS_COUNT__);
+  CHK(ref->global == GLOBAL_RESULTS_COUNT__);
+  CHK(c->global == GLOBAL_RESULTS_COUNT__);
   return ref->receiver == c->receiver
     && ref->primary == c->primary
     && ref->failed >= c->failed;
@@ -200,7 +200,7 @@ read_line(char* line, size_t max_line_len, FILE* stream)
   ASSERT(stream && line && max_line_len);
   line = fgets(line, (int)max_line_len, stream);
   if(!line) return 0;
-  CHECK(strlen(line) + 1 < max_line_len, 1);
+  CHK(strlen(line) + 1 < max_line_len);
   return 1;
 }
 
@@ -213,29 +213,26 @@ get_angles_and_counts
   char line[MAX_LINE_LEN];
   int r;
 
-  NCHECK(file, NULL);
-  NCHECK(angles, NULL);
-  NCHECK(counts, NULL);
+  CHK(file != NULL);
+  CHK(angles != NULL);
+  CHK(counts != NULL);
 
   /* Get sun dir */
   r = read_line(line, sizeof(line), file);
   if (!r) {
-    CHECK(feof(file), 1);
+    CHK(feof(file) == 1);
     return 0;
   }
-  CHECK(IS_NEW_BLOCK(line, sundir_header), 1);
-  CHECK(
-    sscanf(line+strlen(sundir_header), "%lg%lg", &angles[0], &angles[1]),
-    2);
+  CHK(IS_NEW_BLOCK(line, sundir_header) == 1);
+  CHK(sscanf(line+strlen(sundir_header), "%lg%lg", &angles[0], &angles[1]) == 2);
 
   /* Get counts */
-  CHECK(read_line(line, sizeof(line), file), 1);
-  CHECK(
+  CHK(read_line(line, sizeof(line), file) == 1);
+  CHK(
     sscanf(line,
       "%lu %lu %lu %lu %lu",
       &counts->global, &counts->receiver, &counts->primary,
-      &counts->realisation, &counts->failed),
-    5);
+      &counts->realisation, &counts->failed) == 5);
   return 1;
 }
 
@@ -243,10 +240,8 @@ static void
 read_global(FILE* file, double* E, double* SE)
 {
   char line[MAX_LINE_LEN];
-  CHECK(read_line(line, sizeof(line), file), 1);
-  CHECK(
-    sscanf(line, "%lg %lg", E, SE),
-    2);
+  CHK(read_line(line, sizeof(line), file) == 1);
+  CHK(sscanf(line, "%lg %lg", E, SE) == 2);
 }
 
 static void
@@ -254,13 +249,13 @@ read_recv(FILE* file, char name[], double E[], double SE[])
 {
   char line[MAX_LINE_LEN];
 
-  NCHECK(file, NULL);
-  NCHECK(name, NULL);
-  NCHECK(E, NULL);
-  NCHECK(SE, NULL);
+  CHK(file != NULL);
+  CHK(name != NULL);
+  CHK(E != NULL);
+  CHK(SE != NULL);
 
-  CHECK(read_line(line, sizeof(line), file), 1);
-  CHECK(
+  CHK(read_line(line, sizeof(line), file) == 1);
+  CHK(
     sscanf(line,
       "%s %*u %*g   "
       "%lg %lg   %lg %lg   %lg %lg   %lg %lg   %lg %lg  "
@@ -275,7 +270,7 @@ read_recv(FILE* file, char name[], double E[], double SE[])
       &E[BACK_INCOMING_FLUX], &SE[BACK_INCOMING_FLUX],
       &E[BACK_ABSORBED_FIELD_GAIN], &SE[BACK_ABSORBED_FIELD_GAIN],
       &E[BACK_ABSORBED_ATM_GAIN], &SE[BACK_ABSORBED_ATM_GAIN],
-      &E[BACK_EFFICIENCY], &SE[BACK_EFFICIENCY]),
+      &E[BACK_EFFICIENCY], &SE[BACK_EFFICIENCY]) ==
     2 * RECEIVER_RESULTS_COUNT__ + 1);
 }
 
@@ -285,13 +280,13 @@ read_primary
 {
   char line[MAX_LINE_LEN];
 
-  NCHECK(file, NULL);
-  NCHECK(area, NULL);
-  NCHECK(E, NULL);
-  NCHECK(SE, NULL);
+  CHK(file != NULL);
+  CHK(area != NULL);
+  CHK(E != NULL);
+  CHK(SE != NULL);
 
-  CHECK(read_line(line, sizeof(line), file), 1);
-  CHECK(
+  CHK(read_line(line, sizeof(line), file) == 1);
+  CHK(
     sscanf(line,
       "%s %*u   "
       "%lg %*u   "
@@ -299,7 +294,7 @@ read_primary
       name, /* ID */
       area, /* count, */
       &E[PRIMARY_COS], &SE[PRIMARY_COS],
-      &E[PRIMARY_SHADOW], &SE[PRIMARY_SHADOW]),
+      &E[PRIMARY_SHADOW], &SE[PRIMARY_SHADOW]) ==
     2 * PRIMARY_RESULTS_COUNT__ + 2);
 }
 
@@ -314,14 +309,14 @@ read_recvXprim
 {
   char line[MAX_LINE_LEN];
 
-  NCHECK(file, NULL);
-  NCHECK(rcv_id, NULL);
-  NCHECK(prim_id, NULL);
-  NCHECK(E, NULL);
-  NCHECK(SE, NULL);
+  CHK(file != NULL);
+  CHK(rcv_id != NULL);
+  CHK(prim_id != NULL);
+  CHK(E != NULL);
+  CHK(SE != NULL);
 
-  CHECK(read_line(line, sizeof(line), file), 1);
-  CHECK(
+  CHK(read_line(line, sizeof(line), file) == 1);
+  CHK(
     sscanf(line,
       "%lu %lu  "
       "%lg %lg   %lg %lg   %lg %lg   %lg %lg   "
@@ -334,7 +329,7 @@ read_recvXprim
       &E[BACK_ABSORBED_FLUX], &SE[BACK_ABSORBED_FLUX],
       &E[BACK_INCOMING_FLUX], &SE[BACK_INCOMING_FLUX],
       &E[BACK_ABSORBED_FIELD_GAIN], &SE[BACK_ABSORBED_FIELD_GAIN],
-      &E[BACK_ABSORBED_ATM_GAIN], &SE[BACK_ABSORBED_ATM_GAIN]),
+      &E[BACK_ABSORBED_ATM_GAIN], &SE[BACK_ABSORBED_ATM_GAIN]) ==
     2 * (RECEIVER_RESULTS_COUNT__ - 2 /* efficiencies not read */) + 2);
 }
 
@@ -348,7 +343,7 @@ compute_estimate_intersection
    const double SE1)
 {
   double interval0[2], interval1[2];
-  CHECK(scale > 0, 1);
+  CHK(scale > 0);
   interval0[0] = E0 - scale*SE0;
   interval0[1] = E0 + scale*SE0;
   interval1[0] = E1 - scale*SE1;
@@ -365,18 +360,18 @@ check_estimate
    double test_SE)
 {
   if(ref_E == -1) {
-    CHECK(ref_SE, -1);
-    CHECK(test_E, -1);
-    CHECK(test_SE, -1);
+    CHK(ref_SE == -1);
+    CHK(test_E == -1);
+    CHK(test_SE == -1);
   } else {
     double interval[2];
-    CHECK(ref_SE >= 0, 1);
-    CHECK(test_E >= 0, 1);
-    CHECK(test_SE >= 0, 1);
+    CHK(ref_SE >= 0);
+    CHK(test_E >= 0);
+    CHK(test_SE >= 0);
     if(!ref_SE) ref_SE = ref_E / 1000.0;
     if(!test_SE) test_SE = test_E / 1000.0;
     compute_estimate_intersection(interval, 2, ref_E, ref_SE, test_E, test_SE);
-    CHECK(interval[0] <= interval[1], 1);
+    CHK(interval[0] <= interval[1]);
   }
 }
 
@@ -388,9 +383,9 @@ check_1_reference
 {
   unsigned n;
 
-  NCHECK(ref_file, NULL);
-  NCHECK(test_file, NULL);
-  NCHECK(counts, NULL);
+  CHK(ref_file != NULL);
+  CHK(test_file != NULL);
+  CHK(counts != NULL);
 
   /* both files' pointer are just past the new bloc header */
 
@@ -410,7 +405,7 @@ check_1_reference
 
     read_recv(ref_file, ref_rcv_name, reference_E, reference_SE);
     read_recv(test_file, test_rcv_name, test_E, test_SE);
-    CHECK(strcmp(ref_rcv_name, test_rcv_name), 0);
+    CHK(strcmp(ref_rcv_name, test_rcv_name) == 0);
     FOR_EACH(r, FIRST_RECEIVER_RESULT, RECEIVER_RESULTS_COUNT__) {
       check_estimate(reference_E[r], reference_SE[r], test_E[r], test_SE[r]);
     }
@@ -427,7 +422,7 @@ check_1_reference
     read_primary(ref_file, ref_prim_name, &ref_area, reference_E, reference_SE);
     read_primary(test_file, test_prim_name, &test_area, test_E, test_SE);
     check_estimate(ref_area, 0, test_area, 0);
-    CHECK(strcmp(ref_prim_name, test_prim_name), 0);
+    CHK(strcmp(ref_prim_name, test_prim_name) == 0);
     FOR_EACH(r, FIRST_RECEIVER_RESULT, PRIMARY_RESULTS_COUNT__) {
       check_estimate(reference_E[r], reference_SE[r], test_E[r], test_SE[r]);
     }
@@ -444,8 +439,8 @@ check_1_reference
     read_recvXprim(ref_file, &ref_rcv_id, &ref_prim_id, reference_E, reference_SE);
     read_recvXprim(test_file, &test_rcv_id, &test_prim_id, test_E, test_SE);
     /* we rely on the order of outputs */
-    CHECK(ref_rcv_id, test_rcv_id);
-    CHECK(ref_prim_id, test_prim_id);
+    CHK(ref_rcv_id == test_rcv_id);
+    CHK(ref_prim_id == test_prim_id);
     FOR_EACH(r, FIRST_RECEIVER_RESULT, RECEIVER_RESULTS_COUNT__) {
       if (r == FRONT_EFFICIENCY || r == BACK_EFFICIENCY)
         continue; /* not read */
@@ -459,11 +454,11 @@ create_tmp_file(char* name, const size_t max_sizeof_name)
 {
   const char* template = "solstice_tmp_file_XXXXXX";
   int fd;
-  NCHECK(name, NULL);
-  CHECK(strlen(template)+1 <= max_sizeof_name-1, 1);
+  CHK(name != NULL);
+  CHK(strlen(template)+1 <= max_sizeof_name-1);
   strcpy(name, template);
   fd = mkstemp(name);
-  NCHECK(fd, -1);
+  CHK(fd != -1);
   return fd;
 }
 
@@ -478,10 +473,10 @@ do_check(const char* binary, const char* dir, const char* base_name)
   ASSERT(base_name);
 
   n = snprintf(ref_file_name, sizeof(ref_file_name), "%s%s.ref", dir, base_name);
-  CHECK((size_t)n < sizeof(ref_file_name), 1);
+  CHK((size_t)n < sizeof(ref_file_name));
 
   ref_file = fopen(ref_file_name, "r");
-  NCHECK(ref_file, NULL);
+  CHK(ref_file != NULL);
 
   while(!feof(ref_file)) {
     char cmd[512];
@@ -495,20 +490,20 @@ do_check(const char* binary, const char* dir, const char* base_name)
 
     fd = create_tmp_file(test_file_name, sizeof(test_file_name));
     test_file = fdopen(fd, "r");
-    NCHECK(test_file, NULL);
+    CHK(test_file != NULL);
 
     n = snprintf(cmd, sizeof(cmd),
       "%s -o %s -f -D %g,%g -n %lu -R %s%s_receiver.yaml %s%s.yaml",
       binary, test_file_name, SPLIT2(ref_sun_angles), ref_counts.realisation,
       dir, base_name, dir, base_name);
-    CHECK((unsigned)n < sizeof(cmd), 1);
+    CHK((unsigned)n < sizeof(cmd));
 
     err = system(cmd);
-    CHECK(err, 0);
+    CHK(err == 0);
 
     get_angles_and_counts(test_file, test_sun_angles, &test_counts);
-    CHECK(d2_eq(ref_sun_angles, test_sun_angles), 1);
-    CHECK(counts_ok(&ref_counts, &test_counts), 1);
+    CHK(d2_eq(ref_sun_angles, test_sun_angles) == 1);
+    CHK(counts_ok(&ref_counts, &test_counts) == 1);
     check_1_reference(ref_file, test_file, &ref_counts);
 
     fclose(test_file);

	solstice Compute collected power and efficiencies of a solar plant
	git clone git://git.meso-star.com/solstice.git
	Log \| Files \| Refs \| README \| LICENSE

M	cmake/CMakeLists.txt	\|	2	+-
M	src/parser/test_solparser.c	\|	18	+++++++++---------
M	src/parser/test_solparser2.c	\|	160	++++++++++++++++++++++++++++++++++++++++----------------------------------------
M	src/parser/test_solparser3.c	\|	192	++++++++++++++++++++++++++++++++++++++++----------------------------------------
M	src/parser/test_solparser4.c	\|	110	++++++++++++++++++++++++++++++++++++++++----------------------------------------
M	src/parser/test_solparser5.c	\|	44	++++++++++++++++++++++----------------------
M	src/parser/test_solparser6.c	\|	102	++++++++++++++++++++++++++++++++++++++++----------------------------------------
M	src/parser/test_solparser7.c	\|	78	+++++++++++++++++++++++++++++++++++++++---------------------------------------
M	src/parser/test_solparser8.c	\|	76	++++++++++++++++++++++++++++++++++++++--------------------------------------
M	src/parser/test_solparser_normal_map.c	\|	154	++++++++++++++++++++++++++++++++++++++++----------------------------------------
M	src/parser/test_solparser_spectrum.c	\|	214	++++++++++++++++++++++++++++++++++++++++----------------------------------------
M	src/receivers/test_srcvl.c	\|	18	+++++++++---------
M	src/receivers/test_srcvl2.c	\|	70	+++++++++++++++++++++++++++++++++++-----------------------------------
M	src/solstice.c	\|	4	++--
M	src/solstice_solve.c	\|	2	+-
M	src/test_solstice_args.c	\|	414	++++++++++++++++++++++++++++++++++++++++----------------------------------------
M	src/test_solstice_simulation.c	\|	127	++++++++++++++++++++++++++++++++++++++-----------------------------------------