Index: unittests/tst_views.cpp =================================================================== diff -u -r44a85c96ab55e424866ec4cca0270aa218355f82 -r0622f1ec79b9a24a3f9d58cd2de329df997b37d6 --- unittests/tst_views.cpp (.../tst_views.cpp) (revision 44a85c96ab55e424866ec4cca0270aa218355f82) +++ unittests/tst_views.cpp (.../tst_views.cpp) (revision 0622f1ec79b9a24a3f9d58cd2de329df997b37d6) @@ -1,16 +1,16 @@ /*! - * + * * Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved. * \copyright * THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN * WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER. - * + * * \file tst_views.cpp * \author (last) Behrouz NemaiPour * \date (last) 23-Jun-2020 * \author (original) Behrouz NematiPour * \date (original) 21-Apr-2020 - * + * */ #include "tst_views.h" @@ -19,6 +19,7 @@ // Project #include "vtreatmentadjustmentresponsebase.h" #include "vtreatmentadjustmentultrafiltrationstate.h" +#include "filehandler.h" tst_views::tst_views(QObject *parent) : QObject(parent) { } @@ -65,3 +66,687 @@ v.isPaused(false); } +/*! + * \brief tst_views::VCreateTreatment_validation + * Tests treatment parameter validation + */ +void tst_views::VCreateTreatment_validation() +{ + + for (int i = 0; i < 18; ++i) { + View::VCreateTreatment view; + if (i != 0) view.set_bloodFlowRate(view.bloodFlowRateMax()); + if (i != 1) view.set_dialysateFlowRate(view.dialysateFlowRateMax()); + if (i != 2) view.set_duration(view.durationMax()); + if (i != 3) view.set_heparinDispensingRate(view.heparinDispensingRateMax()); + + if (i != 4) view.set_heparinBolusVolume(view.heparinBolusVolumeMax()); + if (i != 5) view.set_heparinStopTime(view.heparinStopTimeMax()); + if (i != 6) view.set_salineBolusVolume(0); + if (i != 7) view.set_acidConcentrate(0); + if (i != 8) view.set_bicarbonateConcentrate(0); + + if (i != 9) view.set_dialyzerType(0); + if (i != 10) view.set_dialysateTemp(view.dialysateTempMax()); + if (i != 11) view.set_arterialPressureLimitLow(view.arterialPressureLimitLowMin()); + if (i != 12) view.set_arterialPressureLimitHigh(view.arterialPressureLimitHighMax()); + if (i != 13) view.set_venousPressureLimitLow(view.venousPressureLimitLowMin()); + if (i != 14) view.set_venousPressureLimitHigh(view.venousPressureLimitHighMax()); + + if (i != 15) view.set_bloodPressureMeasureInterval(view.bloodPressureMeasureIntervalMax()); + if (i != 16) view.set_rinsebackFlowRate(view.rinsebackFlowRateMax()); + + if (i == 17) { + QCOMPARE(view.isbloodFlowRateSet, true); + QCOMPARE(view.isdialysateFlowRateSet, true); + QCOMPARE(view.isdurationSet, true); + QCOMPARE(view.isheparinDispensingRateSet, true); + QCOMPARE(view.isheparinBolusVolumeSet, true); + QCOMPARE(view.isheparinStopTimeSet, true); + QCOMPARE(view.issalineBolusVolumeSet, true); + QCOMPARE(view.isacidConcentrateSet, true); + QCOMPARE(view.isbicarbonateConcentrateSet, true); + QCOMPARE(view.isdialyzerTypeSet, true); + QCOMPARE(view.isdialysateTempSet, true); + QCOMPARE(view.isarterialPressureLimitLowSet, true); + QCOMPARE(view.isarterialPressureLimitHighSet, true); + QCOMPARE(view.isvenousPressureLimitLowSet, true); + QCOMPARE(view.isvenousPressureLimitHighSet, true); + QCOMPARE(view.isbloodPressureMeasureIntervalSet, true); + QCOMPARE(view.isrinsebackFlowRateSet, true); + QCOMPARE(view.validate(view.treatmentData), true); + + // check getters + QCOMPARE(view.get_bloodFlowRate(), view.bloodFlowRateMax()); + QCOMPARE(view.get_dialysateFlowRate(), view.dialysateFlowRateMax()); + QCOMPARE(view.get_duration(), view.durationMax()); + QCOMPARE(view.get_heparinDispensingRate(),view.heparinDispensingRateMax()); + + QCOMPARE(view.get_heparinBolusVolume(),view.heparinBolusVolumeMax()); + QCOMPARE(view.get_heparinStopTime(),view.heparinStopTimeMax()); + QCOMPARE(view.get_salineBolusVolume(), quint32(0)); + QCOMPARE(view.get_acidConcentrate(), quint32(0)); + QCOMPARE(view.get_bicarbonateConcentrate(), quint32(0)); + + QCOMPARE(view.get_dialyzerType(), quint32(0)); + QCOMPARE(view.get_dialysateTemp(), view.dialysateTempMax()); + QCOMPARE(view.get_arterialPressureLimitLow(),view.arterialPressureLimitLowMin()); + QCOMPARE(view.get_arterialPressureLimitHigh(), view.arterialPressureLimitHighMax()); + QCOMPARE(view.get_venousPressureLimitLow(), view.venousPressureLimitLowMin()); + QCOMPARE(view.get_venousPressureLimitHigh(), view.venousPressureLimitHighMax()); + + QCOMPARE(view.get_bloodPressureMeasureInterval(), view.bloodPressureMeasureIntervalMax()); + QCOMPARE(view.get_rinsebackFlowRate(), view.rinsebackFlowRateMax()); + + view.onFinishedCreate(); + } + else { + QCOMPARE(view.validate(view.treatmentData), false); + } + } +} + +/*! + * \brief tst_views::VCreateTreatment_simulate_valid_parameters + * Simulates a user selection of valid parameters + * \param view VCreateTreatment object to be set with valid parameters + */ +void tst_views::VCreateTreatment_simulate_valid_parameters(View::VCreateTreatment &view) +{ + view.set_bloodFlowRate(view.bloodFlowRateMax()); + view.set_dialysateFlowRate(view.dialysateFlowRateMax()); + view.set_duration(view.durationMax()); + view.set_heparinDispensingRate(view.heparinDispensingRateMax()); + + view.set_heparinBolusVolume(view.heparinBolusVolumeMax()); + view.set_heparinStopTime(view.heparinStopTimeMax()); + view.set_salineBolusVolume(0); + view.set_acidConcentrate(0); + view.set_bicarbonateConcentrate(0); + + view.set_dialyzerType(0); + view.set_dialysateTemp(view.dialysateTempMax()); + view.set_arterialPressureLimitLow(view.arterialPressureLimitLowMin()); + view.set_arterialPressureLimitHigh(view.arterialPressureLimitHighMax()); + view.set_venousPressureLimitLow(view.venousPressureLimitLowMin()); + view.set_venousPressureLimitHigh(view.venousPressureLimitHighMax()); + + view.set_bloodPressureMeasureInterval(view.bloodPressureMeasureIntervalMax()); + view.set_rinsebackFlowRate(view.rinsebackFlowRateMax()); + +} + +/*! + * \brief tst_views::VCreateTreatment_init_ranges + * Initializes the treatment parameter ranges + * \param obj - QJsonObject to write the ranges to + */ +void tst_views::VCreateTreatment_init_ranges(QJsonObject &obj) +{ + obj["bloodFlowRateMin"] = 100; + obj["bloodFlowRateMax"] = 500; + obj["dialysateFlowRateMin"] = 100; + obj["dialysateFlowRateMax"] = 600; + obj["durationMin"] = 60; + obj["durationMax"] = 480; + obj["heparinDispensingRateMin"] = 0; + obj["heparinDispensingRateMax"] = 1000; + obj["heparinBolusVolumeMin"] = 100; + obj["heparinBolusVolumeMax"] = 2000; + obj["heparinStopTimeMin"] = 1000; + obj["heparinStopTimeMax"] = 2000; + obj["salineBolusOptions"] = QJsonArray({ + "100 mL", + "200 mL", + "300 mL" + }); + obj["acidConcentrateOptions"] = QJsonArray({ + "08-1251-1", + "08-2251-0", + "08-3251-9" + }), + obj["bicarbonateConcentrateOptions"] = QJsonArray({ + "Dimesol - BC-201" + }), + obj["dialyzerTypeOptions"] = QJsonArray({ + "Nipro Elisio-H 17", + "Nipro Elisio-H 19", + "Fresenius Optiflux F160NRe", + "Fresenius Optiflux F180NRe" + }); + obj["dialysateTempMin"] = 35; + obj["dialysateTempMax"] = 39; + obj["arterialPressureLimitLowMin"] = -300; + obj["arterialPressureLimitLowMax"] = 200; + obj["arterialPressureLimitHighMin"] = -300; + obj["arterialPressureLimitHighMax"] = 200; + obj["venousPressureLimitLowMin"] = -100; + obj["venousPressureLimitLowMax"] = 600; + obj["venousPressureLimitHighMin"] = 0; + obj["venousPressureLimitHighMax"] = 600; + obj["bloodPressureMeasureIntervalMin"] = 0; + obj["bloodPressureMeasureIntervalMax"] = 30; + obj["rinsebackFlowRateMin"] = 50; + obj["rinsebackFlowRateMax"] = 150; +} + +/*! + * \brief tst_views::VCreateTreatment_validation_ranges + * Tests the treatment parameter validation ranges are checked + */ +void tst_views::VCreateTreatment_validation_ranges() +{ + View::VCreateTreatment view; + + // adjust quint32 minimums + view.bloodFlowRateMin(1); + view.dialysateFlowRateMin(1); + view.durationMin(1); + view.heparinDispensingRateMin(2); + view.heparinBolusVolumeMin(1); + view.heparinStopTimeMin(1); + + view.dialysateTempMin(1); + view.arterialPressureLimitLowMin(2); + view.arterialPressureLimitHighMin(2); + view.venousPressureLimitLowMin(2); + view.venousPressureLimitHighMin(2); + view.bloodPressureMeasureIntervalMin(2); + view.rinsebackFlowRateMin(1); + + // setters + view.set_bloodFlowRate(0); + view.set_dialysateFlowRate(0); + view.set_duration(0); + view.set_heparinDispensingRate(1); + + view.set_heparinBolusVolume(0); + view.set_heparinStopTime(0); + view.set_salineBolusVolume(-1); + view.set_acidConcentrate(-1); + view.set_bicarbonateConcentrate(-1); + + view.set_dialyzerType(-1); + view.set_dialysateTemp(0); + view.set_arterialPressureLimitLow(1); + view.set_arterialPressureLimitHigh(1); + view.set_venousPressureLimitLow(1); + view.set_venousPressureLimitHigh(1); + + view.set_bloodPressureMeasureInterval(1); + view.set_rinsebackFlowRate(0); + + view.setTreatmentData(); + + QCOMPARE(view.isbloodFlowRateSet, true); + QCOMPARE(view.isdialysateFlowRateSet, true); + QCOMPARE(view.isdurationSet, true); + QCOMPARE(view.isheparinDispensingRateSet, true); + QCOMPARE(view.isheparinBolusVolumeSet, true); + QCOMPARE(view.isheparinStopTimeSet, true); + QCOMPARE(view.issalineBolusVolumeSet, true); + QCOMPARE(view.isacidConcentrateSet, true); + QCOMPARE(view.isbicarbonateConcentrateSet, true); + QCOMPARE(view.isdialyzerTypeSet, true); + QCOMPARE(view.isdialysateTempSet, true); + QCOMPARE(view.isarterialPressureLimitLowSet, true); + QCOMPARE(view.isarterialPressureLimitHighSet, true); + QCOMPARE(view.isvenousPressureLimitLowSet, true); + QCOMPARE(view.isvenousPressureLimitHighSet, true); + QCOMPARE(view.isbloodPressureMeasureIntervalSet, true); + QCOMPARE(view.isrinsebackFlowRateSet, true); + + QCOMPARE(view.validate(view.treatmentData), false); + + // edge case when pressure lows are set greater than the highs + view.set_arterialPressureLimitLow(view.arterialPressureLimitHighMin()+1); + view.set_venousPressureLimitLow(view.venousPressureLimitHighMin()+1); + + QCOMPARE(view.validate(view.treatmentData), false); + + view.onResetCreateTreatment(); + + + for (int i = 0; i < 17; ++i) { + VCreateTreatment_simulate_valid_parameters(view); + + switch (i) { + case 0: view.set_bloodFlowRate(view.bloodFlowRateMax()+1); break; + case 1: view.set_dialysateFlowRate(view.dialysateFlowRateMax()+1); break; + case 2: view.set_duration(view.durationMax()+1); break; + case 3: view.set_heparinDispensingRate(view.heparinDispensingRateMax()+1); break; + + case 4: view.set_heparinBolusVolume(view.heparinBolusVolumeMax()+1); break; + case 5: view.set_heparinStopTime(view.heparinStopTimeMax()+1); break; + case 6: view.set_salineBolusVolume(view.salineBolusOptions().length()); break; + case 7: view.set_acidConcentrate(view.acidConcentrateOptions().length()); break; + case 8: view.set_bicarbonateConcentrate(view.bicarbonateConcentrateOptions().length()); break; + + case 9: view.set_dialyzerType(view.dialyzerTypeOptions().length()); break; + case 10: view.set_dialysateTemp(view.dialysateTempMax()+1); break; + case 11: view.set_arterialPressureLimitLow(view.arterialPressureLimitLowMax()+1); break; + case 12: view.set_arterialPressureLimitHigh(view.arterialPressureLimitHighMax()+1); break; + case 13: view.set_venousPressureLimitLow(view.venousPressureLimitLowMax()+1); break; + case 14: view.set_venousPressureLimitHigh(view.venousPressureLimitHighMax()+1); break; + + case 15: view.set_bloodPressureMeasureInterval(view.bloodPressureMeasureIntervalMax()+1); break; + case 16: view.set_rinsebackFlowRate(view.rinsebackFlowRateMax()+1); break; + default: break; + } + + + QCOMPARE(view.validate(view.treatmentData), false); + view.onFinishedCreate(); + } + +} + +void tst_views::VCreateTreatment_check_init() +{ + View::VCreateTreatment view; + quint32 val = 150; view.bloodFlowRateMin(val); ++val; + view.bloodFlowRateMin(val); + view.bloodFlowRateMin(val); + QCOMPARE(val, view.bloodFlowRateMin()); + + val = 501; view.bloodFlowRateMax(val); ++val; + view.bloodFlowRateMax(val); + view.bloodFlowRateMax(val); + QCOMPARE(val, view.bloodFlowRateMax()); + + val = 100; view.dialysateFlowRateMin(val); ++val; + view.dialysateFlowRateMin(val); + QCOMPARE(val, view.dialysateFlowRateMin()); + + val = 600; view.dialysateFlowRateMax(val); ++val; + view.dialysateFlowRateMax(val); + view.dialysateFlowRateMax(val); + QCOMPARE(val, view.dialysateFlowRateMax()); + + val = 60; view.durationMin(val); ++val; + view.durationMin(val); + QCOMPARE(val, view.durationMin()); + + val = 480; view.durationMax(val); ++val; + view.durationMax(val); + view.durationMax(val); + QCOMPARE(val, view.durationMax()); + + val = 0; view.heparinDispensingRateMin(val); ++val; + view.heparinDispensingRateMin(val); + view.heparinDispensingRateMin(val); + QCOMPARE(val, view.heparinDispensingRateMin()); + + val = 1000; view.heparinDispensingRateMax(val); ++val; + view.heparinDispensingRateMax(val); + view.heparinDispensingRateMax(val); + QCOMPARE(val, view.heparinDispensingRateMax()); + + val = 100; view.heparinBolusVolumeMin(val); ++val; + view.heparinBolusVolumeMin(val); + view.heparinBolusVolumeMin(val); + QCOMPARE(val, view.heparinBolusVolumeMin()); + + val = 2000; view.heparinBolusVolumeMax(val); ++val; + view.heparinBolusVolumeMax(val); + view.heparinBolusVolumeMax(val); + QCOMPARE(val, view.heparinBolusVolumeMax()); + + val = 1000; view.heparinStopTimeMin(val); ++val; + view.heparinStopTimeMin(val); + view.heparinStopTimeMin(val); + QCOMPARE(val, view.heparinStopTimeMin()); + + val = 2000; view.heparinStopTimeMax(val); ++val; + view.heparinStopTimeMax(val); + view.heparinStopTimeMax(val); + QCOMPARE(val, view.heparinStopTimeMax()); + + val = 480; view.durationMax(val); ++val; + view.durationMax(val); + view.durationMax(val); + QCOMPARE(val, view.durationMax()); + + QStringList options = QStringList() << "100 mL" << "200 mL" << "300 mL"; + view.salineBolusOptions(options); options.append(" "); + view.salineBolusOptions(options); + view.salineBolusOptions(options); + QCOMPARE(options, view.salineBolusOptions()); + + + options = QStringList() << "08-1251-1" << "08-2251-0" << "08-3251-9"; + view.acidConcentrateOptions(options); options.append(" "); + view.acidConcentrateOptions(options); + view.acidConcentrateOptions(options); + QCOMPARE(options, view.acidConcentrateOptions()); + + options = QStringList() << "Dimesol - BC-201"; + view.bicarbonateConcentrateOptions(options); options.append(" "); + view.bicarbonateConcentrateOptions(options); + view.bicarbonateConcentrateOptions(options); + QCOMPARE(options, view.bicarbonateConcentrateOptions()); + + + options = QStringList() << "Nipro Elisio-H 17" + << "Nipro Elisio-H 19" + << "Fresenius Optiflux F160NRe" + << "Fresenius Optiflux F180NRe"; + view.dialyzerTypeOptions(options); options.append(" "); + view.dialyzerTypeOptions(options); + view.dialyzerTypeOptions(options); + QCOMPARE(options, view.dialyzerTypeOptions()); + + val = 36; view.dialysateTempMin(val); ++val; + view.dialysateTempMin(val); + view.dialysateTempMin(val); + QCOMPARE(val, view.dialysateTempMin()); + + val = 37; view.dialysateTempMax(val); ++val; + view.dialysateTempMax(val); + view.dialysateTempMax(val); + QCOMPARE(val, view.dialysateTempMax()); + + qint32 v; + v = -299; view.arterialPressureLimitLowMin(v); ++v; + view.arterialPressureLimitLowMin(v); + view.arterialPressureLimitLowMin(v); + QCOMPARE(v, view.arterialPressureLimitLowMin()); + + v = 201; view.arterialPressureLimitLowMax(v); ++v; + view.arterialPressureLimitLowMax(v); + view.arterialPressureLimitLowMax(v); + QCOMPARE(v, view.arterialPressureLimitLowMax()); + + v = 1000; view.arterialPressureLimitHighMin(v); ++v; + view.arterialPressureLimitHighMin(v); + view.arterialPressureLimitHighMin(v); + QCOMPARE(v, view.arterialPressureLimitHighMin()); + + v = 2000; view.arterialPressureLimitHighMax(v); ++v; + view.arterialPressureLimitHighMax(v); + view.arterialPressureLimitHighMax(v); + QCOMPARE(v, view.arterialPressureLimitHighMax()); + + v = -101; view.venousPressureLimitLowMin(v); ++v; + view.venousPressureLimitLowMin(v); + view.venousPressureLimitLowMin(v); + QCOMPARE(v, view.venousPressureLimitLowMin()); + + v = 601; view.venousPressureLimitLowMax(v); ++v; + view.venousPressureLimitLowMax(v); + view.venousPressureLimitLowMax(v); + QCOMPARE(v, view.venousPressureLimitLowMax()); + + v = 10; view.venousPressureLimitHighMin(v); ++v; + view.venousPressureLimitHighMin(v); + view.venousPressureLimitHighMin(v); + QCOMPARE(v, view.venousPressureLimitHighMin()); + + v = 601; view.venousPressureLimitHighMax(v); ++v; + view.venousPressureLimitHighMax(v); + view.venousPressureLimitHighMax(v); + QCOMPARE(v, view.venousPressureLimitHighMax()); + + + val = 1; view.bloodPressureMeasureIntervalMin(val); ++val; + view.bloodPressureMeasureIntervalMin(val); + view.bloodPressureMeasureIntervalMin(val); + QCOMPARE(val, view.bloodPressureMeasureIntervalMin()); + + val = 31; view.bloodPressureMeasureIntervalMax(val); ++val; + view.bloodPressureMeasureIntervalMax(val); + view.bloodPressureMeasureIntervalMax(val); + QCOMPARE(val, view.bloodPressureMeasureIntervalMax()); + + + val = 10; view.rinsebackFlowRateMin(val); ++val; + view.rinsebackFlowRateMin(val); + view.rinsebackFlowRateMin(val); + QCOMPARE(val, view.rinsebackFlowRateMin()); + + val = 149; view.rinsebackFlowRateMax(val); ++val; + view.rinsebackFlowRateMax(val); + view.rinsebackFlowRateMax(val); + QCOMPARE(val, view.rinsebackFlowRateMax()); + + bool b = false; view.continueEnabled(b); + view.continueEnabled(b); + QCOMPARE(b, view.continueEnabled()); + + view.saveTreatmentProfile(b); + view.saveTreatmentProfile(b); + QCOMPARE(b, view.saveTreatmentProfile()); +} + +void tst_views::VCreateTreatment_save_csv() +{ + View::VCreateTreatment view; + QString csvData = view.getParameterRangesDataCSV(); + QString filename = QString("/tmp/out_%0.csv").arg(QDateTime::currentDateTime().toString(datetimeFormat)); + + view.saveTreatmentRangesCSV(filename); + + QString readCsvData; + FileHandler::read(filename, readCsvData); + + QCOMPARE(csvData, readCsvData); + + QVERIFY(!FileHandler::read(filename + "invalid", readCsvData)); + +} + +/*! + * \brief tst_views::VCreateTreatment_save + * Tests that VCreateTreatment saves treatment profiles properly. + */ +void tst_views::VCreateTreatment_save() +{ + View::VCreateTreatment view; + + QJsonObject objectWritten { + {"bloodFlowRate", QString::number(view.treatmentData.bloodFlowRate)}, + {"dialysateFlowRate", QString::number(view.treatmentData.dialysateFlowRate)}, + {"duration", QString::number(view.treatmentData.duration)}, + {"heparinDispensingRate", QString::number(view.treatmentData.heparinDispensingRate)}, + {"heparinBolusVolume", QString::number(view.treatmentData.heparinBolusVolume)}, + {"heparinStopTime", QString::number(view.treatmentData.heparinStopTime)}, + {"acidConcentrate", QString::number(view.treatmentData.acidConcentrate)}, + {"bicarbonateConcentrate", QString::number(view.treatmentData.bicarbonateConcentrate)}, + {"dialyzerType", QString::number(view.treatmentData.dialyzerType)}, + {"dialysateTemp", QString::number(view.treatmentData.dialysateTemp)}, + {"arterialPressureLimitLow", QString::number(view.treatmentData.arterialPressureLimitLow)}, + {"arterialPressureLimitHigh", QString::number(view.treatmentData.arterialPressureLimitHigh)}, + {"venousPressureLimitLow", QString::number(view.treatmentData.venousPressureLimitLow)}, + {"venousPressureLimitHigh", QString::number(view.treatmentData.venousPressureLimitHigh)}, + {"bloodPressureMeasureInterval",QString::number(view.treatmentData.bloodPressureMeasureInterval)}, + {"rinsebackFlowRate", QString::number(view.treatmentData.rinsebackFlowRate)} + }; + + QString dir = QString("/tmp/newTreatment_%0.json").arg(QDateTime::currentDateTime().toString(datetimeFormat)); + + QString oldFilename = view.saveNewTreatment(objectWritten, dir); + QDateTime startTime = QDateTime::currentDateTime(); + int elapsedSeconds = 0; + while (!QFile(oldFilename).exists()) + { + elapsedSeconds = startTime.secsTo(QDateTime::currentDateTime()); + } + + startTime = QDateTime::currentDateTime(); + QString filename = view.saveNewTreatment(objectWritten, dir); + + QVERIFY(oldFilename != filename); + QVERIFY(elapsedSeconds < 0.5); + + elapsedSeconds = 0; + QJsonObject objectReadTemp; + while (!FileHandler::readJSON(filename, objectReadTemp) || (objectWritten != objectReadTemp)) + { + elapsedSeconds = startTime.secsTo(QDateTime::currentDateTime()); + } + + QVERIFY(elapsedSeconds < 0.5); + + QJsonObject objectRead; + QVERIFY(FileHandler::readJSON(filename, objectRead)); + QCOMPARE(objectWritten, objectRead); + +} + +/*! + * \brief tst_views::VCreateTreatment_enums + * Tests that enums are handled properly + */ +void tst_views::VCreateTreatment_enums() +{ + View::VCreateTreatment view; + + GuiRequestReasons reason = GuiRequestReasons::REQUEST_REJECT_REASON_NONE; + QCOMPARE(view.enumToString(reason), "REQUEST_REJECT_REASON_NONE"); + + QCOMPARE(view.enumToString(static_cast(-1)), "[-1] Unknown Rejection Reason"); + QCOMPARE(view.enumToString(static_cast(GuiRequestReasons::NUM_OF_REQUEST_REJECT_REASONS + 1)), + QString("[%0] Unknown Rejection Reason").arg(GuiRequestReasons::NUM_OF_REQUEST_REJECT_REASONS + 1)); +} + +/*! + * \brief tst_views::VCreateTreatment_json + * Tests a helper function's conversion from QJsonArray to QStringList + */ +void tst_views::VCreateTreatment_json() +{ + View::VCreateTreatment view; + + QJsonArray arr; + QStringList list; + + QCOMPARE(view.jsonArrayToStringList(arr), list); + + arr << "1"; + QVERIFY(view.jsonArrayToStringList(arr) != list); + + list << "1"; + + QCOMPARE(view.jsonArrayToStringList(arr), list); + + arr << QJsonValue("1") << QJsonValue("2"); + list << "1" << "2"; + + QCOMPARE(view.jsonArrayToStringList(arr), list); + + arr << 3 << 4; + list << "3" << "4"; + + QVERIFY(view.jsonArrayToStringList(arr) != list); + +} + +/*! + * \brief tst_views::VCreateTreatment_fw_validation_response + * Tests handling of a FW validation response and parameter integrity + */ +void tst_views::VCreateTreatment_fw_validation_response() +{ + View::VCreateTreatment view; + GuiActionType action = GuiActionType::ID_CreateTreatmentRsp; + + for (int i = 0; i < 18; ++i) + { + // 0 = OK, 1,2,3 ... parameter is not OK + QVariantList messageData; + if (i == 0) messageData.append(1); else messageData.append(0); + if (i == 1) messageData.append(1); else messageData.append(0); + if (i == 2) messageData.append(1); else messageData.append(0); + if (i == 3) messageData.append(1); else messageData.append(0); + if (i == 4) messageData.append(1); else messageData.append(0); + if (i == 5) messageData.append(1); else messageData.append(0); + if (i == 6) messageData.append(1); else messageData.append(0); + if (i == 7) messageData.append(1); else messageData.append(0); + if (i == 8) messageData.append(1); else messageData.append(0); + if (i == 9) messageData.append(1); else messageData.append(0); + if (i == 10) messageData.append(1); else messageData.append(0); + if (i == 11) messageData.append(1); else messageData.append(0); + if (i == 12) messageData.append(1); else messageData.append(0); + if (i == 13) messageData.append(1); else messageData.append(0); + if (i == 14) messageData.append(1); else messageData.append(0); + if (i == 15) messageData.append(1); else messageData.append(0); + if (i == 16) messageData.append(1); else messageData.append(0); + if (i == 17) messageData.append(1); else messageData.append(0); + QVERIFY(!view.onFWValidationResponse(action, messageData)); + } + + AdjustTreatmentParametersRequestData dataBackup = view.treatmentData; + + QVariantList validMessageData; + for (int i = 0; i < 18; ++i) { validMessageData.append(0); } + + QVERIFY(!view.onFWValidationResponse(GuiActionType::ID_CreateTreatmentReq, validMessageData)); + + QVERIFY(view.onFWValidationResponse(GuiActionType::ID_CreateTreatmentRsp, validMessageData)); + + view.saveTreatmentProfile(false); + QVERIFY(!view._saveTreatmentProfile); + view.onFinishedConfirm(); + + view.saveTreatmentProfile(true); + QVERIFY(view._saveTreatmentProfile); + view.onFinishedConfirm(); + + + view.onFinishedSaveNewTreatment(true); + view.onFinishedSaveNewTreatment(false); + view.onFinishedPrime(); + view.onStart(); + + QCOMPARE(view.treatmentData.bloodFlowRate, dataBackup.bloodFlowRate); + QCOMPARE(view.treatmentData.dialysateFlowRate, dataBackup.dialysateFlowRate); + QCOMPARE(view.treatmentData.duration, dataBackup.duration); + QCOMPARE(view.treatmentData.heparinDispensingRate, dataBackup.heparinDispensingRate); + QCOMPARE(view.treatmentData.heparinBolusVolume, dataBackup.heparinBolusVolume); + QCOMPARE(view.treatmentData.heparinStopTime, dataBackup.heparinStopTime); + QCOMPARE(view.treatmentData.salineBolus, dataBackup.salineBolus); + QCOMPARE(view.treatmentData.acidConcentrate, dataBackup.acidConcentrate); + QCOMPARE(view.treatmentData.bicarbonateConcentrate, dataBackup.bicarbonateConcentrate); + QCOMPARE(view.treatmentData.dialyzerType, dataBackup.dialyzerType); + QCOMPARE(view.treatmentData.dialysateTemp, dataBackup.dialysateTemp); + QCOMPARE(view.treatmentData.arterialPressureLimitLow, dataBackup.arterialPressureLimitLow); + QCOMPARE(view.treatmentData.arterialPressureLimitHigh, dataBackup.arterialPressureLimitHigh); + QCOMPARE(view.treatmentData.venousPressureLimitLow, dataBackup.venousPressureLimitLow); + QCOMPARE(view.treatmentData.venousPressureLimitHigh, dataBackup.venousPressureLimitHigh); + QCOMPARE(view.treatmentData.bloodPressureMeasureInterval, dataBackup.bloodPressureMeasureInterval); + QCOMPARE(view.treatmentData.rinsebackFlowRate, dataBackup.rinsebackFlowRate); + +} + +/*! + * \brief tst_views::VCreateTreatment_load_parameter_ranges + * Tests that parameter ranges are loaded correctly from disk. + */ +void tst_views::VCreateTreatment_load_parameter_ranges() +{ + View::VCreateTreatment view; + + QJsonObject obj; + + VCreateTreatment_init_ranges(obj); + + obj["UnexpectedParameter"] = 123; + + QJsonDocument document(obj); + + QString path = QString("/tmp/ranges_%0.json").arg(QDateTime::currentDateTime().toString(datetimeFormat));; + + _FileSaver.onConcurrentSave(path, document.toJson(), false); + + QThread::msleep(500); + + QJsonObject readObj = view.loadTreatmentParameterRanges(path); + + QCOMPARE(obj, readObj); + + readObj = view.loadTreatmentParameterRanges(QString("/tmp/wrong_path_%0.json") + .arg(QDateTime::currentDateTime().toString(datetimeFormat))); + + QVERIFY(obj != readObj); +} +