YARP
Yet Another Robot Platform
 
Loading...
Searching...
No Matches
IMap2DTest.h
Go to the documentation of this file.
1/*
2 * SPDX-FileCopyrightText: 2006-2021 Istituto Italiano di Tecnologia (IIT)
3 * SPDX-License-Identifier: BSD-3-Clause
4 */
5
6#ifndef IMAP2DTEST_H
7#define IMAP2DTEST_H
8
9#include <yarp/dev/api.h>
10#include <yarp/dev/IMap2D.h>
11#include <catch2/catch_amalgamated.hpp>
12#include <fstream>
13#include <yarp/sig/ImageFile.h>
14#include <filesystem>
15#include <cstdlib>
16
17using namespace yarp::dev;
18using namespace yarp::dev::Nav2D;
19using namespace yarp::sig;
20using namespace yarp::os;
21
22
23bool remove_map_files(std::string filename)
24{
25 bool ret = true;
26 ret &= std::filesystem::remove (filename + ".map");
27 ret &= std::filesystem::remove (filename + "_grid.pgm");
28 ret &= std::filesystem::remove (filename + "_grid.yaml");
29 ret &= std::filesystem::remove (filename + "_yarpflags.ppm");
30 return ret;
31}
32
33namespace yarp::dev::tests
34{
36 {
37 {
39 std::vector<std::string> ll;
40 std::vector<std::string> la;
41 std::vector<std::string> lp;
42 std::vector<std::string> op;
43 {
44 Map2DLocation l1 = Map2DLocation("map_1", 10.0, 20.0, 15);
45 Map2DLocation l2 = Map2DLocation("map_1", 10.2, 20.1, 15.5);
46 Map2DArea a1("map_1", std::vector<Map2DLocation> {Map2DLocation("map_1", -10, -10, 0),
47 Map2DLocation("map_1", -10, +10, 0),
48 Map2DLocation("map_1", +10, +10, 0),
49 Map2DLocation("map_1", +10, -10, 0)});
50 Map2DPath p1(std::vector<Map2DLocation> {l1, l2});
51 Map2DObject o1("map_1", 1.0, 2.0, 3.0);
52 bool b;
53 b = imap->storeArea("area_test1", a1); CHECK(b);
54 b = imap->storeLocation("loc_test1", l1); CHECK(b);
55 b = imap->storeLocation("loc_test2", l2); CHECK(b);
56 b = imap->storePath("path_test1", p1); CHECK(b);
57 b = imap->storeObject("object_test1", o1); CHECK(b);
58 b = imap->getLocationsList(ll); CHECK(b); CHECK(ll.size() == 2);
59 b = imap->getAreasList(la); CHECK(b); CHECK(la.size() == 1);
60 b = imap->getPathsList(lp); CHECK(b); CHECK(lp.size() == 1);
61 b = imap->getObjectsList(op); CHECK(b); CHECK(op.size() == 1);
62 }
63
64 {
65 bool b;
66 b = imap->saveLocationsAndExtras("locations_test.ini"); CHECK(b);
67 b = std::filesystem::exists("locations_test.ini"); CHECK(b);
68 b = imap->clearAllLocations(); CHECK(b);
69 b = imap->clearAllAreas(); CHECK(b);
70 b = imap->clearAllPaths(); CHECK(b);
71 b = imap->clearAllObjects(); CHECK(b);
72 b = imap->getLocationsList(ll); CHECK(b); CHECK(ll.size() == 0);
73 b = imap->getAreasList(la); CHECK(b); CHECK(la.size() == 0);
74 b = imap->getPathsList(lp); CHECK(b); CHECK(lp.size() == 0);
75 b = imap->getObjectsList(op); CHECK(b); CHECK(op.size() == 0);
76
77 b = imap->loadLocationsAndExtras("locations_test.ini"); CHECK(b);
83 b = imap->getLocationsList(ll); CHECK(b); CHECK(ll.size() == 2);
84 b = imap->getAreasList(la); CHECK(b); CHECK(la.size() == 1);
85 b = imap->getPathsList(lp); CHECK(b); CHECK(lp.size() == 1);
86 b = imap->getObjectsList(op); CHECK(b); CHECK(op.size() == 1);
87
88 std::vector<Map2DLocation> vl;
89 std::vector<Map2DArea> va;
90 std::vector<Map2DPath> vp;
91 std::vector<Map2DObject> vo;
92 b = imap->getAllLocations(vl); CHECK(b); CHECK(vl.size() == 2);
93 b = imap->getAllAreas(va); CHECK(b); CHECK(va.size() == 1);
94 b = imap->getAllPaths(vp); CHECK(b); CHECK(vp.size() == 1);
95 b = imap->getAllObjects(vo); CHECK(b); CHECK(vo.size() == 1);
96
97 b = imap->getLocation("loc_test1", l1t); CHECK(b);
98 b = imap->getLocation("loc_test2", l2t); CHECK(b);
99 b = imap->getArea("area_test1", a1); CHECK(b);
100 b = imap->getPath("path_test1", p1); CHECK(b);
101 b = imap->getObject("object_test1", o1); CHECK(b);
102
103 b = std::filesystem::remove("locations_test.ini"); CHECK(b);
104 }
105 }
106 }
107
109 {
111 {
112 std::vector <Map2DArea> areas;
113 std::vector <Map2DLocation> locs;
114 std::vector <std::string> loc_names;
115 Map2DLocation loc;
116 Map2DArea area;
117 bool ret;
118 bool b1;
119 ret = imap->clearAllLocations(); CHECK(ret);
120 ret = imap->clearAllAreas(); CHECK(ret);
121 ret = imap->getAreasList(loc_names); CHECK(ret);
122 b1 = (loc_names.size() == 0);
123 CHECK(b1);
124 ret = imap->getLocationsList(loc_names); CHECK(ret);
125 b1 = (loc_names.size() == 0);
126 CHECK(b1);
127
128 ret = imap->storeLocation("loc1", Map2DLocation("map1", 1, 2, 3)); CHECK(ret);
129 ret = imap->storeLocation("loc2", Map2DLocation("map2", 4, 5, 6)); CHECK(ret);
130
131 std::vector<Map2DLocation> vec1, vec2, vec3;
133 v.x = 1.1; v.y = 1.1; vec1.push_back(v);
134 v.x = 1.2; v.y = 1.2; vec1.push_back(v);
135 v.x = 1.3; v.y = 1.3; vec1.push_back(v);
136 ret = imap->storeArea("area1", Map2DArea("map1", vec1)); CHECK(ret);
137 v.x = 2.1; v.y = 2.1; vec2 = vec1; vec2.push_back(v);
138 ret = imap->storeArea("area2", Map2DArea("map2", vec2)); CHECK(ret);
139 v.x = 3.1; v.y = 3.1; vec3 = vec2; vec3.push_back(v);
140 ret = imap->storeArea("area3", Map2DArea("map3", vec3)); CHECK(ret);
141
142 ret = imap->getAreasList(loc_names); CHECK(ret);
143 b1 = (loc_names.size() == 3);
144 CHECK(b1);
145 ret = imap->getLocationsList(loc_names); CHECK(ret);
146 b1 = (loc_names.size() == 2);
147 CHECK(b1);
148
149 ret = imap->getArea("area1", area); CHECK(ret);
150 b1 = (area == Map2DArea("map1", vec1));
151 CHECK(b1);
152 ret = imap->getArea("area_err", area); CHECK(ret == false);
153
154 ret = imap->getLocation("loc1", loc); CHECK(ret);
155 b1 = (loc == Map2DLocation("map1", 1, 2, 3));
156 CHECK(b1);
157 ret = imap->getLocation("loc_err", loc); CHECK(ret == false);
158
159 ret = imap->deleteArea("area1"); CHECK(ret);
160 ret = imap->deleteLocation("loc1"); CHECK(ret);
161 ret = imap->deleteArea("area_err"); CHECK(ret == false);
162 ret = imap->deleteLocation("loc_err"); CHECK(ret == false);
163 ret = imap->getArea("area1", area); CHECK(ret == false);
164 ret = imap->getLocation("loc1", loc); CHECK(ret == false);
165
166 ret = imap->getArea("area2", area); CHECK(ret);
167 b1 = (area == Map2DArea("map2", vec2));
168 CHECK(b1);
169 ret = imap->getLocation("loc2", loc); CHECK(ret);
170 b1 = (loc == Map2DLocation("map2", 4, 5, 6));
171 CHECK(b1);
172
173 ret = imap->clearAllLocations(); CHECK(ret);
174 ret = imap->clearAllAreas(); CHECK(ret);
175 ret = imap->getAreasList(loc_names); CHECK(ret);
176 b1 = (loc_names.size() == 0);
177 CHECK(b1);
178 imap->getLocationsList(loc_names);
179 b1 = (loc_names.size() == 0);
180 CHECK(b1);
181
182 ret = imap->storeArea("area", Map2DArea("map1", vec1)); CHECK(ret);
183 ret = imap->storeLocation("loc", Map2DLocation("map2", 4, 5, 6)); CHECK(ret);
184 ret = imap->renameArea("area_fail", "area_new"); CHECK(ret == false);
185 ret = imap->renameLocation("loc_fail", "loc_new"); CHECK(ret == false);
186 ret = imap->renameArea("area", "area_new"); CHECK(ret);
187 ret = imap->renameLocation("loc", "loc_new"); CHECK(ret);
188 ret = imap->getArea("area", area); CHECK(ret == false);
189 ret = imap->getArea("area_new", area); CHECK(ret);
190 ret = imap->getLocation("loc", loc); CHECK(ret == false);
191 ret = imap->getLocation("loc_new", loc); CHECK(ret);
192
193 //final cleanup, already tested
194 ret = imap->clearAllLocations(); CHECK(ret);
195 ret = imap->clearAllAreas(); CHECK(ret);
196 }
197
199 {
200 std::vector <Map2DPath> paths;
201 std::vector <Map2DLocation> locs;
202 std::vector <std::string> loc_names;
203 std::vector <std::string> path_names;
204 Map2DLocation loc;
205 Map2DPath path;
206 bool ret;
207 bool b1;
208 ret = imap->clearAllLocations(); CHECK(ret);
209 ret = imap->clearAllPaths(); CHECK(ret);
210 ret = imap->getPathsList(path_names); CHECK(ret);
211 b1 = (path_names.size() == 0);
212 CHECK(b1);
213 ret = imap->getLocationsList(loc_names); CHECK(ret);
214 b1 = (loc_names.size() == 0);
215 CHECK(b1);
216
217 ret = imap->storeLocation("loc1", Map2DLocation("map1", 1, 2, 3)); CHECK(ret);
218 ret = imap->storeLocation("loc2", Map2DLocation("map2", 4, 5, 6)); CHECK(ret);
219
220 std::vector<Map2DLocation> vec1, vec2, vec3;
222 v.x = 1.1; v.y = 1.1; vec1.push_back(v);
223 v.x = 1.2; v.y = 1.2; vec1.push_back(v);
224 v.x = 1.3; v.y = 1.3; vec1.push_back(v);
225 ret = imap->storePath("path1", Map2DPath(vec1)); CHECK(ret);
226 v.x = 2.1; v.y = 2.1; vec2 = vec1; vec2.push_back(v);
227 ret = imap->storePath("path2", Map2DPath(vec2)); CHECK(ret);
228 v.x = 3.1; v.y = 3.1; vec3 = vec2; vec3.push_back(v);
229 ret = imap->storePath("path3", Map2DPath(vec3)); CHECK(ret);
230
231 ret = imap->getPathsList(path_names); CHECK(ret);
232 b1 = (path_names.size() == 3);
233 CHECK(b1);
234 ret = imap->getLocationsList(loc_names); CHECK(ret);
235 b1 = (loc_names.size() == 2);
236 CHECK(b1);
237
238 ret = imap->getPath("path1", path); CHECK(ret);
239 b1 = (path == Map2DPath(vec1));
240 CHECK(b1);
241 ret = imap->getPath("path_err", path); CHECK(ret == false);
242
243 ret = imap->getLocation("loc1", loc); CHECK(ret);
244 b1 = (loc == Map2DLocation("map1", 1, 2, 3));
245 CHECK(b1);
246 ret = imap->getLocation("loc_err", loc); CHECK(ret == false);
247
248 ret = imap->deletePath("path1"); CHECK(ret);
249 ret = imap->deleteLocation("loc1"); CHECK(ret);
250 ret = imap->deletePath("path_err"); CHECK(ret == false);
251 ret = imap->deleteLocation("loc_err"); CHECK(ret == false);
252 ret = imap->getPath("path1", path); CHECK(ret == false);
253 ret = imap->getLocation("loc1", loc); CHECK(ret == false);
254
255 ret = imap->getPath("path2", path); CHECK(ret);
256 b1 = (path == Map2DPath(vec2));
257 CHECK(b1);
258 ret = imap->getLocation("loc2", loc); CHECK(ret);
259 b1 = (loc == Map2DLocation("map2", 4, 5, 6));
260 CHECK(b1);
261
262 ret = imap->clearAllLocations(); CHECK(ret);
263 ret = imap->clearAllPaths(); CHECK(ret);
264 ret = imap->getPathsList(path_names); CHECK(ret);
265 b1 = (path_names.size() == 0);
266 CHECK(b1);
267 imap->getLocationsList(loc_names);
268 b1 = (loc_names.size() == 0);
269 CHECK(b1);
270
271 ret = imap->storePath("path", Map2DPath(vec1)); CHECK(ret);
272 ret = imap->storeLocation("loc", Map2DLocation("map2", 4, 5, 6)); CHECK(ret);
273 ret = imap->renamePath("path_fail", "path_new"); CHECK(ret == false);
274 ret = imap->renameLocation("loc_fail", "loc_new"); CHECK(ret == false);
275 ret = imap->renamePath("path", "path_new"); CHECK(ret);
276 ret = imap->renameLocation("loc", "loc_new"); CHECK(ret);
277 ret = imap->getPath("path", path); CHECK(ret == false);
278 ret = imap->getPath("path_new", path); CHECK(ret);
279 ret = imap->getLocation("loc", loc); CHECK(ret == false);
280 ret = imap->getLocation("loc_new", loc); CHECK(ret);
281
282 std::string s = path.toString();
283
284 //final cleanup, already tested
285 ret = imap->clearAllLocations(); CHECK(ret);
286 ret = imap->clearAllPaths(); CHECK(ret);
287 }
288
290 {
291 bool ret = false;
292 ret = imap->clearAllMaps(); CHECK(ret);
293
297
298 test_store_map1.setMapName("test_map1");
299 test_store_map2.setMapName("test_map2");
300 std::vector<std::string> map_names;
301
302 ret = imap->store_map(test_store_map1); CHECK(ret);
303 ret = imap->store_map(test_store_map2); CHECK(ret);
304 ret = imap->get_map("test_map1", test_get_map); CHECK(ret);
305 CHECK(test_store_map1.isIdenticalTo(test_get_map)); // IMap2D store/get operation successful
306
307 ret = imap->get_map_names(map_names);
308 CHECK(ret);
309 bool b1 = (map_names.size() == 2);
310 bool b2 = false;
311 if (b1) {
312 b2 = (map_names[0] == "test_map1" && map_names[1] == "test_map2");
313 }
314 CHECK(b1);
315 CHECK(b2);
316 // IMap2D get_map_names operation successful")
317
318 ret = imap->remove_map("test_map1"); CHECK(ret);
319 ret = imap->remove_map("test_map1"); CHECK_FALSE(ret);
320 ret = imap->get_map_names(map_names); CHECK(ret);
321 b1 = (map_names.size() == 1); CHECK(b1);
322 // IMap2D remove_map operation successful
323
324 ret = imap->clearAllMaps(); CHECK(ret);
325 ret = imap->get_map_names(map_names); CHECK(ret);
326 b1 = (map_names.size() == 0); CHECK(b1);
327 }
328 }
329
330 // Additional tests to cover remaining IMap2D API (objects, getAll*, map persistence, compression, temp flags)
332 {
333 REQUIRE(imap != nullptr);
334
335 // 1. Object API: store/get/list/all/rename/delete/clear
336 {
337 bool ret = false;
338 // start clean
339 ret = imap->clearAllObjects(); CHECK(ret);
340 std::vector<std::string> obj_names;
341 ret = imap->getObjectsList(obj_names); CHECK(ret); CHECK(obj_names.empty());
342
343 // Fields: map_id, x, y, z, roll, pitch, yaw, description
344 Map2DObject obj1; obj1.map_id = "map_obj"; obj1.x = 1.0; obj1.y = 2.0; obj1.z = 0.3; obj1.roll = 0.1; obj1.pitch = 0.2; obj1.yaw = 0.5; obj1.description = "an object";
345 Map2DObject obj2; obj2.map_id = "map_obj"; obj2.x = 3.0; obj2.y = 4.0; obj2.z = 0.6; obj2.roll = 0.4; obj2.pitch = 0.5; obj2.yaw = 1.5; obj2.description = "another object";
346 ret = imap->storeObject("obj1", obj1); CHECK(ret);
347 ret = imap->storeObject("obj2", obj2); CHECK(ret);
348
349 ret = imap->getObjectsList(obj_names); CHECK(ret); CHECK(obj_names.size() == 2);
350
352 ret = imap->getObject("obj1", obj1_r); CHECK(ret);
353 ret = imap->getObject("obj2", obj2_r); CHECK(ret);
354 CHECK(obj1_r.x == Catch::Approx(1.0));
355 CHECK(obj2_r.x == Catch::Approx(3.0));
356 CHECK(obj1_r.yaw == Catch::Approx(0.5));
357 CHECK(obj2_r.yaw == Catch::Approx(1.5));
358
359 // getAllObjects
360 std::vector<Map2DObject> all_objs;
361 ret = imap->getAllObjects(all_objs); CHECK(ret); CHECK(all_objs.size() == 2);
362
363 // renameObject (success)
364 ret = imap->renameObject("obj1", "obj1_new"); CHECK(ret);
365 ret = imap->getObject("obj1", obj1_r); CHECK_FALSE(ret);
366 ret = imap->getObject("obj1_new", obj1_r); CHECK(ret);
367
368 // failing rename
369 ret = imap->renameObject("obj_not_exists", "whatever"); CHECK_FALSE(ret);
370
371 // deleteObject success + failure
372 ret = imap->deleteObject("obj2"); CHECK(ret);
373 ret = imap->deleteObject("obj_unknown"); CHECK_FALSE(ret);
374 ret = imap->getObject("obj2", obj2_r); CHECK_FALSE(ret);
375
376 // clearAllObjects finale
377 ret = imap->clearAllObjects(); CHECK(ret);
378 ret = imap->getObjectsList(obj_names); CHECK(ret); CHECK(obj_names.empty());
379 }
380
381 // 2. Map persistence: single map save + optional collection reload (best-effort)
382 {
383 bool ret = false;
384
385 // save individual map (filename relative - depending on device may need to be writable)
386 ret = imap->clearAllMaps(); CHECK(ret);
387 Nav2D::MapGrid2D m0; m0.setMapName("zz_unit_persist_map0");
388 ret = imap->store_map(m0); CHECK(ret);
389 ret = imap->saveMapToDisk("zz_unit_persist_map0", "zz_unit_persist_map0.map"); CHECK(ret);
390 CHECK(std::filesystem::exists("zz_unit_persist_map0.map"));
391 CHECK (remove_map_files("zz_unit_persist_map0"));
392
393 // Prepare a collection of maps
394 ret = imap->clearAllMaps(); CHECK(ret);
395 Nav2D::MapGrid2D m1; m1.setMapName("zz_unit_persist_map1");
396 Nav2D::MapGrid2D m2; m2.setMapName("zz_unit_persist_map2");
397 ret = imap->store_map(m1); CHECK(ret);
398 ret = imap->store_map(m2); CHECK(ret);
399
400 // save collection (cwd does not make any difference, it's used only
401 // to inspect the variable when doing interactive debug.
402 std::string cwd = std::filesystem::current_path().string(); cwd.push_back (std::filesystem::path::preferred_separator);
403 ret = imap->saveMapsCollection(cwd+"maps_collection.ini"); CHECK(ret);
404 CHECK(std::filesystem::exists(cwd+"maps_collection.ini"));
405 CHECK(std::filesystem::exists(cwd+"zz_unit_persist_map1.map"));
406 CHECK(std::filesystem::exists(cwd+"zz_unit_persist_map2.map"));
407
408 // clear everything
409 ret = imap->clearAllMaps(); CHECK(ret);
410 std::vector<std::string> names;
411 ret = imap->get_map_names(names); CHECK(ret); CHECK(names.empty());
412
413 // load a collection
414 ret = imap->loadMapsCollection(cwd+"maps_collection.ini");
415 CHECK(ret);
416 // loading again will fail
417 ret = imap->loadMapsCollection(cwd+"maps_collection.ini");
418 CHECK_FALSE(ret);
419 // loading a not existing file will fail
420 ret = imap->loadMapsCollection(cwd+"maps_collection2.ini");
421 CHECK_FALSE(ret);
422
423 bool ret_names = imap->get_map_names(names);
425 CHECK(names.size() == 2);
426
427 // remove a map then attempt to load it back from single map file
428 bool ret_rm = imap->remove_map("zz_unit_persist_map1");
429 CHECK(ret_rm);
430 bool rv_single = imap->loadMapFromDisk(cwd+"zz_unit_persist_map1.map");
432
433 // edge case: remove non-existing map
434 bool ret_non = imap->remove_map("no_such_map");
436
437 CHECK (remove_map_files("zz_unit_persist_map1"));
438 CHECK (remove_map_files("zz_unit_persist_map2"));
439 CHECK (std::filesystem::remove("maps_collection.ini"));
440 }
441
442 // 3. Temporary flags clearing (cannot easily set flags here, just call and expect success)
443 {
444 bool ret = false;
445 ret = imap->clearAllMapsTemporaryFlags(); CHECK(ret);
446 // ensure map exists first
447 Nav2D::MapGrid2D tmpMap; tmpMap.setMapName("temp_flag_map");
448 ret = imap->store_map(tmpMap); CHECK(ret);
449 ret = imap->clearMapTemporaryFlags("temp_flag_map"); CHECK(ret);
450 }
451
452 // 4. Compression toggle
453 {
454 bool ret = false;
455 ret = imap->enableMapsCompression(true); CHECK(ret);
456 ret = imap->enableMapsCompression(false); CHECK(ret);
457 }
458
459 }
460
461 // Failure paths and legacy formats
463 {
464 REQUIRE(imap != nullptr);
465
466 // 1. saveMapsCollection with empty storage should fail
467 {
468 bool ret = imap->clearAllMaps(); CHECK(ret);
469 ret = imap->saveMapsCollection("empty_collection.ini");
470 CHECK_FALSE(ret);
471 }
472
473 // 2. saveMapToDisk on non existing map -> fail
474 {
475 bool ret = imap->saveMapToDisk("ghost_map", "ghost.map");
476 CHECK_FALSE(ret);
477 }
478
479 // 3. loadMapsCollection missing file -> fail
480 {
481 bool ret = imap->loadMapsCollection("no_such_collection.ini");
482 CHECK_FALSE(ret);
483 }
484
485 // 4. loadMapFromDisk missing file -> fail
486 {
487 bool ret = imap->loadMapFromDisk("no_such_single.map");
488 CHECK_FALSE(ret);
489 }
490
491 // 5. clearMapTemporaryFlags on not-existing map -> fail
492 {
493 bool ret = imap->clearMapTemporaryFlags("definitely_missing_map");
494 CHECK_FALSE(ret);
495 }
496
497 // 6. loadLocationsAndExtras legacy versions 1,2,3 + bad version
498 {
499 // Version 1 file
500 {
501 std::ofstream f("loc_v1_test.ini");
502 f << "Version:\n";
503 f << "1\n";
504 f << "Locations:\n";
505 f << "loc1 mapX 1 2 0\n"; // name map x y theta
506 f << "Areas:\n";
507 f << "area1 mapX 1 0 0\n"; // name map size x y
508 f.close();
509 bool ret = imap->loadLocationsAndExtras("loc_v1_test.ini");
510 CHECK(ret);
511 CHECK(std::filesystem::remove("loc_v1_test.ini"));
512 }
513 // Version 2 file
514 {
515 std::ofstream f("loc_v2_test.ini");
516 f << "Version:\n";
517 f << "2\n";
518 f << "Locations:\n";
519 f << "loc2 mapY 3 4 0\n";
520 f << "Areas:\n";
521 f << "area2 mapY 1 1 1\n";
522 f << "Paths:\n";
523 f << "path1\n"; // empty path line
524 f.close();
525 bool ret = imap->loadLocationsAndExtras("loc_v2_test.ini");
526 CHECK(ret);
527 CHECK(std::filesystem::remove("loc_v2_test.ini"));
528 }
529 // Version 3 file (with descriptions)
530 {
531 std::ofstream f("loc_v3_test.ini");
532 f << "Version:\n";
533 f << "3\n";
534 f << "Locations:\n";
535 f << "loc3 mapZ 5 6 0 \"descL\"\n";
536 f << "Areas:\n";
537 f << "area3 mapZ 1 2 2 \"descA\"\n";
538 f << "Paths:\n";
539 f << "path3 ( mapZ 0 0 0 ) \"descP\"\n";
540 f.close();
541 bool ret = imap->loadLocationsAndExtras("loc_v3_test.ini");
542 CHECK(ret);
543 CHECK(std::filesystem::remove("loc_v3_test.ini"));
544 }
545 // Version 4 file
546 {
547 std::ofstream f("loc_v4_test.ini");
548 f << "Version:\n";
549 f << "4\n";
550 f << "Locations:\n";
551 f << "loc4 mapZ 5 6 0 \"descL\"\n";
552 f << "Objects:\n";
553 f << "obj4 mapZ 5 6 0 7 7 7 \"descO\"\n";
554 f << "Areas:\n";
555 f << "area4 mapZ 1 2 2 \"descA\"\n";
556 f << "Paths:\n";
557 f << "path4 ( mapZ 0 0 0 ) \"descP\"\n";
558 f.close();
559 bool ret = imap->loadLocationsAndExtras("loc_v4_test.ini");
560 CHECK(ret);
561 CHECK(std::filesystem::remove("loc_v4_test.ini"));
562 }
563 // Bad version file
564 {
565 std::ofstream f("loc_bad_version.ini");
566 f << "Version:\n";
567 f << "99\n"; // unsupported
568 f.close();
569 bool ret = imap->loadLocationsAndExtras("loc_bad_version.ini");
570 CHECK_FALSE(ret);
571 CHECK(std::filesystem::remove("loc_bad_version.ini"));
572 }
573 }
574 }
575
577 {
578 REQUIRE(imap != nullptr);
579 bool ret = imap->clearAllMaps(); CHECK(ret);
580
581 Nav2D::MapGrid2D m0; m0.setMapName("test_map0");
582 ret = imap->store_map(m0); CHECK(ret);
583 ret = imap->saveMapsCollection("maps_collection.ini"); CHECK(ret);
584 ret = imap->saveLocationsAndExtras("locations.ini"); CHECK(ret);
585 }
586
588 {
589 CHECK (remove_map_files("test_map0"));
590 CHECK (std::filesystem::remove("maps_collection.ini"));
591 CHECK (std::filesystem::remove("locations.ini"));
592 }
593}
594
595#endif
bool remove_map_files(std::string filename)
Definition IMap2DTest.h:23
double y
y position of the location [m], expressed in the map reference frame
double x
x position of the location [m], expressed in the map reference frame
IMap2D Interface.
Definition IMap2D.h:31
std::string toString() const
Returns text representation of the path.
Definition Map2DPath.cpp:42
A mini-server for performing network communication in the background.
void close() override
Stop port activity.
void exec_iMap2D_test_3(IMap2D *imap)
Definition IMap2DTest.h:331
void exec_iMap2D_test_1(IMap2D *imap)
Definition IMap2DTest.h:35
void remove_test_collection()
Definition IMap2DTest.h:587
void exec_iMap2D_test_4(IMap2D *imap)
Definition IMap2DTest.h:462
void exec_iMap2D_test_2(IMap2D *imap)
Definition IMap2DTest.h:108
void create_test_collection(IMap2D *imap)
Definition IMap2DTest.h:576
For streams capable of holding different kinds of content, check what they actually have.
An interface to the operating system, including Port based communication.
Definition OSTestMsg.cpp:13