test_sg2_geometry.c (12284B)
1 /* Copyright (C) 2019, 2020, 2023 |Méso|Star> (contact@meso-star.com) 2 * 3 * This program is free software: you can redistribute it and/or modify 4 * it under the terms of the GNU General Public License as published by 5 * the Free Software Foundation, either version 3 of the License, or 6 * (at your option) any later version. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program. If not, see <http://www.gnu.org/licenses/>. */ 15 16 #include "sg2.h" 17 #include "test_sg2d_utils.h" 18 19 #include <stdio.h> 20 21 static res_T 22 validate 23 (const unsigned iseg, 24 const unsigned properties[SG2D_PROP_TYPES_COUNT__], 25 void* context, 26 int* properties_conflict) 27 { 28 (void)iseg; (void)properties; (void)context; 29 *properties_conflict = 0; 30 return RES_OK; 31 } 32 33 static res_T 34 merge_seg 35 (const unsigned user_id, 36 const unsigned iseg, 37 const int reversed_segment, 38 unsigned segment_properties[SG2D_PROP_TYPES_COUNT__], 39 const unsigned merged_properties[SG2D_PROP_TYPES_COUNT__], 40 void* context, 41 int* merge_conflict) 42 { 43 ASSERT(segment_properties && merged_properties && merge_conflict); 44 (void)user_id; (void)reversed_segment; (void)context; 45 (void)segment_properties; (void)merged_properties; (void)merge_conflict; 46 *merge_conflict = (int)iseg; 47 return RES_OK; 48 } 49 50 static res_T 51 degenerated_segment 52 (const unsigned iseg, 53 void* context, 54 int* abort) 55 { 56 struct context* ctx = context; 57 ASSERT(abort && ctx); 58 (void)iseg; 59 *abort = *(int*)ctx->custom; 60 return RES_OK; 61 } 62 63 int 64 main(int argc, char** argv) 65 { 66 struct mem_allocator allocator; 67 struct sg2d_device* dev; 68 struct sg2d_geometry* geom; 69 double coord[2]; 70 unsigned indices[2]; 71 unsigned degenerated[2] = { 0, 0 }; 72 unsigned properties[SG2D_PROP_TYPES_COUNT__]; 73 struct sg2d_geometry_add_callbacks callbacks = SG2D_ADD_CALLBACKS_NULL__; 74 unsigned user_id; 75 unsigned count, i; 76 struct context ctx = CONTEXT_NULL__; 77 (void)argc, (void)argv; 78 79 OK(mem_init_proxy_allocator(&allocator, &mem_default_allocator)); 80 OK(sg2d_device_create(NULL, &allocator, 1, &dev)); 81 82 BA(sg2d_geometry_create(NULL, &geom)); 83 BA(sg2d_geometry_create(dev, NULL)); 84 OK(sg2d_geometry_create(dev, &geom)); 85 86 BA(sg2d_geometry_ref_get(NULL)); 87 OK(sg2d_geometry_ref_get(geom)); 88 89 BA(sg2d_geometry_ref_put(NULL)); 90 OK(sg2d_geometry_ref_put(geom)); 91 OK(sg2d_geometry_ref_put(geom)); 92 93 OK(sg2d_geometry_create(dev, &geom)); 94 95 BA(sg2d_geometry_validate_properties(NULL, NULL, NULL)); 96 BA(sg2d_geometry_validate_properties(geom, NULL, NULL)); 97 BA(sg2d_geometry_validate_properties(NULL, validate, NULL)); 98 OK(sg2d_geometry_validate_properties(geom, validate, NULL)); 99 100 BA(sg2d_geometry_get_unique_vertices_count(NULL, NULL)); 101 BA(sg2d_geometry_get_unique_vertices_count(geom, NULL)); 102 BA(sg2d_geometry_get_unique_vertices_count(NULL, &count)); 103 OK(sg2d_geometry_get_unique_vertices_count(geom, &count)); 104 105 BA(sg2d_geometry_get_added_segments_count(NULL, NULL)); 106 BA(sg2d_geometry_get_added_segments_count(geom, NULL)); 107 BA(sg2d_geometry_get_added_segments_count(NULL, &count)); 108 OK(sg2d_geometry_get_added_segments_count(geom, &count)); 109 110 BA(sg2d_geometry_get_unique_segments_count(NULL, NULL)); 111 BA(sg2d_geometry_get_unique_segments_count(geom, NULL)); 112 BA(sg2d_geometry_get_unique_segments_count(NULL, &count)); 113 OK(sg2d_geometry_get_unique_segments_count(geom, &count)); 114 115 BA(sg2d_geometry_get_unique_segments_with_unspecified_side_count(NULL, NULL)); 116 BA(sg2d_geometry_get_unique_segments_with_unspecified_side_count(geom, NULL)); 117 BA(sg2d_geometry_get_unique_segments_with_unspecified_side_count(NULL, &count)); 118 OK(sg2d_geometry_get_unique_segments_with_unspecified_side_count(geom, &count)); 119 120 BA(sg2d_geometry_get_unique_segments_with_unspecified_interface_count(NULL, NULL)); 121 BA(sg2d_geometry_get_unique_segments_with_unspecified_interface_count(geom, NULL)); 122 BA(sg2d_geometry_get_unique_segments_with_unspecified_interface_count(NULL, &count)); 123 OK(sg2d_geometry_get_unique_segments_with_unspecified_interface_count(geom, &count)); 124 125 BA(sg2d_geometry_get_unique_segments_with_merge_conflict_count(NULL, NULL)); 126 BA(sg2d_geometry_get_unique_segments_with_merge_conflict_count(geom, NULL)); 127 BA(sg2d_geometry_get_unique_segments_with_merge_conflict_count(NULL, &count)); 128 OK(sg2d_geometry_get_unique_segments_with_merge_conflict_count(geom, &count)); 129 130 BA(sg2d_geometry_get_unique_segments_with_properties_conflict_count(NULL, NULL)); 131 BA(sg2d_geometry_get_unique_segments_with_properties_conflict_count(geom, NULL)); 132 BA(sg2d_geometry_get_unique_segments_with_properties_conflict_count(NULL, &count)); 133 OK(sg2d_geometry_get_unique_segments_with_properties_conflict_count(geom, &count)); 134 135 BA(sg2d_geometry_dump_as_obj(NULL, NULL, 0)); 136 BA(sg2d_geometry_dump_as_obj(geom, NULL, 0)); 137 BA(sg2d_geometry_dump_as_obj(NULL, stdout, 0)); 138 BA(sg2d_geometry_dump_as_obj(NULL, NULL, SG2D_OBJ_DUMP_ALL)); 139 BA(sg2d_geometry_dump_as_obj(geom, stdout, 0)); 140 BA(sg2d_geometry_dump_as_obj(geom, NULL, SG2D_OBJ_DUMP_ALL)); 141 BA(sg2d_geometry_dump_as_obj(NULL, stdout, SG2D_OBJ_DUMP_ALL)); 142 /* BA because geometry is empty */ 143 BA(sg2d_geometry_dump_as_obj(geom, stdout, SG2D_OBJ_DUMP_ALL)); 144 145 BA(sg2d_geometry_dump_as_vtk(NULL, NULL)); 146 BA(sg2d_geometry_dump_as_vtk(geom, NULL)); 147 BA(sg2d_geometry_dump_as_vtk(NULL, stdout)); 148 /* BA because geometry is empty */ 149 BA(sg2d_geometry_dump_as_vtk(geom, stdout)); 150 151 BA(sg2d_geometry_dump_as_c_code(NULL, NULL, NULL, 0)); 152 BA(sg2d_geometry_dump_as_c_code(geom, NULL, NULL, 0)); 153 BA(sg2d_geometry_dump_as_c_code(NULL, stdout, NULL, 0)); 154 BA(sg2d_geometry_dump_as_c_code(NULL, NULL, "test", 0)); 155 BA(sg2d_geometry_dump_as_c_code(geom, NULL, "test", 0)); 156 BA(sg2d_geometry_dump_as_c_code(NULL, stdout, "test", 0)); 157 /* BA because geometry is empty */ 158 BA(sg2d_geometry_dump_as_c_code(geom, stdout, NULL, 0)); 159 BA(sg2d_geometry_dump_as_c_code(geom, stdout, "test", 0)); 160 161 BA(sg2d_geometry_add(NULL, 0, 0, &callbacks, NULL)); 162 OK(sg2d_geometry_get_added_segments_count(geom, &count)); 163 CHK(count == 0); 164 BA(sg2d_geometry_add(geom, nvertices, nsegments, NULL, NULL)); 165 OK(sg2d_geometry_get_added_segments_count(geom, &count)); 166 CHK(count == nsegments); 167 /* Mandatory callbacks are NULL */ 168 callbacks.get_indices = NULL; 169 callbacks.get_position = get_position; 170 BA(sg2d_geometry_add(geom, 0, 0, &callbacks, NULL)); 171 callbacks.get_indices = get_indices; 172 callbacks.get_position = NULL; 173 BA(sg2d_geometry_add(geom, 0, 0, &callbacks, NULL)); 174 callbacks.get_indices = NULL; 175 callbacks.get_position = NULL; 176 BA(sg2d_geometry_add(geom, 0, 0, &callbacks, NULL)); 177 /* Add 0 items */ 178 callbacks.get_indices = get_indices; 179 callbacks.get_position = get_position; 180 OK(sg2d_geometry_add(geom, 0, 0, &callbacks, NULL)); 181 OK(sg2d_geometry_get_added_segments_count(geom, &count)); 182 CHK(count == nsegments); 183 184 /* A 2D square. 185 * 2 enclosures (inside, outside) sharing the same segments, 186 * but opposite sides */ 187 ctx.positions = square_vertices; 188 ctx.indices = box_indices; 189 ctx.front_media = medium0; 190 ctx.back_media = medium1; 191 ctx.intface = intface0; 192 193 callbacks.get_indices = get_indices; 194 callbacks.get_properties = get_properties; 195 callbacks.get_position = get_position; 196 197 OK(sg2d_geometry_add(geom, nvertices, nsegments, &callbacks, &ctx)); 198 OK(sg2d_geometry_dump_as_obj(geom, stdout, SG2D_OBJ_DUMP_ALL)); 199 OK(sg2d_geometry_dump_as_vtk(geom, stdout)); 200 OK(sg2d_geometry_dump_as_c_code(geom, stdout, NULL, 0)); 201 OK(sg2d_geometry_dump_as_c_code(geom, stdout, "test", 202 SG2D_C_DUMP_STATIC | SG2D_C_DUMP_CONST)); 203 204 BA(sg2d_geometry_get_unique_vertex(NULL, nsegments, NULL)); 205 BA(sg2d_geometry_get_unique_vertex(geom, nsegments, NULL)); 206 BA(sg2d_geometry_get_unique_vertex(NULL, 0, NULL)); 207 BA(sg2d_geometry_get_unique_vertex(NULL, nsegments, coord)); 208 BA(sg2d_geometry_get_unique_vertex(geom, 0, NULL)); 209 BA(sg2d_geometry_get_unique_vertex(geom, nsegments, coord)); 210 BA(sg2d_geometry_get_unique_vertex(NULL, 0, coord)); 211 OK(sg2d_geometry_get_unique_vertex(geom, 0, coord)); 212 213 BA(sg2d_geometry_get_unique_segment_vertices(NULL, nsegments, NULL)); 214 BA(sg2d_geometry_get_unique_segment_vertices(geom, nsegments, NULL)); 215 BA(sg2d_geometry_get_unique_segment_vertices(NULL, 0, NULL)); 216 BA(sg2d_geometry_get_unique_segment_vertices(NULL, nsegments, indices)); 217 BA(sg2d_geometry_get_unique_segment_vertices(geom, 0, NULL)); 218 BA(sg2d_geometry_get_unique_segment_vertices(geom, nsegments, indices)); 219 BA(sg2d_geometry_get_unique_segment_vertices(NULL, 0, indices)); 220 OK(sg2d_geometry_get_unique_segment_vertices(geom, 0, indices)); 221 FOR_EACH(i, 0 , 2) CHK(indices[i] == box_indices[i]); 222 223 BA(sg2d_geometry_get_unique_segment_properties(NULL, nsegments, NULL)); 224 BA(sg2d_geometry_get_unique_segment_properties(geom, nsegments, NULL)); 225 BA(sg2d_geometry_get_unique_segment_properties(NULL, 0, NULL)); 226 BA(sg2d_geometry_get_unique_segment_properties(NULL, nsegments, properties)); 227 BA(sg2d_geometry_get_unique_segment_properties(geom, 0, NULL)); 228 BA(sg2d_geometry_get_unique_segment_properties(geom, nsegments, properties)); 229 BA(sg2d_geometry_get_unique_segment_properties(NULL, 0, properties)); 230 OK(sg2d_geometry_get_unique_segment_properties(geom, 0, properties)); 231 CHK(medium0[0] == properties[SG2D_FRONT]); 232 CHK(medium1[0] == properties[SG2D_BACK]); 233 CHK(intface0[0] == properties[SG2D_INTFACE]); 234 235 BA(sg2d_geometry_get_unique_segment_user_id(NULL, nsegments, NULL)); 236 BA(sg2d_geometry_get_unique_segment_user_id(geom, nsegments, NULL)); 237 BA(sg2d_geometry_get_unique_segment_user_id(NULL, 0, NULL)); 238 BA(sg2d_geometry_get_unique_segment_user_id(NULL, nsegments, &user_id)); 239 BA(sg2d_geometry_get_unique_segment_user_id(geom, 0, NULL)); 240 BA(sg2d_geometry_get_unique_segment_user_id(geom, nsegments, &user_id)); 241 BA(sg2d_geometry_get_unique_segment_user_id(NULL, 0, &user_id)); 242 OK(sg2d_geometry_get_unique_segment_user_id(geom, 0, &user_id)); 243 /* Due to a failed attempt to add nsegments segments, user_id for the 244 * first successfully added segment is shifted */ 245 CHK(user_id == nsegments); 246 247 /* Conflicts with merge_seg callback */ 248 callbacks.merge_segment = merge_seg; 249 OK(sg2d_geometry_add(geom, nvertices, nsegments, &callbacks, &ctx)); 250 OK(sg2d_geometry_get_unique_segments_with_merge_conflict_count(geom, &count)); 251 /* Due to merge_seg internals, all but the first segment have conflict */ 252 CHK(count == nsegments - 1); 253 OK(sg2d_geometry_dump_as_obj(geom, stdout, SG2D_OBJ_DUMP_ALL)); 254 OK(sg2d_geometry_dump_as_vtk(geom, stdout)); 255 /* BA because of conflicts */ 256 BA(sg2d_geometry_dump_as_c_code(geom, stdout, "test", SG2D_C_DUMP_STATIC)); 257 OK(sg2d_geometry_ref_put(geom)); 258 259 /* Conflicts without merge_seg callback */ 260 OK(sg2d_geometry_create(dev, &geom)); 261 callbacks.merge_segment = NULL; 262 OK(sg2d_geometry_add(geom, nvertices, nsegments, &callbacks, &ctx)); 263 ctx.front_media = medium1_top0; 264 OK(sg2d_geometry_add(geom, nvertices, nsegments, &callbacks, &ctx)); 265 OK(sg2d_geometry_get_unique_segments_with_merge_conflict_count(geom, &count)); 266 FOR_EACH(i, 0, nsegments) if(medium0[i] != medium1_top0[i]) count--; 267 CHK(count == 0); 268 OK(sg2d_geometry_dump_as_obj(geom, stdout, SG2D_OBJ_DUMP_ALL)); 269 OK(sg2d_geometry_dump_as_vtk(geom, stdout)); 270 /* BA because of conflicts */ 271 BA(sg2d_geometry_dump_as_c_code(geom, stdout, "test", SG2D_C_DUMP_CONST)); 272 273 /* Degenerated segments */ 274 ctx.indices = degenerated; 275 /* Without callback : OK */ 276 OK(sg2d_geometry_add(geom, nvertices, 1, &callbacks, &ctx)); 277 /* With callback : OK */ 278 callbacks.degenerated_segment = degenerated_segment; 279 ctx.custom = &i; 280 i = 0; 281 OK(sg2d_geometry_add(geom, nvertices, 1, &callbacks, &ctx)); 282 /* With callback : KO */ 283 i= 1; 284 BA(sg2d_geometry_add(geom, nvertices, 1, &callbacks, &ctx)); 285 286 OK(sg2d_geometry_ref_put(geom)); 287 OK(sg2d_device_ref_put(dev)); 288 289 check_memory_allocator(&allocator); 290 mem_shutdown_proxy_allocator(&allocator); 291 CHK(mem_allocated_size() == 0); 292 return 0; 293 }