mirror of
https://gitlab.com/pholy/OSCAR-code.git
synced 2025-04-05 18:50:44 +00:00
a95429763d
It also turns out that every sample machine that claims to be F0V3 in its property file contains only F0V2 data, so there appears to be nothing additional to test, but now there are more warnings in case we ever do actually encounter F0V3 data. Also warn if we ever encounter oximetry.
408 lines
14 KiB
C++
408 lines
14 KiB
C++
/* PRS1 Unit Tests
|
|
*
|
|
* Copyright (c) 2019 The OSCAR Team
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file COPYING in the main directory of the source code
|
|
* for more details. */
|
|
|
|
#include "prs1tests.h"
|
|
#include "sessiontests.h"
|
|
|
|
#define TESTDATA_PATH "./testdata/"
|
|
|
|
static PRS1Loader* s_loader = nullptr;
|
|
static void iterateTestCards(const QString & root, void (*action)(const QString &));
|
|
static QString prs1OutputPath(const QString & inpath, const QString & serial, const QString & basename, const QString & suffix);
|
|
static QString prs1OutputPath(const QString & inpath, const QString & serial, int session, const QString & suffix);
|
|
|
|
void PRS1Tests::initTestCase(void)
|
|
{
|
|
initializeStrings();
|
|
qDebug() << STR_TR_OSCAR + " " + getBranchVersion();
|
|
QString profile_path = TESTDATA_PATH "profile/";
|
|
Profiles::Create("test", &profile_path);
|
|
|
|
schema::init();
|
|
PRS1Loader::Register();
|
|
s_loader = dynamic_cast<PRS1Loader*>(lookupLoader(prs1_class_name));
|
|
}
|
|
|
|
void PRS1Tests::cleanupTestCase(void)
|
|
{
|
|
}
|
|
|
|
|
|
// ====================================================================================================
|
|
|
|
extern PRS1ModelInfo s_PRS1ModelInfo;
|
|
void PRS1Tests::testMachineSupport()
|
|
{
|
|
QHash<QString,QString> tested = {
|
|
{ "ModelNumber", "550P" },
|
|
{ "Family", "0" },
|
|
{ "FamilyVersion", "3" },
|
|
};
|
|
QHash<QString,QString> supported = {
|
|
{ "ModelNumber", "700X999" },
|
|
{ "Family", "0" },
|
|
{ "FamilyVersion", "6" },
|
|
};
|
|
QHash<QString,QString> unsupported = {
|
|
{ "ModelNumber", "550P" },
|
|
{ "Family", "0" },
|
|
{ "FamilyVersion", "9" },
|
|
};
|
|
|
|
Q_ASSERT(s_PRS1ModelInfo.IsSupported(5, 3));
|
|
Q_ASSERT(!s_PRS1ModelInfo.IsSupported(5, 9));
|
|
Q_ASSERT(!s_PRS1ModelInfo.IsSupported(9, 9));
|
|
Q_ASSERT(s_PRS1ModelInfo.IsTested("550P", 0, 2));
|
|
Q_ASSERT(s_PRS1ModelInfo.IsTested("550P", 0, 3));
|
|
Q_ASSERT(s_PRS1ModelInfo.IsTested("760P", 0, 4));
|
|
Q_ASSERT(s_PRS1ModelInfo.IsTested("700X110", 0, 6));
|
|
Q_ASSERT(!s_PRS1ModelInfo.IsTested("700X999", 0, 6));
|
|
|
|
Q_ASSERT(s_PRS1ModelInfo.IsTested(tested));
|
|
Q_ASSERT(!s_PRS1ModelInfo.IsTested(supported));
|
|
Q_ASSERT(s_PRS1ModelInfo.IsSupported(tested));
|
|
Q_ASSERT(s_PRS1ModelInfo.IsSupported(supported));
|
|
Q_ASSERT(!s_PRS1ModelInfo.IsSupported(unsupported));
|
|
}
|
|
|
|
|
|
// ====================================================================================================
|
|
|
|
|
|
void parseAndEmitSessionYaml(const QString & path)
|
|
{
|
|
qDebug() << path;
|
|
|
|
// This mirrors the functional bits of PRS1Loader::OpenMachine.
|
|
// Maybe there's a clever way to add parameters to OpenMachine that
|
|
// would make it more amenable to automated tests. But for now
|
|
// something is better than nothing.
|
|
|
|
QStringList paths;
|
|
QString propertyfile;
|
|
int sessionid_base;
|
|
sessionid_base = s_loader->FindSessionDirsAndProperties(path, paths, propertyfile);
|
|
|
|
Machine *m = s_loader->CreateMachineFromProperties(propertyfile);
|
|
Q_ASSERT(m != nullptr);
|
|
|
|
s_loader->ScanFiles(paths, sessionid_base, m);
|
|
|
|
// Each session now has a PRS1Import object in m_MLtasklist
|
|
QList<ImportTask*>::iterator i;
|
|
while (!s_loader->m_MLtasklist.isEmpty()) {
|
|
ImportTask* task = s_loader->m_MLtasklist.takeFirst();
|
|
|
|
// Run the parser
|
|
PRS1Import* import = dynamic_cast<PRS1Import*>(task);
|
|
bool ok = import->ParseSession();
|
|
|
|
// Emit the parsed session data to compare against our regression benchmarks
|
|
Session* session = import->session;
|
|
QString outpath = prs1OutputPath(path, m->serial(), session->session(), "-session.yml");
|
|
SessionToYaml(outpath, session, ok);
|
|
|
|
delete session;
|
|
delete task;
|
|
}
|
|
}
|
|
|
|
void PRS1Tests::testSessionsToYaml()
|
|
{
|
|
//iterateTestCards(TESTDATA_PATH "prs1/input/", parseAndEmitSessionYaml);
|
|
}
|
|
|
|
|
|
// ====================================================================================================
|
|
|
|
static QString ts(qint64 msecs)
|
|
{
|
|
// TODO: make this UTC so that tests don't vary by where they're run
|
|
return QDateTime::fromMSecsSinceEpoch(msecs).toString(Qt::ISODate);
|
|
}
|
|
|
|
static QString dur(qint64 msecs)
|
|
{
|
|
qint64 s = msecs / 1000L;
|
|
int h = s / 3600; s -= h * 3600;
|
|
int m = s / 60; s -= m * 60;
|
|
return QString("%1:%2:%3")
|
|
.arg(h, 2, 10, QChar('0'))
|
|
.arg(m, 2, 10, QChar('0'))
|
|
.arg(s, 2, 10, QChar('0'));
|
|
}
|
|
|
|
static QString byteList(QByteArray data, int limit=-1)
|
|
{
|
|
int count = data.size();
|
|
if (limit == -1 || limit > count) limit = count;
|
|
QStringList l;
|
|
for (int i = 0; i < limit; i++) {
|
|
l.push_back(QString( "%1" ).arg((int) data[i] & 0xFF, 2, 16, QChar('0') ).toUpper());
|
|
}
|
|
if (limit < count) l.push_back("...");
|
|
QString s = l.join(" ");
|
|
return s;
|
|
}
|
|
|
|
void ChunkToYaml(QTextStream & out, PRS1DataChunk* chunk, bool ok)
|
|
{
|
|
// chunk header
|
|
out << "chunk:" << endl;
|
|
out << " at: " << hex << chunk->m_filepos << endl;
|
|
out << " parsed: " << ok << endl;
|
|
out << " version: " << dec << chunk->fileVersion << endl;
|
|
out << " size: " << chunk->blockSize << endl;
|
|
out << " htype: " << chunk->htype << endl;
|
|
out << " family: " << chunk->family << endl;
|
|
out << " familyVersion: " << chunk->familyVersion << endl;
|
|
out << " ext: " << chunk->ext << endl;
|
|
out << " session: " << chunk->sessionid << endl;
|
|
out << " start: " << ts(chunk->timestamp * 1000L) << endl;
|
|
out << " duration: " << dur(chunk->duration * 1000L) << endl;
|
|
|
|
// hblock for V3 non-waveform chunks
|
|
if (chunk->fileVersion == 3 && chunk->htype == 0) {
|
|
out << " hblock:" << endl;
|
|
QMapIterator<unsigned char, short> i(chunk->hblock);
|
|
while (i.hasNext()) {
|
|
i.next();
|
|
out << " " << (int) i.key() << ": " << i.value() << endl;
|
|
}
|
|
}
|
|
|
|
// waveform chunks
|
|
if (chunk->htype == 1) {
|
|
out << " intervals: " << chunk->interval_count << endl;
|
|
out << " intervalSeconds: " << (int) chunk->interval_seconds << endl;
|
|
out << " interleave:" << endl;
|
|
for (int i=0; i < chunk->waveformInfo.size(); i++) {
|
|
const PRS1Waveform & w = chunk->waveformInfo.at(i);
|
|
out << " " << i << ": " << w.interleave << endl;
|
|
}
|
|
out << " end: " << ts((chunk->timestamp + chunk->duration) * 1000L) << endl;
|
|
}
|
|
|
|
// header checksum
|
|
out << " checksum: " << hex << chunk->storedChecksum << endl;
|
|
if (chunk->storedChecksum != chunk->calcChecksum) {
|
|
out << " calcChecksum: " << hex << chunk->calcChecksum << endl;
|
|
}
|
|
|
|
// data
|
|
bool dump_data = true;
|
|
if (chunk->m_parsedData.size() > 0) {
|
|
dump_data = false;
|
|
out << " events:" << endl;
|
|
for (auto & e : chunk->m_parsedData) {
|
|
QString name = _PRS1ParsedEventName(e);
|
|
if (name == "raw" || name == "unknown") {
|
|
dump_data = true;
|
|
}
|
|
QMap<QString,QString> contents = _PRS1ParsedEventContents(e);
|
|
if (name == "setting" && contents.size() == 1) {
|
|
out << " - set_" << contents.firstKey() << ": " << contents.first() << endl;
|
|
}
|
|
else {
|
|
out << " - " << name << ":" << endl;
|
|
|
|
// Always emit start first if present
|
|
if (contents.contains("start")) {
|
|
out << " " << "start" << ": " << contents["start"] << endl;
|
|
}
|
|
for (auto & key : contents.keys()) {
|
|
if (key == "start") continue;
|
|
out << " " << key << ": " << contents[key] << endl;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (dump_data || !ok) {
|
|
out << " data: " << byteList(chunk->m_data, 100) << endl;
|
|
}
|
|
|
|
// data CRC
|
|
out << " crc: " << hex << chunk->storedCrc << endl;
|
|
if (chunk->storedCrc != chunk->calcCrc) {
|
|
out << " calcCrc: " << hex << chunk->calcCrc << endl;
|
|
}
|
|
out << endl;
|
|
}
|
|
|
|
void parseAndEmitChunkYaml(const QString & path)
|
|
{
|
|
qDebug() << path;
|
|
|
|
QStringList paths;
|
|
QString propertyfile;
|
|
int sessionid_base;
|
|
sessionid_base = s_loader->FindSessionDirsAndProperties(path, paths, propertyfile);
|
|
|
|
Machine *m = s_loader->CreateMachineFromProperties(propertyfile);
|
|
Q_ASSERT(m != nullptr);
|
|
|
|
// This mirrors the functional bits of PRS1Loader::ScanFiles.
|
|
|
|
QDir dir;
|
|
dir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden | QDir::NoSymLinks);
|
|
dir.setSorting(QDir::Name);
|
|
|
|
int size = paths.size();
|
|
|
|
// for each p0/p1/p2/etc... folder
|
|
for (int p=0; p < size; ++p) {
|
|
dir.setPath(paths.at(p));
|
|
if (!dir.exists() || !dir.isReadable()) {
|
|
qWarning() << dir.canonicalPath() << "can't read directory";
|
|
continue;
|
|
}
|
|
QFileInfoList flist = dir.entryInfoList();
|
|
|
|
// Scan for individual .00X files
|
|
for (int i = 0; i < flist.size(); i++) {
|
|
QFileInfo fi = flist.at(i);
|
|
QString inpath = fi.canonicalFilePath();
|
|
bool ok;
|
|
|
|
if (fi.fileName() == ".DS_Store") {
|
|
continue;
|
|
}
|
|
|
|
QString ext_s = fi.fileName().section(".", -1);
|
|
int ext = ext_s.toInt(&ok);
|
|
if (!ok) {
|
|
// not a numerical extension
|
|
qInfo() << inpath << "unexpected filename";
|
|
continue;
|
|
}
|
|
|
|
QString session_s = fi.fileName().section(".", 0, -2);
|
|
int sessionid = session_s.toInt(&ok, sessionid_base);
|
|
if (!ok) {
|
|
// not a numerical session ID
|
|
qInfo() << inpath << "unexpected filename";
|
|
continue;
|
|
}
|
|
|
|
// Create the YAML file.
|
|
QString suffix = QString(".%1-chunks.yml").arg(ext, 3, 10, QChar('0'));
|
|
QString outpath = prs1OutputPath(path, m->serial(), sessionid, suffix);
|
|
QFile file(outpath);
|
|
if (!file.open(QFile::WriteOnly | QFile::Truncate)) {
|
|
qDebug() << outpath;
|
|
Q_ASSERT(false);
|
|
}
|
|
QTextStream out(&file);
|
|
|
|
// keep only P1234568/Pn/00000000.001
|
|
QStringList pathlist = QDir::toNativeSeparators(inpath).split(QDir::separator(), QString::SkipEmptyParts);
|
|
QString relative = pathlist.mid(pathlist.size()-3).join(QDir::separator());
|
|
out << "file: " << relative << endl;
|
|
|
|
// Parse the chunks in the file.
|
|
QList<PRS1DataChunk *> chunks = s_loader->ParseFile(inpath);
|
|
for (int i=0; i < chunks.size(); i++) {
|
|
PRS1DataChunk * chunk = chunks.at(i);
|
|
bool ok = true;
|
|
|
|
// Parse the inner data.
|
|
switch (chunk->ext) {
|
|
case 0: ok = chunk->ParseCompliance(); break;
|
|
case 1: ok = chunk->ParseSummary(); break;
|
|
case 2: ok = chunk->ParseEvents(MODE_UNKNOWN); break;
|
|
case 5: break; // skip flow/pressure waveforms
|
|
case 6: // skip oximetry data (but log it)
|
|
qWarning() << relative << "oximetry is untested"; // never encountered
|
|
break;
|
|
default:
|
|
qWarning() << relative << "unexpected file type";
|
|
break;
|
|
}
|
|
|
|
// Emit the YAML.
|
|
ChunkToYaml(out, chunk, ok);
|
|
delete chunk;
|
|
}
|
|
|
|
file.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
void PRS1Tests::testChunksToYaml()
|
|
{
|
|
iterateTestCards(TESTDATA_PATH "prs1/input/", parseAndEmitChunkYaml);
|
|
}
|
|
|
|
|
|
// ====================================================================================================
|
|
|
|
QString prs1OutputPath(const QString & inpath, const QString & serial, int session, const QString & suffix)
|
|
{
|
|
QString basename = QString("%1").arg(session, 8, 10, QChar('0'));
|
|
return prs1OutputPath(inpath, serial, basename, suffix);
|
|
}
|
|
|
|
QString prs1OutputPath(const QString & inpath, const QString & serial, const QString & basename, const QString & suffix)
|
|
{
|
|
// Output to prs1/output/FOLDER/SERIAL-000000(-session.yml, etc.)
|
|
QDir path(inpath);
|
|
QStringList pathlist = QDir::toNativeSeparators(inpath).split(QDir::separator(), QString::SkipEmptyParts);
|
|
pathlist.pop_back(); // drop serial number directory
|
|
pathlist.pop_back(); // drop P-Series directory
|
|
QString foldername = pathlist.last();
|
|
|
|
QDir outdir(TESTDATA_PATH "prs1/output/" + foldername);
|
|
outdir.mkpath(".");
|
|
|
|
QString filename = QString("%1-%2%3")
|
|
.arg(serial)
|
|
.arg(basename)
|
|
.arg(suffix);
|
|
return outdir.path() + QDir::separator() + filename;
|
|
}
|
|
|
|
void iterateTestCards(const QString & root, void (*action)(const QString &))
|
|
{
|
|
QDir dir(root);
|
|
dir.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden | QDir::NoSymLinks);
|
|
dir.setSorting(QDir::Name);
|
|
QFileInfoList flist = dir.entryInfoList();
|
|
|
|
// Look through each folder in the given root
|
|
for (int i = 0; i < flist.size(); i++) {
|
|
QFileInfo fi = flist.at(i);
|
|
if (fi.isDir()) {
|
|
// If it contains a P-Series folder, it's a PRS1 SD card
|
|
QDir pseries(fi.canonicalFilePath() + QDir::separator() + "P-Series");
|
|
if (pseries.exists()) {
|
|
pseries.setFilter(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files | QDir::Hidden | QDir::NoSymLinks);
|
|
pseries.setSorting(QDir::Name);
|
|
QFileInfoList plist = pseries.entryInfoList();
|
|
|
|
// Look for machine directories (containing a PROP.TXT or properties.txt)
|
|
for (int j = 0; j < plist.size(); j++) {
|
|
QFileInfo pfi = plist.at(j);
|
|
if (pfi.isDir()) {
|
|
QString machinePath = pfi.canonicalFilePath();
|
|
QDir machineDir(machinePath);
|
|
QFileInfoList mlist = machineDir.entryInfoList();
|
|
for (int k = 0; k < mlist.size(); k++) {
|
|
QFileInfo mfi = mlist.at(k);
|
|
if (QDir::match("PROP*.TXT", mfi.fileName())) {
|
|
// Found a properties file, this is a machine folder
|
|
action(machinePath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|