mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2025-02-19 22:16:15 +00:00
Code Issues Projects Releases Packages Wiki Activity

Import: merge dives trip-wise

Browse source 
The old way of merging log-files was not well defined: Trips
were recognized as the same if and only if the first dives
started at the same instant. Later dives did not matter.

Change this to merge dives if they are overlapping.
Moreover, on parsing and download generate trips in a separate
trip-table.

This will be fundamental for undo of dive-import: Firstly, we
don't want to mix trips of imported and not-yet imported dives.
Secondly, by merging trip-wise, we can autogroup the dives
in the import-data to trips and merge these at once. This will
simplify the code to decide to which trip dives should be
autogrouped.

Signed-off-by: Berthold Stoeger <bstoeger@mail.tuwien.ac.at>
This commit is contained in:
Berthold Stoeger 2018-12-23 12:46:45 +01:00 • committed by Dirk Hohndel
parent f542dc4030
commit 1593f2ebad
13 changed files with 251 additions and 129 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
core/dive.c
View file

@ -2555,25 +2555,10 @@ static void merge_temperatures(struct dive *res, const struct dive *a, const str
MERGE_NONZERO(res, a, b, watertemp.mkelvin);
}
/*
* When merging two dives, this picks the trip from one, and removes it
* from the other.
*
* The 'next' dive is not involved in the dive merging, but is the dive
* that will be the next dive after the merged dive.
*/
static void pick_trip(struct dive *res, const struct dive *pick)
{
dive_trip_t *trip = pick->divetrip;
res->notrip = pick->notrip;
add_dive_to_trip(res, trip);
}
/*
* Pick a trip for a dive
*/
static const struct dive *get_preferred_trip(const struct dive *a, const struct dive *b)
static struct dive_trip *get_preferred_trip(const struct dive *a, const struct dive *b)
{
dive_trip_t *atrip, *btrip;
@ -2581,33 +2566,33 @@ static const struct dive *get_preferred_trip(const struct dive *a, const struct
atrip = a->divetrip;
btrip = b->divetrip;
if (!atrip)
return b;
return btrip;
if (!btrip)
return a;
return atrip;
/* Both dives have a trip - prefer the non-autogenerated one */
if (atrip->autogen && !btrip->autogen)
return b;
return btrip;
if (!atrip->autogen && btrip->autogen)
return a;
return atrip;
/* Otherwise, look at the trip data and pick the "better" one */
if (!atrip->location)
return b;
return btrip;
if (!btrip->location)
return a;
return atrip;
if (!atrip->notes)
return b;
return btrip;
if (!btrip->notes)
return a;
return atrip;
/*
* Ok, so both have location and notes.
* Pick the earlier one.
*/
if (a->when < b->when)
return a;
return b;
return atrip;
return btrip;
}
#if CURRENTLY_NOT_USED
@ -2903,14 +2888,6 @@ static int likely_same_dive(const struct dive *a, const struct dive *b)
same_string(b->dc.model, "manually added dive"))
return 0;
/* Don't try to merge dives with different trip information
* Exception: if the dive is downloaded without any
* explicit trip information, we do want to merge it
* with existing old dives even if they have trips.
*/
if (a->divetrip != b->divetrip && b->divetrip)
return 0;
/*
* Do some basic sanity testing of the values we
* have filled in during 'fixup_dive()'
@ -3403,7 +3380,6 @@ bool has_planned(const struct dive *dive, bool planned) {
struct dive *merge_dives(const struct dive *a, const struct dive *b, int offset, bool prefer_downloaded, struct dive_trip **trip)
{
struct dive *res = alloc_dive();
const struct dive *preferred_trip;
int cylinders_map_a[MAX_CYLINDERS], cylinders_map_b[MAX_CYLINDERS];
if (offset) {
@ -3424,11 +3400,8 @@ struct dive *merge_dives(const struct dive *a, const struct dive *b, int offset,
}
res->when = prefer_downloaded ? b->when : a->when;
res->selected = a->selected || b->selected;
preferred_trip = get_preferred_trip(a, b);
if (trip)
*trip = preferred_trip->divetrip;
else
pick_trip(res, preferred_trip);
*trip = get_preferred_trip(a, b);
MERGE_TXT(res, a, b, notes, "\n--\n");
MERGE_TXT(res, a, b, buddy, ", ");
MERGE_TXT(res, a, b, divemaster, ", ");

261
core/divelist.c
View file

@ -783,6 +783,13 @@ timestamp_t trip_date(const struct dive_trip *trip)
return trip->dives.dives[0]->when;
}
static timestamp_t trip_enddate(const struct dive_trip *trip)
{
if (!trip || trip->dives.nr == 0)
return 0;
return dive_endtime(trip->dives.dives[trip->dives.nr - 1]);
}
/* check if we have a trip right before / after this dive */
bool is_trip_before_after(const struct dive *dive, bool before)
{
@ -968,6 +975,13 @@ static MAKE_GET_IDX(trip_table, struct dive_trip *, trips)
MAKE_SORT(dive_table, struct dive *, dives, comp_dives)
MAKE_SORT(trip_table, struct dive_trip *, trips, comp_trips)
static void remove_dive(struct dive_table *table, const struct dive *dive)
{
int idx = get_idx_in_dive_table(table, dive);
if (idx >= 0)
remove_from_dive_table(table, idx);
}
/* remove a dive from the trip it's associated to, but don't delete the
* trip if this was the last dive in the trip. the caller is responsible
* for removing the trip, if the trip->dives.nr went to 0.
@ -975,14 +989,11 @@ MAKE_SORT(trip_table, struct dive_trip *, trips, comp_trips)
struct dive_trip *unregister_dive_from_trip(struct dive *dive)
{
dive_trip_t *trip = dive->divetrip;
int idx;
if (!trip)
return NULL;
idx = get_idx_in_dive_table(&trip->dives, dive);
if (idx >= 0)
remove_from_dive_table(&trip->dives, idx);
remove_dive(&trip->dives, dive);
dive->divetrip = NULL;
return trip;
}
@ -1468,29 +1479,175 @@ static void merge_imported_dives(struct dive_table *table)
/*
* Try to merge a new dive into the dive at position idx. Return
* true on success. On success, the dive to add and the old dive
* will be deleted. On failure, they are untouched.
* true on success. On success, the old dive will be deleted. On failure,
* it is unchanged.
* If replace_in is not NULL, the original dive will also be replaced
* by the merged dive in this dive table. If it is NULL it will be
* replaced in the dive table of its trip. This is used for merging dive
* in the trip table *and* the dive table.
* If "prefer_imported" is true, use data of the new dive.
*/
static bool try_to_merge_into(struct dive *dive_to_add, struct trip_table *dive_to_add_trip_table,
int idx, bool prefer_imported)
static bool try_to_merge_into(struct dive *dive_to_add, int idx, struct dive_table *table,
struct dive_table *replace_in, bool prefer_imported)
{
struct dive *old_dive = dive_table.dives[idx];
struct dive *old_dive = table->dives[idx];
struct dive *merged = try_to_merge(old_dive, dive_to_add, prefer_imported);
if (!merged)
return false;
/* Hack alert! If no replace_in table was passed, we are merging
* a non-trip dive into a potentially in-trip dive. In this case
* we also have to replace the merged dive for the old dive in the
* trip list. This will be removed in a subsequent commit, when
* the merging is done outside of processing */
if (!replace_in && old_dive->divetrip)
replace_in = &old_dive->divetrip->dives;
merged->id = old_dive->id;
merged->selected = old_dive->selected;
dive_table.dives[idx] = merged;
remove_dive_from_trip(old_dive, &trip_table);
merged->divetrip = old_dive->divetrip;
old_dive->divetrip = NULL;
table->dives[idx] = merged;
if (replace_in) {
int idx2 = get_idx_in_dive_table(replace_in, old_dive);
if (idx2 >= 0)
replace_in->dives[idx2] = merged;
}
free_dive(old_dive);
remove_dive_from_trip(dive_to_add, dive_to_add_trip_table);
free_dive(dive_to_add);
return true;
}
static bool trips_overlap(const struct dive_trip *t1, const struct dive_trip *t2)
{
/* First, handle the empty-trip cases. */
if (t1->dives.nr == 0 || t2->dives.nr == 0)
return 0;
if (trip_date(t1) < trip_date(t2))
return trip_enddate(t1) >= trip_date(t2);
else
return trip_enddate(t2) >= trip_date(t1);
}
static bool insert_dive(struct dive_table *table, struct dive *d)
{
int idx = dive_table_get_insertion_index(table, d);
add_to_dive_table(table, idx, d);
return idx == table->nr - 1;
}
/* Merge dives from dives_from into dives_to. Overlapping dives will be merged,
* non-overlapping dives will be moved. Optionally, if delete_from and add_to
* are non-null, dives will be removed / added to these tables. This supposes that
* all tables are sorted. */
static bool merge_dive_tables(struct dive_table *dives_from, struct dive_table *delete_from,
struct dive_table *dives_to, struct dive_table *add_to,
bool prefer_imported, struct dive_trip *trip)
{
int i, j;
bool sequence_changed = false;
/* Merge newly imported dives into the dive table.
* Since both lists (old and new) are sorted, we can step
* through them concurrently and locate the insertions points.
* Once found, check if the new dive can be merged in the
* previous or next dive.
* Note that this doesn't consider pathological cases such as:
* - New dive "connects" two old dives (turn three into one).
* - New dive can not be merged into adjacent but some further dive.
*/
j = 0; /* Index in dives_to */
for (i = 0; i < dives_from->nr; i++) {
struct dive *dive_to_add = dives_from->dives[i];
if (delete_from)
remove_dive(delete_from, dive_to_add);
/* Find insertion point. */
while (j < dives_to->nr && dive_less_than(dives_to->dives[j], dive_to_add))
j++;
/* Try to merge into previous dive. */
if (j > 0 && dive_endtime(dives_to->dives[j - 1]) > dive_to_add->when) {
if (try_to_merge_into(dive_to_add, j - 1, dives_to, add_to, prefer_imported)) {
free_dive(dive_to_add);
continue;
}
}
/* That didn't merge into the previous dive. If we're
* at the end of the dive table, quit the loop and add
* all new dives at the end. */
if (j >= dives_to->nr)
break;
/* Try to merge into next dive. */
if (dive_endtime(dive_to_add) > dives_to->dives[j]->when) {
if (try_to_merge_into(dive_to_add, j, dives_to, add_to, prefer_imported)) {
free_dive(dive_to_add);
continue;
}
}
/* We couldnt merge dives, add at the given position. */
add_to_dive_table(dives_to, j, dive_to_add);
dive_to_add->divetrip = trip;
if (add_to)
insert_dive(add_to, dive_to_add);
j++;
sequence_changed = true;
}
/* If there are still dives to add, add them at the end of the dive table. */
for ( ; i < dives_from->nr; i++) {
struct dive *dive_to_add = dives_from->dives[i];
if (delete_from)
remove_dive(delete_from, dive_to_add);
dive_to_add->divetrip = trip;
add_to_dive_table(dives_to, dives_to->nr, dive_to_add);
if (add_to)
sequence_changed |= !insert_dive(add_to, dive_to_add);
}
/* we took care of all dives, clean up the import table */
dives_from->nr = 0;
return sequence_changed;
}
/* Merge the dives of the trip "from" and the dive_table "dives_from" into the trip "to"
* and dive_table "dives_to". If "prefer_imported" is true, dive data of "from" takes
* precedence */
static bool merge_trips(struct dive_trip *from, struct dive_table *dives_from,
struct dive_trip *to, struct dive_table *dives_to, bool prefer_imported)
{
return merge_dive_tables(&from->dives, dives_from, &to->dives, dives_to, prefer_imported, to);
}
static bool add_trip_to_table(struct dive_trip *trip, struct dive_table *dives_from,
struct trip_table *table, struct dive_table *dives_to)
{
int i;
struct dive *d;
bool sequence_changed = false;
for (i = 0; i < trip->dives.nr; i++) {
d = trip->dives.dives[i];
/* Add dive to copy-to table */
sequence_changed |= !insert_dive(dives_to, d);
/* Remove dive from copy-from table */
remove_dive(dives_from, d);
}
/* Add trip to list */
insert_trip(trip, table);
return sequence_changed;
}
/*
* Add imported dive to global dive table. Overlapping dives will
* be merged if possible. If prefer_imported is true, data of the
@ -1498,12 +1655,14 @@ static bool try_to_merge_into(struct dive *dive_to_add, struct trip_table *dive_
* If downloaded is true, only the divecomputer of the first dive
* will be considered, as it is assumed that all dives come from
* the same computer.
* Note: the dives in import_table are consumed! On return import_table
* has size 0.
* Note: the dives in import_table and the trips in import_trip_table
* are consumed. On return both tables have size 0.
*/
void process_imported_dives(struct dive_table *import_table, bool prefer_imported, bool downloaded)
void process_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table,
bool prefer_imported, bool downloaded)
{
int i, j;
struct dive_trip *trip_import, *trip_old;
int preexisting;
bool sequence_changed = false;
@ -1525,63 +1684,39 @@ void process_imported_dives(struct dive_table *import_table, bool prefer_importe
sort_dive_table(import_table);
merge_imported_dives(import_table);
/* Merge newly imported dives into the dive table.
* Since both lists (old and new) are sorted, we can step
* through them concurrently and locate the insertions points.
* Once found, check if the new dive can be merged in the
* previous or next dive.
* Note that this doesn't consider pathological cases such as:
* - New dive "connects" two old dives (turn three into one).
* - New dive can not be merged into adjacent but some further dive.
*/
j = 0; /* Index in old dives */
/* Autogroup dives if desired by user. */
autogroup_dives(import_table, import_trip_table);
preexisting = dive_table.nr; /* Remember old size for renumbering */
for (i = 0; i < import_table->nr; i++) {
struct dive *dive_to_add = import_table->dives[i];
/* Find insertion point. */
while (j < dive_table.nr && dive_less_than(dive_table.dives[j], dive_to_add))
j++;
/* Try to merge into previous dive. */
if (j > 0 && dive_endtime(dive_table.dives[j - 1]) > dive_to_add->when) {
if (try_to_merge_into(dive_to_add, &trip_table, j - 1, prefer_imported))
continue;
/* Merge overlapping trips. Since both trip tables are sorted, we
* could be smarter here, but realistically not a whole lot of trips
* will be imported so do a simple n*m loop until someone complains.
*/
for (i = 0; i < import_trip_table->nr; i++) {
trip_import = import_trip_table->trips[i];
for (j = 0; j < trip_table.nr; j++) {
trip_old = trip_table.trips[j];
if (trips_overlap(trip_import, trip_old)) {
sequence_changed |= merge_trips(trip_import, import_table, trip_old, &dive_table, prefer_imported);
free_trip(trip_import); /* All dives in trip have been consumed -> free */
break;
}
}
/* That didn't merge into the previous dive. If we're
* at the end of the dive table, quit the loop and add
* all new dives at the end. */
if (j >= dive_table.nr)
break;
/* Try to merge into next dive. */
if (dive_endtime(dive_to_add) > dive_table.dives[j]->when) {
if (try_to_merge_into(dive_to_add, &trip_table, j, prefer_imported))
continue;
}
/* We couldnt merge dives, add at the given position. */
add_single_dive(j, dive_to_add);
j++;
sequence_changed = true;
/* If no trip to merge-into was found, add trip as-is. */
if (j == trip_table.nr)
sequence_changed |= add_trip_to_table(trip_import, import_table, &trip_table, &dive_table);
}
import_trip_table->nr = 0; /* All trips were consumed */
/* If there are still dives to add, add them at the end of the dive table. */
for ( ; i < import_table->nr; i++)
add_single_dive(dive_table.nr, import_table->dives[i]);
/* we took care of all dives, clean up the import table */
import_table->nr = 0;
sequence_changed |= merge_dive_tables(import_table, NULL, &dive_table, NULL, prefer_imported, NULL);
/* If the sequence wasn't changed, renumber */
if (!sequence_changed)
try_to_renumber(preexisting);
/* Autogroup dives if desired by user. */
autogroup_dives(&dive_table, &trip_table);
/* Trips may have changed - make sure that they are still ordered */
/* Unlikely, but trip order may have changed owing to merging dives -
* make sure that they are still ordered */
sort_trip_table(&trip_table);
/* We might have deleted the old selected dive.

2
core/divelist.h
View file

@ -18,7 +18,7 @@ extern int init_decompression(struct deco_state *ds, struct dive *dive);
/* divelist core logic functions */
extern void process_loaded_dives();
extern void process_imported_dives(struct dive_table *import_table, bool prefer_imported, bool downloaded);
extern void process_imported_dives(struct dive_table *import_table, struct trip_table *import_trip_table, bool prefer_imported, bool downloaded);
extern char *get_dive_gas_string(const struct dive *dive);
extern struct dive **grow_dive_table(struct dive_table *table);

8
core/downloadfromdcthread.cpp
View file

@ -60,6 +60,7 @@ static void updateRememberedDCs()
DownloadThread::DownloadThread() : downloadTable({ 0 }),
tripTable({ 0 }),
m_data(DCDeviceData::instance())
{
}
@ -81,6 +82,10 @@ void DownloadThread::run()
#endif
qDebug() << "Starting download from " << (internalData->bluetooth_mode ? "BT" : internalData->devname);
clear_table(&downloadTable);
if (tripTable.nr > 0) {
qWarning() << "DownloadThread::run(): Trip table not empty after reset";
tripTable.nr = 0;
}
Q_ASSERT(internalData->download_table != nullptr);
const char *errorText;
@ -309,8 +314,7 @@ struct dive_table *DownloadThread::table()
struct trip_table *DownloadThread::trips()
{
// TODO: Replace by local trip-table
return &trip_table;
return &tripTable;
}
QString DCDeviceData::vendor() const

1
core/downloadfromdcthread.h
View file

@ -74,6 +74,7 @@ public:
private:
struct dive_table downloadTable;
struct trip_table tripTable;
DCDeviceData *m_data;
};

13
desktop-widgets/divelogimportdialog.cpp
View file

@ -900,14 +900,15 @@ int DiveLogImportDialog::parseTxtHeader(QString fileName, char **params, int pnr
void DiveLogImportDialog::on_buttonBox_accepted()
{
struct dive_table table = { 0 };
struct trip_table trips = { 0 };
QStringList r = resultModel->result();
if (ui->knownImports->currentText() != "Manual import") {
for (int i = 0; i < fileNames.size(); ++i) {
if (ui->knownImports->currentText() == "Seabear CSV") {
parse_seabear_log(qPrintable(fileNames[i]), &table, &trip_table);
parse_seabear_log(qPrintable(fileNames[i]), &table, &trips);
} else if (ui->knownImports->currentText() == "Poseidon MkVI") {
QPair<QString, QString> pair = poseidonFileNames(fileNames[i]);
parse_txt_file(qPrintable(pair.second), qPrintable(pair.first), &table, &trip_table);
parse_txt_file(qPrintable(pair.second), qPrintable(pair.first), &table, &trips);
} else {
char *params[49];
int pnr = 0;
@ -924,7 +925,7 @@ void DiveLogImportDialog::on_buttonBox_accepted()
pnr = setup_csv_params(r, params, pnr);
parse_csv_file(qPrintable(fileNames[i]), params, pnr - 1,
specialCSV.contains(ui->knownImports->currentIndex()) ? qPrintable(CSVApps[ui->knownImports->currentIndex()].name) : "csv",
&table, &trip_table);
&table, &trips);
}
}
} else {
@ -988,7 +989,7 @@ void DiveLogImportDialog::on_buttonBox_accepted()
params[pnr++] = intdup(r.indexOf(tr("Rating")));
params[pnr++] = NULL;
parse_manual_file(qPrintable(fileNames[i]), params, pnr - 1, &table, &trip_table);
parse_manual_file(qPrintable(fileNames[i]), params, pnr - 1, &table, &trips);
} else {
char *params[51];
int pnr = 0;
@ -1005,12 +1006,12 @@ void DiveLogImportDialog::on_buttonBox_accepted()
pnr = setup_csv_params(r, params, pnr);
parse_csv_file(qPrintable(fileNames[i]), params, pnr - 1,
specialCSV.contains(ui->knownImports->currentIndex()) ? qPrintable(CSVApps[ui->knownImports->currentIndex()].name) : "csv",
&table, &trip_table);
&table, &trips);
}
}
}
process_imported_dives(&table, false, false);
process_imported_dives(&table, &trips, false, false);
Command::clear();
MainWindow::instance()->refreshDisplay();
}

