mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-12-11 19:41:30 +00:00
Code Issues Projects Releases Packages Wiki Activity
subsurface/tests/testplan.cpp

957 lines
32 KiB
C++
Raw Normal View History

Add SPDX header to tests Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2017-04-27 18:21:27 +00:00
// SPDX-License-Identifier: GPL-2.0
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
#include "testplan.h"
Cleanup: move planner/deco related declarations planner/deco.h Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-05 18:43:06 +00:00
#include "core/deco.h"
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
#include "core/dive.h"
cleanup: break out event-related code into event.[c|h] In an effort to reduce the size of dive.h and dive.c, break out the event related functions. Moreover event-names were handled by the profile-code, collect that also in the new source files. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2020-10-25 08:14:16 +00:00
#include "core/event.h"
Convert qDebug() to report_info() in testing code Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-26 13:05:35 +00:00
#include "core/errorhelper.h"
Fix compilation with the new folder architecture A few more fixes for things that broke in commit 7be962bfc287 ("Move subsurface-core to core and qt-mobile to mobile-widgets"). [Dirk Hohndel: slightly edited and overlap with Linus' patch removed] Signed-off-by: Tomaz Canabrava <tomaz.canabrava@intel.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-04-05 17:22:00 +00:00
#include "core/planner.h"
#include "core/qthelper.h"
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
#include "core/subsurfacestartup.h"
#include "core/units.h"
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
#define DEBUG 1
Fix typo in test and some numbers With these values I reproduce the runtimes from the UI. Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-06 13:44:05 +00:00
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
// testing the dive plan algorithm
core: add constructor/destructor pairs to dive and divecomputer This allows us to use non-C member variables. Convert a number of pointers to unique_ptr<>s. Code in uemis-downloader.cpp had to be refactored, because it mixed owning and non-owning pointers. Mad. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-16 18:11:21 +00:00
static struct dive dive;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
static struct deco_state test_deco_state;
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
void setupPrefs()
{
preferences: use std::string in struct preferences This is a messy commit, because the "qPref" system relies heavily on QString, which means lots of conversions between the two worlds. Ultimately, I plan to base the preferences system on std::string and only convert to QString when pushing through Qt's property system or when writing into Qt's settings. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-13 20:59:32 +00:00
prefs = default_prefs;
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
prefs.ascrate50 = feet_to_mm(30) / 60;
prefs.ascrate75 = prefs.ascrate50;
prefs.ascratestops = prefs.ascrate50;
prefs.ascratelast6m = feet_to_mm(10) / 60;
prefs.last_stop = true;
}
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
void setupPrefsVpmb()
{
preferences: use std::string in struct preferences This is a messy commit, because the "qPref" system relies heavily on QString, which means lots of conversions between the two worlds. Ultimately, I plan to base the preferences system on std::string and only convert to QString when pushing through Qt's property system or when writing into Qt's settings. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-13 20:59:32 +00:00
prefs = default_prefs;
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
prefs.ascrate50 = 10000 / 60;
prefs.ascrate75 = prefs.ascrate50;
prefs.ascratestops = prefs.ascrate50;
prefs.ascratelast6m = prefs.ascrate50;
prefs.descrate = 99000 / 60;
prefs.last_stop = false;
Rename prefs.deco_mode to prefs.planner_deco_mode This is to avoid confusion with planner.display_deco_mode. When accessing the "current deco mode" use the decoMode() helper function. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2017-01-07 02:11:19 +00:00
prefs.planner_deco_mode = VPMB;
Rename conservatism_level to vpmb_conservatism Make the variable purpose less ambiguous Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2016-09-24 08:02:07 +00:00
prefs.vpmb_conservatism = 0;
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlan()
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.gfhigh = 100;
dp.gflow = 100;
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 15_percent, 45_percent};
struct gasmix ean36 = { 36_percent, 0_percent};
struct gasmix oxygen = { 100_percent, 0_percent};
pressure_t po2 = 1600_mbar;;
test: fix subtle bug in testplan.cpp testplan.cpp had a subtle bug since converting from a fixed-size cylinder table to a dynamic cylinder table. As noted in equipment.h, pointers to cylinders are *not* stable when the cylinder table grows. Therefore, a construct such as cylinder_t *cyl0 = get_or_create_cylinder(&dive, 0); cylinder_t *cyl1 = get_or_create_cylinder(&dive, 1); cylinder_t *cyl2 = get_or_create_cylinder(&dive, 2); can give dangling cyl0 and cyl1 pointers. This was not an issue with the old table code, since it had a rather liberal allocation pattern. However, when switching to std::vector<>, the problem becomes active. To "fix" this, simply access the highest index first. Of course, this should never be done in real code! Therefore, add a comment at each instance. Quickly checked all other get_or_create_cylinder() calls and they seemed to be safe. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 16:51:03 +00:00
// Note: we add the highest-index cylinder first, because
// pointers to cylinders are not stable when reallocating.
// For testing OK - don't do this in actual code!
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl2 = dive.get_or_create_cylinder(2);
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
cylinder_t *cyl1 = dive.get_or_create_cylinder(1);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 36_l;
cyl0->type.workingpressure = 232_bar;
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl1->gasmix = ean36;
cyl2->gasmix = oxygen;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
int droptime = M_OR_FT(79, 260) * 60 / M_OR_FT(23, 75);
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
plan_add_segment(dp, 0, dive.gas_mod(ean36, po2, M_OR_FT(3, 10)).mm, 1, 0, 1, OC);
plan_add_segment(dp, 0, dive.gas_mod(oxygen, po2, M_OR_FT(3, 10)).mm, 2, 0, 1, OC);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(79, 260), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 30 * 60 - droptime, M_OR_FT(79, 260), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanVpmb45m30mTx()
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.gfhigh = 100;
dp.gflow = 100;
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 21_percent, 35_percent};
struct gasmix ean50 = { 50_percent, 0_percent};
struct gasmix oxygen = { 100_percent, 0_percent};
pressure_t po2 = 1600_mbar;
test: fix subtle bug in testplan.cpp testplan.cpp had a subtle bug since converting from a fixed-size cylinder table to a dynamic cylinder table. As noted in equipment.h, pointers to cylinders are *not* stable when the cylinder table grows. Therefore, a construct such as cylinder_t *cyl0 = get_or_create_cylinder(&dive, 0); cylinder_t *cyl1 = get_or_create_cylinder(&dive, 1); cylinder_t *cyl2 = get_or_create_cylinder(&dive, 2); can give dangling cyl0 and cyl1 pointers. This was not an issue with the old table code, since it had a rather liberal allocation pattern. However, when switching to std::vector<>, the problem becomes active. To "fix" this, simply access the highest index first. Of course, this should never be done in real code! Therefore, add a comment at each instance. Quickly checked all other get_or_create_cylinder() calls and they seemed to be safe. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 16:51:03 +00:00
// Note: we add the highest-index cylinder first, because
// pointers to cylinders are not stable when reallocating.
// For testing OK - don't do this in actual code!
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl2 = dive.get_or_create_cylinder(2);
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
cylinder_t *cyl1 = dive.get_or_create_cylinder(1);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 24_l;
cyl0->type.workingpressure = 232_bar;
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl1->gasmix = ean50;
cyl2->gasmix = oxygen;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
int droptime = M_OR_FT(45, 150) * 60 / M_OR_FT(23, 75);
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
plan_add_segment(dp, 0, dive.gas_mod(ean50, po2, M_OR_FT(3, 10)).mm, 1, 0, 1, OC);
plan_add_segment(dp, 0, dive.gas_mod(oxygen, po2, M_OR_FT(3, 10)).mm, 2, 0, 1, OC);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(45, 150), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 30 * 60 - droptime, M_OR_FT(45, 150), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanVpmb60m10mTx()
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.gfhigh = 100;
dp.gflow = 100;
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 18_percent, 45_percent };
struct gasmix tx50_15 = { 50_percent, 15_percent };
struct gasmix oxygen = { 100_percent, 0_percent };
pressure_t po2 = 1600_mbar;
test: fix subtle bug in testplan.cpp testplan.cpp had a subtle bug since converting from a fixed-size cylinder table to a dynamic cylinder table. As noted in equipment.h, pointers to cylinders are *not* stable when the cylinder table grows. Therefore, a construct such as cylinder_t *cyl0 = get_or_create_cylinder(&dive, 0); cylinder_t *cyl1 = get_or_create_cylinder(&dive, 1); cylinder_t *cyl2 = get_or_create_cylinder(&dive, 2); can give dangling cyl0 and cyl1 pointers. This was not an issue with the old table code, since it had a rather liberal allocation pattern. However, when switching to std::vector<>, the problem becomes active. To "fix" this, simply access the highest index first. Of course, this should never be done in real code! Therefore, add a comment at each instance. Quickly checked all other get_or_create_cylinder() calls and they seemed to be safe. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 16:51:03 +00:00
// Note: we add the highest-index cylinder first, because
// pointers to cylinders are not stable when reallocating.
// For testing OK - don't do this in actual code!
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl2 = dive.get_or_create_cylinder(2);
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
cylinder_t *cyl1 = dive.get_or_create_cylinder(1);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 24_l;
cyl0->type.workingpressure = 232_bar;
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl1->gasmix = tx50_15;
cyl2->gasmix = oxygen;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
int droptime = M_OR_FT(60, 200) * 60 / M_OR_FT(23, 75);
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
plan_add_segment(dp, 0, dive.gas_mod(tx50_15, po2, M_OR_FT(3, 10)).mm, 1, 0, 1, OC);
plan_add_segment(dp, 0, dive.gas_mod(oxygen, po2, M_OR_FT(3, 10)).mm, 2, 0, 1, OC);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(60, 200), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 10 * 60 - droptime, M_OR_FT(60, 200), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanVpmb60m30minAir()
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 21_percent, 0_percent};
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 100_l;
cyl0->type.workingpressure = 232_bar;
dive.surface_pressure = 1_atm;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
int droptime = M_OR_FT(60, 200) * 60 / M_OR_FT(99, 330);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(60, 200), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 30 * 60 - droptime, M_OR_FT(60, 200), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanVpmb60m30minEan50()
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 21_percent, 0_percent };
struct gasmix ean50 = { 50_percent, 0_percent };
pressure_t po2 = 1600_mbar;
test: fix subtle bug in testplan.cpp testplan.cpp had a subtle bug since converting from a fixed-size cylinder table to a dynamic cylinder table. As noted in equipment.h, pointers to cylinders are *not* stable when the cylinder table grows. Therefore, a construct such as cylinder_t *cyl0 = get_or_create_cylinder(&dive, 0); cylinder_t *cyl1 = get_or_create_cylinder(&dive, 1); cylinder_t *cyl2 = get_or_create_cylinder(&dive, 2); can give dangling cyl0 and cyl1 pointers. This was not an issue with the old table code, since it had a rather liberal allocation pattern. However, when switching to std::vector<>, the problem becomes active. To "fix" this, simply access the highest index first. Of course, this should never be done in real code! Therefore, add a comment at each instance. Quickly checked all other get_or_create_cylinder() calls and they seemed to be safe. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 16:51:03 +00:00
// Note: we add the highest-index cylinder first, because
// pointers to cylinders are not stable when reallocating.
// For testing OK - don't do this in actual code!
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl1 = dive.get_or_create_cylinder(1);
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 36_l;
cyl0->type.workingpressure = 232_bar;
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl1->gasmix = ean50;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
dive.surface_pressure = 1_atm;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
int droptime = M_OR_FT(60, 200) * 60 / M_OR_FT(99, 330);
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
plan_add_segment(dp, 0, dive.gas_mod(ean50, po2, M_OR_FT(3, 10)).mm, 1, 0, 1, OC);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(60, 200), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 30 * 60 - droptime, M_OR_FT(60, 200), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanVpmb60m30minTx()
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 18_percent, 45_percent };
struct gasmix ean50 = { 50_percent, 0_percent };
pressure_t po2 = 1600_mbar;
test: fix subtle bug in testplan.cpp testplan.cpp had a subtle bug since converting from a fixed-size cylinder table to a dynamic cylinder table. As noted in equipment.h, pointers to cylinders are *not* stable when the cylinder table grows. Therefore, a construct such as cylinder_t *cyl0 = get_or_create_cylinder(&dive, 0); cylinder_t *cyl1 = get_or_create_cylinder(&dive, 1); cylinder_t *cyl2 = get_or_create_cylinder(&dive, 2); can give dangling cyl0 and cyl1 pointers. This was not an issue with the old table code, since it had a rather liberal allocation pattern. However, when switching to std::vector<>, the problem becomes active. To "fix" this, simply access the highest index first. Of course, this should never be done in real code! Therefore, add a comment at each instance. Quickly checked all other get_or_create_cylinder() calls and they seemed to be safe. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 16:51:03 +00:00
// Note: we add the highest-index cylinder first, because
// pointers to cylinders are not stable when reallocating.
// For testing OK - don't do this in actual code!
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl1 = dive.get_or_create_cylinder(1);
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 36_l;
cyl0->type.workingpressure = 232_bar;
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl1->gasmix = ean50;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
dive.surface_pressure = 1_atm;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
int droptime = M_OR_FT(60, 200) * 60 / M_OR_FT(99, 330);
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
plan_add_segment(dp, 0, dive.gas_mod(ean50, po2, M_OR_FT(3, 10)).mm, 1, 0, 1, OC);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(60, 200), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 30 * 60 - droptime, M_OR_FT(60, 200), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanVpmbMultiLevelAir()
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 21_percent, 0_percent };
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 200_l;
cyl0->type.workingpressure = 232_bar;
dive.surface_pressure = 1_atm;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
int droptime = M_OR_FT(20, 66) * 60 / M_OR_FT(99, 330);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(20, 66), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 10 * 60 - droptime, M_OR_FT(20, 66), 0, 0, 1, OC);
plan_add_segment(dp, 1 * 60, M_OR_FT(60, 200), 0, 0, 1, OC);
plan_add_segment(dp, 29 * 60, M_OR_FT(60, 200), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanVpmb100m60min()
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 18_percent, 45_percent };
struct gasmix ean50 = { 50_percent, 0_percent };
struct gasmix oxygen = { 100_percent, 0_percent };
pressure_t po2 = 1600_mbar;
test: fix subtle bug in testplan.cpp testplan.cpp had a subtle bug since converting from a fixed-size cylinder table to a dynamic cylinder table. As noted in equipment.h, pointers to cylinders are *not* stable when the cylinder table grows. Therefore, a construct such as cylinder_t *cyl0 = get_or_create_cylinder(&dive, 0); cylinder_t *cyl1 = get_or_create_cylinder(&dive, 1); cylinder_t *cyl2 = get_or_create_cylinder(&dive, 2); can give dangling cyl0 and cyl1 pointers. This was not an issue with the old table code, since it had a rather liberal allocation pattern. However, when switching to std::vector<>, the problem becomes active. To "fix" this, simply access the highest index first. Of course, this should never be done in real code! Therefore, add a comment at each instance. Quickly checked all other get_or_create_cylinder() calls and they seemed to be safe. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 16:51:03 +00:00
// Note: we add the highest-index cylinder first, because
// pointers to cylinders are not stable when reallocating.
// For testing OK - don't do this in actual code!
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl2 = dive.get_or_create_cylinder(2);
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
cylinder_t *cyl1 = dive.get_or_create_cylinder(1);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 200_l;
cyl0->type.workingpressure = 232_bar;
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl1->gasmix = ean50;
cyl2->gasmix = oxygen;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
dive.surface_pressure = 1_atm;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
int droptime = M_OR_FT(100, 330) * 60 / M_OR_FT(99, 330);
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
plan_add_segment(dp, 0, dive.gas_mod(ean50, po2, M_OR_FT(3, 10)).mm, 1, 0, 1, OC);
plan_add_segment(dp, 0, dive.gas_mod(oxygen, po2, M_OR_FT(3, 10)).mm, 2, 0, 1, OC);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(100, 330), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 60 * 60 - droptime, M_OR_FT(100, 330), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanVpmb100m10min()
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 18_percent, 45_percent };
struct gasmix ean50 = { 50_percent, 0_percent};
struct gasmix oxygen = { 100_percent, 0_percent};
pressure_t po2 = 1600_mbar;
test: fix subtle bug in testplan.cpp testplan.cpp had a subtle bug since converting from a fixed-size cylinder table to a dynamic cylinder table. As noted in equipment.h, pointers to cylinders are *not* stable when the cylinder table grows. Therefore, a construct such as cylinder_t *cyl0 = get_or_create_cylinder(&dive, 0); cylinder_t *cyl1 = get_or_create_cylinder(&dive, 1); cylinder_t *cyl2 = get_or_create_cylinder(&dive, 2); can give dangling cyl0 and cyl1 pointers. This was not an issue with the old table code, since it had a rather liberal allocation pattern. However, when switching to std::vector<>, the problem becomes active. To "fix" this, simply access the highest index first. Of course, this should never be done in real code! Therefore, add a comment at each instance. Quickly checked all other get_or_create_cylinder() calls and they seemed to be safe. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 16:51:03 +00:00
// Note: we add the highest-index cylinder first, because
// pointers to cylinders are not stable when reallocating.
// For testing OK - don't do this in actual code!
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl2 = dive.get_or_create_cylinder(2);
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
cylinder_t *cyl1 = dive.get_or_create_cylinder(1);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 60_l;
cyl0->type.workingpressure = 232_bar;
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl1->gasmix = ean50;
cyl2->gasmix = oxygen;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
dive.surface_pressure = 1_atm;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
int droptime = M_OR_FT(100, 330) * 60 / M_OR_FT(99, 330);
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
plan_add_segment(dp, 0, dive.gas_mod(ean50, po2, M_OR_FT(3, 10)).mm, 1, 0, 1, OC);
plan_add_segment(dp, 0, dive.gas_mod(oxygen, po2, M_OR_FT(3, 10)).mm, 2, 0, 1, OC);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(100, 330), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 10 * 60 - droptime, M_OR_FT(100, 330), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanVpmb30m20min()
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 21_percent, 0_percent };
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 36_l;
cyl0->type.workingpressure = 232_bar;
dive.surface_pressure = 1_atm;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
int droptime = M_OR_FT(30, 100) * 60 / M_OR_FT(18, 60);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(30, 100), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 20 * 60 - droptime, M_OR_FT(30, 100), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanVpmb100mTo70m30min()
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix bottomgas = { 12_percent, 65_percent };
struct gasmix tx21_35 = { 21_percent, 35_percent };
struct gasmix ean50 = { 50_percent, 0_percent };
struct gasmix oxygen = { 100_percent, 0_percent };
pressure_t po2 = 1600_mbar;
test: fix subtle bug in testplan.cpp testplan.cpp had a subtle bug since converting from a fixed-size cylinder table to a dynamic cylinder table. As noted in equipment.h, pointers to cylinders are *not* stable when the cylinder table grows. Therefore, a construct such as cylinder_t *cyl0 = get_or_create_cylinder(&dive, 0); cylinder_t *cyl1 = get_or_create_cylinder(&dive, 1); cylinder_t *cyl2 = get_or_create_cylinder(&dive, 2); can give dangling cyl0 and cyl1 pointers. This was not an issue with the old table code, since it had a rather liberal allocation pattern. However, when switching to std::vector<>, the problem becomes active. To "fix" this, simply access the highest index first. Of course, this should never be done in real code! Therefore, add a comment at each instance. Quickly checked all other get_or_create_cylinder() calls and they seemed to be safe. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 16:51:03 +00:00
// Note: we add the highest-index cylinder first, because
// pointers to cylinders are not stable when reallocating.
// For testing OK - don't do this in actual code!
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl3 = dive.get_or_create_cylinder(3);
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
cylinder_t *cyl1 = dive.get_or_create_cylinder(1);
cylinder_t *cyl2 = dive.get_or_create_cylinder(2);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = bottomgas;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 36_l;
cyl0->type.workingpressure = 232_bar;
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl1->gasmix = tx21_35;
cyl2->gasmix = ean50;
cyl3->gasmix = oxygen;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
dive.surface_pressure = 1_atm;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
int droptime = M_OR_FT(100, 330) * 60 / M_OR_FT(18, 60);
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
plan_add_segment(dp, 0, dive.gas_mod(tx21_35, po2, M_OR_FT(3, 10)).mm, 1, 0, 1, OC);
plan_add_segment(dp, 0, dive.gas_mod(ean50, po2, M_OR_FT(3, 10)).mm, 2, 0, 1, OC);
plan_add_segment(dp, 0, dive.gas_mod(oxygen, po2, M_OR_FT(3, 10)).mm, 3, 0, 1, OC);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, droptime, M_OR_FT(100, 330), 0, 0, 1, OC);
Whitespace cleanup tests Again, entirely script based. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2018-07-25 19:39:04 +00:00
plan_add_segment(dp, 20 * 60 - droptime, M_OR_FT(100, 330), 0, 0, 1, OC);
plan_add_segment(dp, 3 * 60, M_OR_FT(70, 230), 0, 0, 1, OC);
Add planner infra structure for bailout Add a divemode column to the planner model and a corresponding field to struct divepoint and fill it in the corresponding functions. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-03-28 20:50:28 +00:00
plan_add_segment(dp, (30 - 20 - 3) * 60, M_OR_FT(70, 230), 0, 0, 1, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
}
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
/* This tests handling different gases in the manually entered part of the dive */
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanSeveralGases()
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
struct gasmix ean36 = { 36_percent, 0_percent };
struct gasmix tx11_50 = { 11_percent, 50_percent };
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
test: fix subtle bug in testplan.cpp testplan.cpp had a subtle bug since converting from a fixed-size cylinder table to a dynamic cylinder table. As noted in equipment.h, pointers to cylinders are *not* stable when the cylinder table grows. Therefore, a construct such as cylinder_t *cyl0 = get_or_create_cylinder(&dive, 0); cylinder_t *cyl1 = get_or_create_cylinder(&dive, 1); cylinder_t *cyl2 = get_or_create_cylinder(&dive, 2); can give dangling cyl0 and cyl1 pointers. This was not an issue with the old table code, since it had a rather liberal allocation pattern. However, when switching to std::vector<>, the problem becomes active. To "fix" this, simply access the highest index first. Of course, this should never be done in real code! Therefore, add a comment at each instance. Quickly checked all other get_or_create_cylinder() calls and they seemed to be safe. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 16:51:03 +00:00
// Note: we add the highest-index cylinder first, because
// pointers to cylinders are not stable when reallocating.
// For testing OK - don't do this in actual code!
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl1 = dive.get_or_create_cylinder(1);
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl0->gasmix = ean36;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 36_l;
cyl0->type.workingpressure = 232_bar;
Core: remove MAX_CYLINDERS restriction Instead of using fixed size arrays, use a new cylinder_table structure. The code copies the weightsystem code, but is significantly more complex because cylinders are such an integral part of the core. Two functions to access the cylinders were added: get_cylinder() and get_or_create_cylinder() The former does a simple array access and supposes that the cylinder exists. The latter is used by the parser(s) and if a cylinder with the given id does not exist, cylinders up to that id are generated. One point will make C programmers cringe: the cylinder structure is passed by value. This is due to the way the table-macros work. A refactoring of the table macros is planned. It has to be noted that the size of a cylinder_t is 64 bytes, i.e. 8 long words on a 64-bit architecture, so passing on the stack is probably not even significantly slower than passing as reference. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2019-08-04 16:44:57 +00:00
cyl1->gasmix = tx11_50;
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
dive.surface_pressure = 1_atm;
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
plan_add_segment(dp, 120, 40000, 0, 0, true, OC);
plan_add_segment(dp, 18 * 60, 40000, 0, 0, true, OC);
plan_add_segment(dp, 10 * 60, 10000, 1, 0, true, OC);
plan_add_segment(dp, 5 * 60, 10000, 0, 0, true, OC);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
}
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan setupPlanCcr()
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
{
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
diveplan dp;
dp.salinity = 10300;
units: replace SURFACE_PRESSURE by 1_atm Moreover, convert diveplan::surface_pressure from int to pressure_t. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-09 11:55:37 +00:00
dp.surface_pressure = 1_atm;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp.gflow = 50;
dp.gfhigh = 70;
dp.bottomsac = prefs.bottomsac;
dp.decosac = prefs.decosac;
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
pressure_t po2 = 1600_mbar;
struct gasmix diluent = { 20_percent, 21_percent};
struct gasmix ean53 = { 53_percent, 0_percent};
struct gasmix tx19_33 = { 19_percent, 33_percent};
test: fix subtle bug in testplan.cpp testplan.cpp had a subtle bug since converting from a fixed-size cylinder table to a dynamic cylinder table. As noted in equipment.h, pointers to cylinders are *not* stable when the cylinder table grows. Therefore, a construct such as cylinder_t *cyl0 = get_or_create_cylinder(&dive, 0); cylinder_t *cyl1 = get_or_create_cylinder(&dive, 1); cylinder_t *cyl2 = get_or_create_cylinder(&dive, 2); can give dangling cyl0 and cyl1 pointers. This was not an issue with the old table code, since it had a rather liberal allocation pattern. However, when switching to std::vector<>, the problem becomes active. To "fix" this, simply access the highest index first. Of course, this should never be done in real code! Therefore, add a comment at each instance. Quickly checked all other get_or_create_cylinder() calls and they seemed to be safe. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-31 16:51:03 +00:00
// Note: we add the highest-index cylinder first, because
// pointers to cylinders are not stable when reallocating.
// For testing OK - don't do this in actual code!
core: move get_or_create_cylinder() to struct dive Other cylinder-creation functions were already there. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 20:39:52 +00:00
cylinder_t *cyl2 = dive.get_or_create_cylinder(2);
cylinder_t *cyl0 = dive.get_or_create_cylinder(0);
cylinder_t *cyl1 = dive.get_or_create_cylinder(1);
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
cyl0->gasmix = diluent;
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
cyl0->depth = dive.gas_mod(diluent, po2, M_OR_FT(3, 10));
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cyl0->type.size = 3_l;
cyl0->type.workingpressure = 200_bar;
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
cyl0->cylinder_use = DILUENT;
cyl1->gasmix = ean53;
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
cyl1->depth = dive.gas_mod(ean53, po2, M_OR_FT(3, 10));
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
cyl2->gasmix = tx19_33;
core: move get_max_mod() and get_max_mnd() to struct dive Feels natural in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-30 14:17:20 +00:00
cyl2->depth = dive.gas_mod(tx19_33, po2, M_OR_FT(3, 10));
planner: get rid of global displayed_dive variable Allocate the dive in the planner. This is all a bit convoluted and needs more cleanup. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2022-11-05 19:27:49 +00:00
reset_cylinders(&dive, true);
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
plan_add_segment(dp, 0, cyl1->depth.mm, 1, 0, false, OC);
plan_add_segment(dp, 0, cyl2->depth.mm, 2, 0, false, OC);
plan_add_segment(dp, 20 * 60, M_OR_FT(60, 197), 0, 1300, true, CCR);
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
return dp;
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
}
VPM-B Tests: Compare against known Subsurface runtime We should compare the calculated runtime against the runtime previously calculated by Subsurface, expecting them to match exactly, in order to detect if a change has been made. We still compare against a benchmark, allowing some difference. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 12:30:48 +00:00
/* We compare the calculated runtimes against two values:
* - Known runtime calculated by Subsurface previously (to detect if anything has changed)
* - Benchmark runtime (we should be close, but not always exactly the same)
*/
bool compareDecoTime(int actualRunTimeSeconds, int benchmarkRunTimeSeconds, int knownSsrfRunTimeSeconds)
Dive planner tests: pass dives that are close to expected duration Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 21:51:57 +00:00
{
VPM-B Tests: Compare against known Subsurface runtime We should compare the calculated runtime against the runtime previously calculated by Subsurface, expecting them to match exactly, in order to detect if a change has been made. We still compare against a benchmark, allowing some difference. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 12:30:48 +00:00
bool result;
Dive planner tests: pass dives that are close to expected duration Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 21:51:57 +00:00
// If the calculated run time equals the expected run time, do a simple comparison
VPM-B Tests: Compare against known Subsurface runtime We should compare the calculated runtime against the runtime previously calculated by Subsurface, expecting them to match exactly, in order to detect if a change has been made. We still compare against a benchmark, allowing some difference. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 12:30:48 +00:00
if (actualRunTimeSeconds == benchmarkRunTimeSeconds) {
TestPlan: Do not re-declare bool result Fixing this error makes TestPlan pass again. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-30 05:40:34 +00:00
result = true;
Dive planner tests: pass dives that are close to expected duration Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 21:51:57 +00:00
} else {
/* We want the difference between the expected and calculated total run time to be not more than
* 1% of total run time + 1 minute */
int permilDifferenceAllowed = 1 * 10;
int absoluteDifferenceAllowedSeconds = 60;
Fix double to int truncation in C++ code Wfloat-conversion enabled for C++ part of the code Fix warnings raised by the flag using lrint Original issue reported on the mailing list: The ascent/descent rates are sometimes not what is expected. E.g. setting the ascent rate to 10m/min results in an actual ascent rate of 9m/min. This is due to truncating the ascent rate preference, then effectively rounding up the time to reach each stop to 2s intervals. The result being that setting the ascent rate to 10m/min results in 20s to ascend 3m (9m/min), when it should be exactly 18s. Reported-by: John Smith <noseygit@hotmail.com> Reported-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Jeremie Guichard <djebrest@gmail.com>
2017-03-23 01:13:49 +00:00
int totalDifferenceAllowed = lrint(0.001 * permilDifferenceAllowed * benchmarkRunTimeSeconds + absoluteDifferenceAllowedSeconds);
VPM-B Tests: Compare against known Subsurface runtime We should compare the calculated runtime against the runtime previously calculated by Subsurface, expecting them to match exactly, in order to detect if a change has been made. We still compare against a benchmark, allowing some difference. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 12:30:48 +00:00
int totalDifference = abs(actualRunTimeSeconds - benchmarkRunTimeSeconds);
Dive planner tests: pass dives that are close to expected duration Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 21:51:57 +00:00
Convert qDebug() to report_info() in testing code Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-26 13:05:35 +00:00
report_info("Calculated run time = %d seconds", actualRunTimeSeconds);
report_info("Expected run time = %d seconds", benchmarkRunTimeSeconds);
report_info("Allowed time difference is %g percent plus %d seconds = %d seconds",
Dive planner tests: pass dives that are close to expected duration Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 21:51:57 +00:00
permilDifferenceAllowed * 0.1, absoluteDifferenceAllowedSeconds, totalDifferenceAllowed);
Convert qDebug() to report_info() in testing code Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-26 13:05:35 +00:00
report_info("total difference = %d seconds", totalDifference);
Dive planner tests: pass dives that are close to expected duration Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 21:51:57 +00:00
TestPlan: Do not re-declare bool result Fixing this error makes TestPlan pass again. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-30 05:40:34 +00:00
result = (totalDifference <= totalDifferenceAllowed);
VPM-B Tests: Compare against known Subsurface runtime We should compare the calculated runtime against the runtime previously calculated by Subsurface, expecting them to match exactly, in order to detect if a change has been made. We still compare against a benchmark, allowing some difference. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 12:30:48 +00:00
}
if ((knownSsrfRunTimeSeconds > 0) && (actualRunTimeSeconds != knownSsrfRunTimeSeconds)) {
Convert qDebug() to report_info() in testing code Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-26 13:05:35 +00:00
report_error("Calculated run time does not match known Subsurface runtime");
report_error("Calculated runtime: %d", actualRunTimeSeconds);
report_error("Known Subsurface runtime: %d", knownSsrfRunTimeSeconds);
Dive planner tests: pass dives that are close to expected duration Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 21:51:57 +00:00
}
VPM-B Tests: Compare against known Subsurface runtime We should compare the calculated runtime against the runtime previously calculated by Subsurface, expecting them to match exactly, in order to detect if a change has been made. We still compare against a benchmark, allowing some difference. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 12:30:48 +00:00
return result;
Dive planner tests: pass dives that are close to expected duration Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 21:51:57 +00:00
}
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
void TestPlan::testMetric()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
setupPrefs();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
Rename prefs.deco_mode to prefs.planner_deco_mode This is to avoid confusion with planner.display_deco_mode. When accessing the "current deco mode" use the decoMode() helper function. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2017-01-07 02:11:19 +00:00
prefs.planner_deco_mode = BUEHLMANN;
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlan();
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 148l);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(dive.dcs[0].events.size() >= 2);
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
// check first gas change to EAN36 at 33m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
struct event *ev = &dive.dcs[0].events[0];
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
QCOMPARE(ev->gas.index, 1);
QCOMPARE(ev->value, 36);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 33000);
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
// check second gas change to Oxygen at 6m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
ev = &dive.dcs[0].events[1];
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
QVERIFY(ev != NULL);
QCOMPARE(ev->gas.index, 2);
QCOMPARE(ev->value, 100);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 6000);
Fix typo in saturation/desatureation rates This patch eliminates the difference between the saturation and desaturation rates. This was probably once meant as a conservative measure but the desaturation rate was increased rather than the saturation rate (which is probably a typo, as reported by Stefan). Since there is no good basis for this anyway, this patch sets both factors to 1.0 (and if accepted the whole factor business should be removed). This makes our deco times slightly longer. But in the past, we had introduced a 1.2% fudge factor in the critical radius calculation to add conservatism and match the benchmark better. Removing this fudge factor brings us close to the benchmarks. Expected test values updated. Reported-by: Stefan <sjti@gmx.net> Signed-off-by: Robert C. Helling <helling@atdotde.de>
2017-02-19 09:28:55 +00:00
// check expected run time of 109 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 109u * 60u, 109u * 60u));
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
}
void TestPlan::testImperial()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
setupPrefs();
prefs.unit_system = IMPERIAL;
prefs.units.length = units::FEET;
Rename prefs.deco_mode to prefs.planner_deco_mode This is to avoid confusion with planner.display_deco_mode. When accessing the "current deco mode" use the decoMode() helper function. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2017-01-07 02:11:19 +00:00
prefs.planner_deco_mode = BUEHLMANN;
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlan();
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 155l);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(dive.dcs[0].events.size() >= 2);
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
// check first gas change to EAN36 at 33m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
struct event *ev = &dive.dcs[0].events[0];
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
QCOMPARE(ev->gas.index, 1);
QCOMPARE(ev->value, 36);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 33528);
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
// check second gas change to Oxygen at 6m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
ev = &dive.dcs[0].events[1];
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
QVERIFY(ev != NULL);
QCOMPARE(ev->gas.index, 2);
QCOMPARE(ev->value, 100);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 6096);
Fix typo in saturation/desatureation rates This patch eliminates the difference between the saturation and desaturation rates. This was probably once meant as a conservative measure but the desaturation rate was increased rather than the saturation rate (which is probably a typo, as reported by Stefan). Since there is no good basis for this anyway, this patch sets both factors to 1.0 (and if accepted the whole factor business should be removed). This makes our deco times slightly longer. But in the past, we had introduced a 1.2% fudge factor in the critical radius calculation to add conservatism and match the benchmark better. Removing this fudge factor brings us close to the benchmarks. Expected test values updated. Reported-by: Stefan <sjti@gmx.net> Signed-off-by: Robert C. Helling <helling@atdotde.de>
2017-02-19 09:28:55 +00:00
// check expected run time of 111 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 111u * 60u - 2u, 111u * 60u - 2u));
Add simple test for the dive planner This sets up a standard dive scenario (30 minutes at 260ft/79m, EAN36 and Oxygen as deco gases, last stop at 20ft/6m) and calls the planner to set up a dive plan given certain standard gases. Instead of trying to verify the complete plans it checks that we switch to the deco gases at the right depth and the complete duration of the dive matches our expectation. The test intentionally fails right now for imperial as we have the wrong switch depth for Oxygen. See how useful tests are? On the downside, the test does NOT produce the same plan as Subsurface when I try to create a consistent setup for both - and I have not been able to figure out why. There must be some other parameters that I'm not setting, but I haven't identified them, yet. It's very small differences, for example in the metric case the stops at 21m, 9m, and 6m are each one minute shorter in the test than it what Subsurface calculates. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-07-04 16:12:54 +00:00
}
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
void TestPlan::testVpmbMetric45m30minTx()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
setupPrefsVpmb();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanVpmb45m30mTx();
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
#endif
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 108l);
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check benchmark run time of 141 minutes, and known Subsurface runtime of 139 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
//QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 141u * 60u + 20u, 139u * 60u + 20u));
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
}
void TestPlan::testVpmbMetric60m10minTx()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
setupPrefsVpmb();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanVpmb60m10mTx();
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
#endif
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 162l);
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check benchmark run time of 141 minutes, and known Subsurface runtime of 139 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
//QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 141u * 60u + 20u, 139u * 60u + 20u));
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
}
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
void TestPlan::testVpmbMetric60m30minAir()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
setupPrefsVpmb();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanVpmb60m30minAir();
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 180l);
VPM-B Tests: Output first ceiling This is useful for determining why we calculate a difference profile Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 02:05:39 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
TestPlan: update known Subsurface runtimes The purpose of testing against known Subsurface runtimes is to warn (when test is run in verbose mode) if the runtime has altered. Before the next release, we should update the known Subsurface runtimes to match current behaviour, so we are alerted when we change something during the next release cycle. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-06 11:41:40 +00:00
// check benchmark run time of 141 minutes, and known Subsurface runtime of 139 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 141u * 60u + 20u, 139u * 60u + 20u));
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
}
void TestPlan::testVpmbMetric60m30minEan50()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
setupPrefsVpmb();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanVpmb60m30minEan50();
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 155l);
VPM-B Tests: Output first ceiling This is useful for determining why we calculate a difference profile Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 02:05:39 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(dive.dcs[0].events.size() >= 1);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
// check first gas change to EAN50 at 21m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
struct event *ev = &dive.dcs[0].events[0];
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
QCOMPARE(ev->gas.index, 1);
QCOMPARE(ev->value, 50);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 21000);
VPM-B Tests: Compare against known Subsurface runtime We should compare the calculated runtime against the runtime previously calculated by Subsurface, expecting them to match exactly, in order to detect if a change has been made. We still compare against a benchmark, allowing some difference. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 12:30:48 +00:00
// check benchmark run time of 95 minutes, and known Subsurface runtime of 96 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 95u * 60u + 20u, 96u * 60u + 20u));
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
}
void TestPlan::testVpmbMetric60m30minTx()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
setupPrefsVpmb();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanVpmb60m30minTx();
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 159l);
VPM-B Tests: Output first ceiling This is useful for determining why we calculate a difference profile Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 02:05:39 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
// check first gas change to EAN50 at 21m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(dive.dcs[0].events.size() >= 1);
struct event *ev = &dive.dcs[0].events[0];
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
QCOMPARE(ev->gas.index, 1);
QCOMPARE(ev->value, 50);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 21000);
TestPlan: update known Subsurface runtimes The purpose of testing against known Subsurface runtimes is to warn (when test is run in verbose mode) if the runtime has altered. Before the next release, we should update the known Subsurface runtimes to match current behaviour, so we are alerted when we change something during the next release cycle. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-06 11:41:40 +00:00
// check benchmark run time of 89 minutes, and known Subsurface runtime of 89 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 89u * 60u + 20u, 89u * 60u + 20u));
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
}
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
void TestPlan::testVpmbMetric100m60min()
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
setupPrefsVpmb();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanVpmb100m60min();
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 157l);
VPM-B Tests: Output first ceiling This is useful for determining why we calculate a difference profile Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 02:05:39 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(dive.dcs[0].events.size() >= 2);
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
// check first gas change to EAN50 at 21m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
struct event *ev = &dive.dcs[0].events[0];
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
QCOMPARE(ev->gas.index, 1);
QCOMPARE(ev->value, 50);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 21000);
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
// check second gas change to Oxygen at 6m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
ev = &dive.dcs[0].events[1];
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
QVERIFY(ev != NULL);
QCOMPARE(ev->gas.index, 2);
QCOMPARE(ev->value, 100);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 6000);
TestPlan: update known Subsurface runtimes The purpose of testing against known Subsurface runtimes is to warn (when test is run in verbose mode) if the runtime has altered. Before the next release, we should update the known Subsurface runtimes to match current behaviour, so we are alerted when we change something during the next release cycle. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-06 11:41:40 +00:00
// check benchmark run time of 311 minutes, and known Subsurface runtime of 314 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 311u * 60u + 20u, 315u * 60u + 20u));
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
}
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
void TestPlan::testMultipleGases()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
setupPrefsVpmb();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanSeveralGases();
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
#endif
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
gasmix gas = dive.get_gasmix_at_time(dive.dcs[0], 20_min + 1_sec);
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
QCOMPARE(get_o2(gas), 110);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 2480u, 2480u));
A test for gases used in the planner This tests for the planner getting the gases in the manually entered part of the dive wrong (as here: from incorrect value returned by get_gasmix_at_time. Signed-off-by: Robert C. Helling <helling@atdotde.de>
2018-10-30 10:55:11 +00:00
}
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
void TestPlan::testVpmbMetricMultiLevelAir()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
setupPrefsVpmb();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanVpmbMultiLevelAir();
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 101l);
VPM-B Tests: Output first ceiling This is useful for determining why we calculate a difference profile Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 02:05:39 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
TestPlan: update known Subsurface runtimes The purpose of testing against known Subsurface runtimes is to warn (when test is run in verbose mode) if the runtime has altered. Before the next release, we should update the known Subsurface runtimes to match current behaviour, so we are alerted when we change something during the next release cycle. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-06 11:41:40 +00:00
// check benchmark run time of 167 minutes, and known Subsurface runtime of 169 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 167u * 60u + 20u, 169u * 60u + 20u));
VPM-B: Add more planner tests Add more VPM-B planner tests. The "expected" total run time is taken as the total run time produced by the Fortran VPM-B program. For all these tests, the results are within two minutes, which is a good result, but most are classified as a "fail". Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-25 14:33:17 +00:00
}
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
void TestPlan::testVpmbMetric100m10min()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
setupPrefsVpmb();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanVpmb100m10min();
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 175l);
VPM-B Tests: Output first ceiling This is useful for determining why we calculate a difference profile Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-29 02:05:39 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(dive.dcs[0].events.size() >= 2);
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
// check first gas change to EAN50 at 21m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
struct event *ev = &dive.dcs[0].events[0];
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
QVERIFY(ev != NULL);
QCOMPARE(ev->gas.index, 1);
QCOMPARE(ev->value, 50);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 21000);
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
// check second gas change to Oxygen at 6m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
ev = &dive.dcs[0].events[1];
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
QVERIFY(ev != NULL);
QCOMPARE(ev->gas.index, 2);
QCOMPARE(ev->value, 100);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 6000);
TestPlan: update known Subsurface runtimes The purpose of testing against known Subsurface runtimes is to warn (when test is run in verbose mode) if the runtime has altered. Before the next release, we should update the known Subsurface runtimes to match current behaviour, so we are alerted when we change something during the next release cycle. Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-10-06 11:41:40 +00:00
// check benchmark run time of 58 minutes, and known Subsurface runtime of 57 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 58u * 60u + 20u, 57u * 60u + 20u));
Test another VPM-B dive plan This adds a test for 100 m for 60 min dive on trimix using VPM-B Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-24 21:37:20 +00:00
}
Add a test for the VPM-B mode of the planner Signed-off-by: Robert C. Helling <helling@atdotde.de> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-08-23 14:08:04 +00:00
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
/* This tests that a previously calculated plan isn't affecting the calculations of the next plan.
* It is NOT a 'repetitive dive' test (i.e. with a surface interval and considering tissue
* saturation from the previous dive).
*/
void TestPlan::testVpmbMetricRepeat()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
setupPrefsVpmb();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanVpmb30m20min();
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 61l);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
Fix typo in saturation/desatureation rates This patch eliminates the difference between the saturation and desaturation rates. This was probably once meant as a conservative measure but the desaturation rate was increased rather than the saturation rate (which is probably a typo, as reported by Stefan). Since there is no good basis for this anyway, this patch sets both factors to 1.0 (and if accepted the whole factor business should be removed). This makes our deco times slightly longer. But in the past, we had introduced a 1.2% fudge factor in the critical radius calculation to add conservatism and match the benchmark better. Removing this fudge factor brings us close to the benchmarks. Expected test values updated. Reported-by: Stefan <sjti@gmx.net> Signed-off-by: Robert C. Helling <helling@atdotde.de>
2017-02-19 09:28:55 +00:00
// check benchmark run time of 27 minutes, and known Subsurface runtime of 28 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 27u * 60u + 20u, 27u * 60u + 20u));
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
int firstDiveRunTimeSeconds = dive.dcs[0].duration.seconds;
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
testPlan = setupPlanVpmb100mTo70m30min();
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 80l);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(dive.dcs[0].events.size() >= 3);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
// check first gas change to 21/35 at 66m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
struct event *ev = &dive.dcs[0].events[0];
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
QVERIFY(ev != NULL);
QCOMPARE(ev->gas.index, 1);
QCOMPARE(ev->gas.mix.o2.permille, 210);
QCOMPARE(ev->gas.mix.he.permille, 350);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 66000);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
// check second gas change to EAN50 at 21m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
ev = &dive.dcs[0].events[1];
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
QCOMPARE(ev->gas.index, 2);
QCOMPARE(ev->value, 50);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 21000);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
// check third gas change to Oxygen at 6m
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
ev = &dive.dcs[0].events[2];
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
QVERIFY(ev != NULL);
QCOMPARE(ev->gas.index, 3);
QCOMPARE(ev->value, 100);
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QCOMPARE(get_depth_at_time(&dive.dcs[0], ev->time.seconds), 6000);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
// we don't have a benchmark, known Subsurface runtime is 126 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 127u * 60u + 20u, 127u * 60u + 20u));
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
testPlan = setupPlanVpmb30m20min();
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, 1, 0);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
#endif
Tests for minimum gas Add automatic tests in TestPlan for minimum gas: - Copy minimum gas result (pressure) to diveplan. - Add cylinder size and working pressure for bottom gas to every dive in TestPlan Hint: Unrealistic cylinder sizes (100l, 200l) have to be used for the very long and deep dives in TestPlan - Add minimum gas check for every dive - Add two additional test dives in TestPlan which produce sane minimum gas results with 24l tank Hint: Deco check for these new dives is commented out at the moment Signed-off-by: Stefan Fuchs <sfuchs@gmx.de>
2017-03-15 21:28:36 +00:00
// check minimum gas result
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
dp = std::find_if(testPlan.dp.begin(), testPlan.dp.end(), [](auto &dp) { return dp.minimum_gas.mbar != 0; });
tests: shut up coverity warnings It wants us to test for end of container when finding elements. That is of course reasonable in "production" code, but a bit pointless in the testing code. Oh well. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-10 19:32:09 +00:00
QCOMPARE(lrint(dp == testPlan.dp.end() ? 0.0 : dp->minimum_gas.mbar / 1000.0), 61l);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
// print first ceiling
core: move *_to_depth() functions into struct dive Seems logical in a C++ code base. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-20 20:47:16 +00:00
printf("First ceiling %.1f m\n", dive.mbar_to_depth(test_deco_state.first_ceiling_pressure.mbar) * 0.001);
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
// check runtime is exactly the same as the first time
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
int finalDiveRunTimeSeconds = dive.dcs[0].duration.seconds;
TestPlan: Add test for repeating dive If variables were accidentally carried through from a previous calculated plan, subsequent plan could be affected. This test aims to detect if this happens. Commit 8994270 corrected such a bug. If it were reverted, this test would fail (as it should). Signed-off-by: Rick Walsh <rickmwalsh@gmail.com> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2015-09-22 14:32:26 +00:00
QCOMPARE(finalDiveRunTimeSeconds, firstDiveRunTimeSeconds);
}
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
// Test that the correct gases are selected during a CCR dive with bailout ascent
// Includes a regression test for https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E
void TestPlan::testCcrBailoutGasSelection()
{
planner: encapsulate deco state cache in a struct Removes memory management pain: the struct cleans up when it goes out of scope. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-03-07 18:08:22 +00:00
deco_state_cache cache;
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
setupPrefs();
prefs.unit_system = METRIC;
prefs.units.length = units::METERS;
prefs.planner_deco_mode = BUEHLMANN;
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
dive.dcs[0].divemode = CCR;
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
prefs.dobailout = true;
planner: turn diveplan into a C++ structure No more memory management woes. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-04 05:36:05 +00:00
auto testPlan = setupPlanCcr();
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
planner: return decotable from plan() The old return code was not used by any caller. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-07 13:32:06 +00:00
plan(&test_deco_state, testPlan, &dive, 0, 60, cache, true, false);
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
#if DEBUG
core: turn struct dive string data into std::string Much easier memory management! Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-29 18:40:18 +00:00
dive.notes.clear();
core: turn C dive-table into an owning table This is a humongous commit, because it touches all parts of the code. It removes the last user of our horrible TABLE macros, which simulate std::vector<> in a very clumsy way. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-06-07 08:25:09 +00:00
save_dive(stdout, dive, false);
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
#endif
// check diluent used
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cylinder_t *cylinder = dive.get_cylinder(get_cylinderid_at_time(&dive, &dive.dcs[0], 20_min - 1_sec));
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
QCOMPARE(cylinder->cylinder_use, DILUENT);
QCOMPARE(get_o2(cylinder->gasmix), 200);
// check deep bailout used
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cylinder = dive.get_cylinder(get_cylinderid_at_time(&dive, &dive.dcs[0], 20_min + 1_sec));
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
QCOMPARE(cylinder->cylinder_use, OC_GAS);
QCOMPARE(get_o2(cylinder->gasmix), 190);
// check shallow bailout used
core: introduce a few user-defined literals for unit types Thise makes initialization of unit types more palatable. For example: surface.time = sample.time - duration_t { .seconds = 20 }; => surface.time = sample.time - 20_sec; delta_depth.mm = feet_to_mm(1.0); // 1ft => delta_depth = 1_ft; get_cylinderid_at_time(..., { .seconds = 20 * 60 + 1 })); => get_cylinderid_at_time(..., 20_min + 1_sec)); Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-09-03 15:04:48 +00:00
cylinder = dive.get_cylinder(get_cylinderid_at_time(&dive, &dive.dcs[0], 30_min));
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
QCOMPARE(cylinder->cylinder_use, OC_GAS);
QCOMPARE(get_o2(cylinder->gasmix), 530);
// check expected run time of 51 minutes
core: turn divecomputer list into std::vector<> Since struct divecomputer is now fully C++ (i.e. cleans up after itself), we can simply turn the list of divecomputers into an std::vector<>. This makes the code quite a bit simpler, because the first divecomputer was actually a subobject. Yes, this makes the common case of a single divecomputer a little bit less efficient, but it really shouldn't matter. If it does, we can still write a special std::vector<>- like container that keeps the first element inline. This change makes pointers-to-divecomputers not stable. So always access the divecomputer via its index. As far as I can tell, most of the code already does this. Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
2024-05-27 15:09:48 +00:00
QVERIFY(compareDecoTime(dive.dcs[0].duration.seconds, 51 * 60, 51 * 60));
Fix invalid bailout gas choice when planning a CCR dive. Fixes a bug reported in https://groups.google.com/g/subsurface-divelog/c/8N3cTz2Zv5E: When planning a CCR dive with OC bailout, the diluent gas may be chosen as the first OC bailout gas, despite being set up with a use type of 'diluent', and likely not being available for open circuit breathing. `best_first_ascend_cylinder` is now initialised to an invalid value (instead of the first cylinder, which may or may not be a diluent cylinder), and its subsequent use is guarded by a validity check. Signed-off-by: Michael Keller <github@ike.ch>
2023-02-16 02:53:17 +00:00
}
Our tests are actually GUILESS Signed-off-by: Anton Lundin <glance@acc.umu.se> Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2017-02-05 22:26:51 +00:00
QTEST_GUILESS_MAIN(TestPlan)
Reference in a new issue Copy permalink