3
desktop-widgets/downloadfromdivecomputer.cpp
View file

@ -508,6 +508,7 @@ void DownloadFromDCWidget::on_ok_clicked()
if (currentState != DONE && currentState != ERROR)
return;
struct dive_table *table = thread.table();
struct trip_table *trips = thread.trips();
// delete non-selected dives
int total = table->nr;
@ -524,7 +525,7 @@ void DownloadFromDCWidget::on_ok_clicked()
// remember the last downloaded dive (on most dive computers this will be the chronologically
// first new dive) and select it again after processing all the dives
int uniqId = table->dives[table->nr - 1]->id;
process_imported_dives(table, preferDownloaded(), true);
process_imported_dives(table, trips, preferDownloaded(), true);
Command::clear();
// after process_imported_dives does any merging or resorting needed, we need
// to recreate the model for the dive list so we can select the newest dive

5
desktop-widgets/mainwindow.cpp
View file

@ -1708,12 +1708,13 @@ void MainWindow::importFiles(const QStringList fileNames)
QByteArray fileNamePtr;
struct dive_table table = { 0 };
struct trip_table trips = { 0 };
for (int i = 0; i < fileNames.size(); ++i) {
fileNamePtr = QFile::encodeName(fileNames.at(i));
parse_file(fileNamePtr.data(), &table, &trip_table);
parse_file(fileNamePtr.data(), &table, &trips);
}
process_imported_dives(&table, false, false);
process_imported_dives(&table, &trips, false, false);
Command::clear();
refreshDisplay();
}

5
desktop-widgets/subsurfacewebservices.cpp
View file

@ -769,8 +769,9 @@ void DivelogsDeWebServices::buttonClicked(QAbstractButton *button)
}
/* parse file and import dives */
struct dive_table table = { 0 };
parse_file(QFile::encodeName(zipFile.fileName()), &table, &trip_table);
process_imported_dives(&table, false, false);
struct trip_table trips = { 0 };
parse_file(QFile::encodeName(zipFile.fileName()), &table, &trips);
process_imported_dives(&table, &trips, false, false);
MainWindow::instance()->refreshDisplay();
/* store last entered user/pass in config */

5
mobile-widgets/qmlmanager.cpp
View file

@ -339,8 +339,9 @@ void QMLManager::mergeLocalRepo()
{
char *filename = NOCLOUD_LOCALSTORAGE;
struct dive_table table = { 0 };
parse_file(filename, &table, &trip_table);
process_imported_dives(&table, false, false);
struct trip_table trips = { 0 };
parse_file(filename, &table, &trips);
process_imported_dives(&table, &trips, false, false);
}
void QMLManager::copyAppLogToClipboard()

2
qt-models/diveimportedmodel.cpp
View file

@ -157,7 +157,7 @@ void DiveImportedModel::recordDives()
delete_dive_from_table(diveTable, j);
}
process_imported_dives(diveTable, true, true);
process_imported_dives(diveTable, tripTable, true, true);
}
QHash<int, QByteArray> DiveImportedModel::roleNames() const {

18
tests/testmerge.cpp
View file

@ -22,10 +22,11 @@ void TestMerge::testMergeEmpty()
* check that we correctly merge mixed cylinder dives
*/
struct dive_table table = { 0 };
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &table, &trip_table), 0);
process_imported_dives(&table, false, false);
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test48.xml", &table, &trip_table), 0);
process_imported_dives(&table, false, false);
struct trip_table trips = { 0 };
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &table, &trips), 0);
process_imported_dives(&table, &trips, false, false);
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test48.xml", &table, &trips), 0);
process_imported_dives(&table, &trips, false, false);
QCOMPARE(save_dives("./testmerge47+48.ssrf"), 0);
QFile org(SUBSURFACE_TEST_DATA "/dives/test47+48.xml");
org.open(QFile::ReadOnly);
@ -46,10 +47,11 @@ void TestMerge::testMergeBackwards()
* check that we correctly merge mixed cylinder dives
*/
struct dive_table table = { 0 };
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test48.xml", &table, &trip_table), 0);
process_imported_dives(&table, false, false);
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &table, &trip_table), 0);
process_imported_dives(&table, false, false);
struct trip_table trips = { 0 };
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test48.xml", &table, &trips), 0);
process_imported_dives(&table, &trips, false, false);
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47.xml", &table, &trips), 0);
process_imported_dives(&table, &trips, false, false);
QCOMPARE(save_dives("./testmerge47+48.ssrf"), 0);
QFile org(SUBSURFACE_TEST_DATA "/dives/test47+48.xml");
org.open(QFile::ReadOnly);

6
tests/testrenumber.cpp
View file

@ -14,8 +14,9 @@ void TestRenumber::setup()
void TestRenumber::testMerge()
{
struct dive_table table = { 0 };
struct trip_table trips = { 0 };
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47b.xml", &table, &trip_table), 0);
process_imported_dives(&table, false, false);
process_imported_dives(&table, &trips, false, false);
QCOMPARE(dive_table.nr, 1);
QCOMPARE(unsaved_changes(), 1);
mark_divelist_changed(false);
@ -24,8 +25,9 @@ void TestRenumber::testMerge()
void TestRenumber::testMergeAndAppend()
{
struct dive_table table = { 0 };
struct trip_table trips = { 0 };
QCOMPARE(parse_file(SUBSURFACE_TEST_DATA "/dives/test47c.xml", &table, &trip_table), 0);
process_imported_dives(&table, false, false);
process_imported_dives(&table, &trips, false, false);
QCOMPARE(dive_table.nr, 2);
QCOMPARE(unsaved_changes(), 1);
struct dive *d = get_dive(1);