940 lines
40 KiB
C
940 lines
40 KiB
C
#include <dirent.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <limits.h>
|
|
#include <openssl/evp.h>
|
|
#include <sched.h>
|
|
#include <sqlite3.h>
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
#include <lardon3d/feature_store.h>
|
|
#include <lardon3d/geometric_verifier_task.h>
|
|
#include <lardon3d/match_file.h>
|
|
#include <lardon3d/project.h>
|
|
#include <lardon3d/task_queue.h>
|
|
|
|
#define CHECK(condition) \
|
|
do { \
|
|
if (!(condition)) { \
|
|
(void)fprintf(stderr, "Échec ligne %d : %s\n", __LINE__, #condition); \
|
|
return false; \
|
|
} \
|
|
} while (0)
|
|
|
|
static int fixture_parent_count(void) {
|
|
const char *value = getenv("LARDON3D_TEST_GEOMETRIC_PARENT_COUNT");
|
|
if (!value || !value[0]) {
|
|
return 12;
|
|
}
|
|
char *end = NULL;
|
|
long parsed = strtol(value, &end, 10);
|
|
return end && *end == '\0' && parsed >= 12 && parsed <= 10000 ? (int)parsed
|
|
: 12;
|
|
}
|
|
|
|
static bool remove_tree(const char *path) {
|
|
struct stat information;
|
|
if (lstat(path, &information) != 0) {
|
|
return errno == ENOENT;
|
|
}
|
|
if (!S_ISDIR(information.st_mode)) {
|
|
return unlink(path) == 0;
|
|
}
|
|
DIR *directory = opendir(path);
|
|
if (!directory) {
|
|
return false;
|
|
}
|
|
bool ok = true;
|
|
for (struct dirent *entry = readdir(directory); entry;
|
|
entry = readdir(directory)) {
|
|
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
|
|
continue;
|
|
}
|
|
char child[4096];
|
|
int written = snprintf(child, sizeof(child), "%s/%s", path, entry->d_name);
|
|
if (written <= 0 || (size_t)written >= sizeof(child) ||
|
|
!remove_tree(child)) {
|
|
ok = false;
|
|
}
|
|
}
|
|
return closedir(directory) == 0 && rmdir(path) == 0 && ok;
|
|
}
|
|
|
|
static bool fixture_join_path(char *output, size_t capacity, const char *left,
|
|
const char *right) {
|
|
if (!output || capacity == 0 || !left || !right) {
|
|
return false;
|
|
}
|
|
size_t left_size = strlen(left);
|
|
size_t right_size = strlen(right);
|
|
if (left_size == 0 || right_size == 0 || right_size > SIZE_MAX - 2 ||
|
|
left_size > SIZE_MAX - right_size - 2 ||
|
|
left_size + right_size + 2 > capacity) {
|
|
return false;
|
|
}
|
|
memcpy(output, left, left_size);
|
|
output[left_size] = '/';
|
|
memcpy(output + left_size + 1, right, right_size + 1);
|
|
return true;
|
|
}
|
|
|
|
static Lardon3DResourcePolicy policy(void) {
|
|
return (Lardon3DResourcePolicy){
|
|
.system_memory_reserve_bytes = 4ULL * 1024 * 1024 * 1024,
|
|
.emergency_memory_floor_bytes = 2ULL * 1024 * 1024 * 1024,
|
|
.system_cpu_reserve = 4,
|
|
.maximum_cpu_load_ratio = 1.0,
|
|
.maximum_cpu_pressure_avg10 = 100.0,
|
|
.maximum_memory_pressure_avg10 = 100.0,
|
|
.maximum_io_pressure_avg10 = 100.0,
|
|
.io_slot_capacity = 1,
|
|
.gpu_slot_capacity = 1,
|
|
};
|
|
}
|
|
|
|
static bool wait_state(Lardon3DTaskQueue *queue, uint64_t id,
|
|
Lardon3DTaskState wanted,
|
|
Lardon3DTaskSnapshot *snapshot) {
|
|
for (size_t attempt = 0; attempt < 2000000; ++attempt) {
|
|
if (lardon3d_task_queue_get(queue, id, snapshot) &&
|
|
snapshot->state == wanted) {
|
|
return true;
|
|
}
|
|
sched_yield();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool wait_durable(Lardon3DProjectDb *database, uint64_t id,
|
|
Lardon3DTaskState wanted) {
|
|
for (size_t attempt = 0; attempt < 2000000; ++attempt) {
|
|
Lardon3DProjectDbTask task;
|
|
if (lardon3d_project_db_load_task(database, id, &task) ==
|
|
LARDON3D_PROJECT_DB_OK &&
|
|
task.saved_state == wanted) {
|
|
return true;
|
|
}
|
|
sched_yield();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool exec_sql(const char *path, const char *sql) {
|
|
sqlite3 *db = NULL;
|
|
bool ok =
|
|
sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE, NULL) == SQLITE_OK &&
|
|
sqlite3_exec(db, sql, NULL, NULL, NULL) == SQLITE_OK;
|
|
return sqlite3_close(db) == SQLITE_OK && ok;
|
|
}
|
|
|
|
static bool query_integer(const char *path, const char *sql,
|
|
sqlite3_int64 expected) {
|
|
sqlite3 *db = NULL;
|
|
sqlite3_stmt *statement = NULL;
|
|
bool ok =
|
|
sqlite3_open_v2(path, &db, SQLITE_OPEN_READONLY, NULL) == SQLITE_OK &&
|
|
sqlite3_prepare_v2(db, sql, -1, &statement, NULL) == SQLITE_OK &&
|
|
sqlite3_step(statement) == SQLITE_ROW &&
|
|
sqlite3_column_int64(statement, 0) == expected;
|
|
if (statement) {
|
|
(void)sqlite3_finalize(statement);
|
|
}
|
|
return sqlite3_close(db) == SQLITE_OK && ok;
|
|
}
|
|
|
|
typedef struct {
|
|
uint64_t first_match_result_id;
|
|
uint64_t last_match_result_id;
|
|
char second_match_asset_path[PATH_MAX];
|
|
} FreshParentFixture;
|
|
|
|
static void fixture_image_asset_path(const unsigned char hash[32],
|
|
char path[PATH_MAX]) {
|
|
static const char digits[] = "0123456789abcdef";
|
|
char hex[65];
|
|
for (size_t index = 0; index < 32; ++index) {
|
|
hex[2 * index] = digits[hash[index] >> 4U];
|
|
hex[2 * index + 1] = digits[hash[index] & 15U];
|
|
}
|
|
hex[64] = '\0';
|
|
(void)snprintf(path, PATH_MAX, "assets/images/%c%c/%s", hex[0], hex[1],
|
|
hex);
|
|
}
|
|
|
|
static bool fixture_register_image(Lardon3DAppState *state, uint64_t scanset_id,
|
|
unsigned char seed,
|
|
Lardon3DProjectDbImage *image) {
|
|
unsigned char hash[32];
|
|
memset(hash, seed, sizeof(hash));
|
|
char relative[PATH_MAX];
|
|
fixture_image_asset_path(hash, relative);
|
|
Lardon3DProjectDbImageRegisterStatus status;
|
|
return lardon3d_project_db_register_image(
|
|
state->project_db, scanset_id, hash, relative, 1, "fixture.bin",
|
|
"/fixture.bin", 0, (int64_t)seed, &status, image) ==
|
|
LARDON3D_PROJECT_DB_OK;
|
|
}
|
|
|
|
static bool fixture_publish_features(Lardon3DAppState *state,
|
|
const Lardon3DProjectDbImage *image,
|
|
unsigned char salt,
|
|
Lardon3DProjectDbFeatureSet *set) {
|
|
enum { FEATURE_COUNT = 16, DESCRIPTOR_DIMENSION = 32 };
|
|
Lardon3DFeatureKeypoint keypoints[FEATURE_COUNT];
|
|
unsigned char descriptors[FEATURE_COUNT * DESCRIPTOR_DIMENSION];
|
|
memset(keypoints, 0, sizeof(keypoints));
|
|
memset(descriptors, salt, sizeof(descriptors));
|
|
for (uint32_t index = 0; index < FEATURE_COUNT; ++index) {
|
|
keypoints[index].x = 10.0F + (float)index;
|
|
keypoints[index].y = 20.0F + (float)index;
|
|
keypoints[index].size = 1.0F;
|
|
}
|
|
Lardon3DExtractedFeatures features = {
|
|
.image_width = 256,
|
|
.image_height = 256,
|
|
.feature_count = FEATURE_COUNT,
|
|
.keypoints = keypoints,
|
|
.descriptors = descriptors,
|
|
.descriptor_bytes = sizeof(descriptors),
|
|
};
|
|
unsigned char fingerprint[32];
|
|
memset(fingerprint, salt, sizeof(fingerprint));
|
|
return lardon3d_feature_store_publish_v2(
|
|
state, image->image_id, 0, "orb", 1, fingerprint,
|
|
LARDON3D_FEATURE_DESCRIPTOR_U8, DESCRIPTOR_DIMENSION, 0, &features,
|
|
set) == LARDON3D_FEATURE_STORE_OK;
|
|
}
|
|
|
|
static bool fixture_sha256_file(const char *path, unsigned char output[32],
|
|
uint64_t *size) {
|
|
int descriptor = open(path, O_RDONLY | O_CLOEXEC);
|
|
if (descriptor < 0) {
|
|
return false;
|
|
}
|
|
EVP_MD_CTX *context = EVP_MD_CTX_new();
|
|
bool ok = context && EVP_DigestInit_ex(context, EVP_sha256(), NULL) == 1;
|
|
unsigned char bytes[4096];
|
|
uint64_t total = 0;
|
|
for (;;) {
|
|
ssize_t count = read(descriptor, bytes, sizeof(bytes));
|
|
if (count < 0) {
|
|
ok = false;
|
|
break;
|
|
}
|
|
if (count == 0) {
|
|
break;
|
|
}
|
|
if (total > UINT64_MAX - (uint64_t)count ||
|
|
!context ||
|
|
EVP_DigestUpdate(context, bytes, (size_t)count) != 1) {
|
|
ok = false;
|
|
break;
|
|
}
|
|
total += (uint64_t)count;
|
|
}
|
|
unsigned int digest_size = 0;
|
|
ok = ok && context &&
|
|
EVP_DigestFinal_ex(context, output, &digest_size) == 1 &&
|
|
digest_size == 32;
|
|
EVP_MD_CTX_free(context);
|
|
if (close(descriptor) != 0) {
|
|
ok = false;
|
|
}
|
|
if (ok) {
|
|
*size = total;
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
static bool seed_fresh_parents(Lardon3DAppState *state, size_t count,
|
|
FreshParentFixture *fixture) {
|
|
if (!state || !state->project_db || !fixture || count < 2 || count > 64) {
|
|
return false;
|
|
}
|
|
memset(fixture, 0, sizeof(*fixture));
|
|
Lardon3DProjectDbScanSet scanset;
|
|
Lardon3DProjectDbImage image_a;
|
|
Lardon3DProjectDbImage image_b;
|
|
Lardon3DProjectDbFeatureSet set_a;
|
|
Lardon3DProjectDbFeatureSet set_b;
|
|
Lardon3DProjectDbCandidatePair pair;
|
|
if (lardon3d_project_db_create_scanset(state->project_db, "fresh", &scanset) !=
|
|
LARDON3D_PROJECT_DB_OK ||
|
|
!fixture_register_image(state, scanset.scanset_id, 1, &image_a) ||
|
|
!fixture_register_image(state, scanset.scanset_id, 2, &image_b) ||
|
|
!fixture_publish_features(state, &image_a, 3, &set_a) ||
|
|
!fixture_publish_features(state, &image_b, 4, &set_b) ||
|
|
lardon3d_project_db_create_candidate_pair(
|
|
state->project_db, image_a.image_id, image_b.image_id, 1, &pair) !=
|
|
LARDON3D_PROJECT_DB_OK) {
|
|
return false;
|
|
}
|
|
|
|
Lardon3DMatchFileEntry entries[6];
|
|
for (uint32_t index = 0; index < 6; ++index) {
|
|
entries[index] = (Lardon3DMatchFileEntry){
|
|
.feature_index_a = index,
|
|
.feature_index_b = index,
|
|
.distance = (float)(index + 1U),
|
|
};
|
|
}
|
|
for (size_t index = 0; index < count; ++index) {
|
|
char relative[64];
|
|
char full[PATH_MAX];
|
|
int relative_length =
|
|
snprintf(relative, sizeof(relative), "matches-%zu.bin", index + 1);
|
|
int full_length = snprintf(full, sizeof(full), "%s/%s", state->project_path,
|
|
relative);
|
|
if (relative_length <= 0 || (size_t)relative_length >= sizeof(relative) ||
|
|
full_length <= 0 || (size_t)full_length >= sizeof(full)) {
|
|
return false;
|
|
}
|
|
int descriptor =
|
|
open(full, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, 0600);
|
|
if (descriptor < 0) {
|
|
return false;
|
|
}
|
|
bool written = lardon3d_match_file_write(
|
|
descriptor, LARDON3D_FEATURE_DESCRIPTOR_U8, 32,
|
|
set_a.feature_set_id, set_b.feature_set_id, entries, 6) ==
|
|
LARDON3D_MATCH_FILE_OK;
|
|
if (close(descriptor) != 0) {
|
|
written = false;
|
|
}
|
|
unsigned char asset_sha256[32];
|
|
uint64_t asset_size = 0;
|
|
if (!written ||
|
|
!fixture_sha256_file(full, asset_sha256, &asset_size)) {
|
|
return false;
|
|
}
|
|
unsigned char matcher_fingerprint[32];
|
|
memset(matcher_fingerprint, (int)(index + 1),
|
|
sizeof(matcher_fingerprint));
|
|
Lardon3DProjectDbMatchResult parent;
|
|
if (lardon3d_project_db_create_match_result(
|
|
state->project_db, pair.candidate_pair_id, set_a.feature_set_id,
|
|
set_b.feature_set_id, "fixture", 1, matcher_fingerprint,
|
|
LARDON3D_MATCH_RESULT_STATUS_MATCHED, 6, asset_sha256, relative,
|
|
asset_size, (int64_t)(index + 1), &parent) !=
|
|
LARDON3D_PROJECT_DB_OK) {
|
|
return false;
|
|
}
|
|
if (index == 0) {
|
|
fixture->first_match_result_id = parent.match_result_id;
|
|
}
|
|
fixture->last_match_result_id = parent.match_result_id;
|
|
if (index == 1) {
|
|
(void)snprintf(fixture->second_match_asset_path,
|
|
sizeof(fixture->second_match_asset_path), "%s", full);
|
|
}
|
|
}
|
|
return fixture->first_match_result_id != 0 &&
|
|
fixture->last_match_result_id >= fixture->first_match_result_id &&
|
|
fixture->second_match_asset_path[0] != '\0';
|
|
}
|
|
|
|
static bool seed_reusable_parents(const char *path,
|
|
const unsigned char fingerprint[32]) {
|
|
sqlite3 *db = NULL;
|
|
CHECK(sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE, NULL) == SQLITE_OK);
|
|
static const char setup[] =
|
|
"PRAGMA foreign_keys=ON;BEGIN IMMEDIATE;"
|
|
"INSERT INTO scansets(name,created_at,updated_at) VALUES('task',1,1);"
|
|
"INSERT INTO image_assets(sha256,path,size_bytes,state,created_at) "
|
|
"VALUES(zeroblob(32),'assets/images/00/a',1,1,1),"
|
|
"(randomblob(32),'assets/images/00/b',1,1,1);"
|
|
"INSERT INTO "
|
|
"images(scanset_id,asset_id,original_name,source_path,imported_at) "
|
|
"VALUES(1,1,'a','a',1),(1,2,'b','b',1);"
|
|
"INSERT INTO "
|
|
"feature_assets(sha256,path,size_bytes,durability,created_at) "
|
|
"VALUES(randomblob(32),'assets/features/a',1,0,1),"
|
|
"(randomblob(32),'assets/features/b',1,0,1);"
|
|
"INSERT INTO "
|
|
"feature_sets(image_id,feature_asset_id,extractor_kind,extractor_version,"
|
|
"parameter_fingerprint,source_image_sha256,feature_count,descriptor_type,"
|
|
"descriptor_dimension,created_at) VALUES"
|
|
"(1,1,'orb',1,zeroblob(32),zeroblob(32),16,1,32,1),"
|
|
"(2,2,'orb',1,zeroblob(32),zeroblob(32),16,1,32,1);"
|
|
"INSERT INTO candidate_pairs(image_id_a,image_id_b,created_at) "
|
|
"VALUES(1,2,1);"
|
|
"COMMIT;";
|
|
CHECK(sqlite3_exec(db, setup, NULL, NULL, NULL) == SQLITE_OK);
|
|
sqlite3_stmt *parent = NULL;
|
|
sqlite3_stmt *result = NULL;
|
|
CHECK(sqlite3_prepare_v2(
|
|
db,
|
|
"INSERT INTO "
|
|
"match_results(candidate_pair_id,feature_set_id_a,feature_set_id_b,"
|
|
"matcher_kind,matcher_version,parameter_fingerprint,result_status,"
|
|
"match_count,"
|
|
"match_asset_sha256,match_asset_path,match_asset_size_bytes,"
|
|
"created_at) "
|
|
"VALUES(1,1,2,?1,1,?2,1,16,?3,?4,128,1)",
|
|
-1, &parent, NULL) == SQLITE_OK);
|
|
CHECK(sqlite3_prepare_v2(
|
|
db,
|
|
"INSERT INTO "
|
|
"geometric_verification_results(match_result_id,verifier_kind,"
|
|
"verifier_version,parameter_fingerprint,status,inlier_count,inlier_"
|
|
"mask,created_at) "
|
|
"VALUES(?1,1,3,?2,1,0,zeroblob(2),1)",
|
|
-1, &result, NULL) == SQLITE_OK);
|
|
for (int index = 0; index < fixture_parent_count(); ++index) {
|
|
char kind[32];
|
|
char asset[64];
|
|
unsigned char identity[32];
|
|
unsigned char match_hash[32];
|
|
memset(identity, index + 1, sizeof(identity));
|
|
memset(match_hash, index + 33, sizeof(match_hash));
|
|
(void)snprintf(kind, sizeof(kind), "fixture-%d", index);
|
|
(void)snprintf(asset, sizeof(asset), "assets/matches/%d", index);
|
|
sqlite3_bind_text(parent, 1, kind, -1, SQLITE_TRANSIENT);
|
|
sqlite3_bind_blob(parent, 2, identity, 32, SQLITE_TRANSIENT);
|
|
sqlite3_bind_blob(parent, 3, match_hash, 32, SQLITE_TRANSIENT);
|
|
sqlite3_bind_text(parent, 4, asset, -1, SQLITE_TRANSIENT);
|
|
CHECK(sqlite3_step(parent) == SQLITE_DONE);
|
|
CHECK(sqlite3_reset(parent) == SQLITE_OK);
|
|
sqlite3_bind_int64(result, 1, sqlite3_last_insert_rowid(db));
|
|
sqlite3_bind_blob(result, 2, fingerprint, 32, SQLITE_TRANSIENT);
|
|
CHECK(sqlite3_step(result) == SQLITE_DONE);
|
|
CHECK(sqlite3_reset(result) == SQLITE_OK);
|
|
}
|
|
CHECK(sqlite3_finalize(parent) == SQLITE_OK);
|
|
CHECK(sqlite3_finalize(result) == SQLITE_OK);
|
|
return sqlite3_close(db) == SQLITE_OK;
|
|
}
|
|
|
|
static bool add_reusable_results(const char *path,
|
|
uint32_t verifier_version,
|
|
const unsigned char fingerprint[32]) {
|
|
sqlite3 *db = NULL;
|
|
sqlite3_stmt *statement = NULL;
|
|
CHECK(sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE, NULL) == SQLITE_OK);
|
|
CHECK(
|
|
sqlite3_prepare_v2(
|
|
db,
|
|
"INSERT INTO "
|
|
"geometric_verification_results(match_result_id,verifier_kind,"
|
|
"verifier_version,parameter_fingerprint,status,inlier_count,inlier_"
|
|
"mask,created_at) "
|
|
"SELECT match_result_id,1,?1,?2,1,0,zeroblob(2),2 FROM match_results",
|
|
-1, &statement, NULL) == SQLITE_OK);
|
|
sqlite3_bind_int64(statement, 1, verifier_version);
|
|
sqlite3_bind_blob(statement, 2, fingerprint, 32, SQLITE_TRANSIENT);
|
|
int code = sqlite3_step(statement);
|
|
if (code != SQLITE_DONE) {
|
|
(void)fprintf(stderr, "Insertion reuse: %s\n", sqlite3_errmsg(db));
|
|
}
|
|
CHECK(code == SQLITE_DONE);
|
|
CHECK(sqlite3_finalize(statement) == SQLITE_OK);
|
|
return sqlite3_close(db) == SQLITE_OK;
|
|
}
|
|
|
|
static bool update_task_fingerprint(const char *path, uint64_t task_id,
|
|
const unsigned char fingerprint[32]) {
|
|
sqlite3 *db = NULL;
|
|
sqlite3_stmt *statement = NULL;
|
|
bool ok = sqlite3_open_v2(path, &db, SQLITE_OPEN_READWRITE, NULL) == SQLITE_OK &&
|
|
sqlite3_prepare_v2(
|
|
db,
|
|
"UPDATE geometric_verifier_tasks SET parameter_fingerprint=?1 "
|
|
"WHERE task_id=?2",
|
|
-1, &statement, NULL) == SQLITE_OK;
|
|
if (ok) {
|
|
sqlite3_bind_blob(statement, 1, fingerprint, 32, SQLITE_TRANSIENT);
|
|
sqlite3_bind_int64(statement, 2, (sqlite3_int64)task_id);
|
|
ok = sqlite3_step(statement) == SQLITE_DONE && sqlite3_changes(db) == 1;
|
|
}
|
|
if (statement) {
|
|
ok = sqlite3_finalize(statement) == SQLITE_OK && ok;
|
|
}
|
|
return sqlite3_close(db) == SQLITE_OK && ok;
|
|
}
|
|
|
|
static bool run_task_mid_batch_failure_regression_test(void) {
|
|
char root[] = "/tmp/lardon3d-geometric-task-fail-XXXXXX";
|
|
CHECK(mkdtemp(root) != NULL);
|
|
char internal[4096];
|
|
char checkpoints[4096];
|
|
char database_path[4096];
|
|
CHECK(fixture_join_path(internal, sizeof(internal), root, ".lardon3d") &&
|
|
fixture_join_path(checkpoints, sizeof(checkpoints), internal,
|
|
"checkpoints") &&
|
|
fixture_join_path(database_path, sizeof(database_path), internal,
|
|
"project.sqlite3"));
|
|
CHECK(mkdir(internal, 0700) == 0 && mkdir(checkpoints, 0700) == 0);
|
|
|
|
Lardon3DAppState state;
|
|
lardon3d_app_state_init(&state);
|
|
char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY];
|
|
CHECK(lardon3d_project_db_open(database_path, &state.project_db, error) ==
|
|
LARDON3D_PROJECT_DB_OK);
|
|
state.project_loaded = true;
|
|
(void)snprintf(state.project_path, sizeof(state.project_path), "%s", root);
|
|
state.hardware_profile = (Lardon3DHardwareProfile){
|
|
.logical_cpu_count = 16,
|
|
.page_size_bytes = 4096,
|
|
.memory_total_bytes = 16ULL * 1024 * 1024 * 1024,
|
|
.cpu_architecture = "test",
|
|
};
|
|
Lardon3DResourcePolicy resource_policy = policy();
|
|
state.resource_governor = lardon3d_resource_governor_create(
|
|
&state.hardware_profile, &resource_policy);
|
|
state.task_queue = lardon3d_task_queue_create(state.resource_governor, 16);
|
|
CHECK(state.resource_governor && state.task_queue);
|
|
|
|
Lardon3DGeometricVerifierTaskConfiguration configuration = {
|
|
.verifier = lardon3d_geometric_verifier_default_parameters(),
|
|
};
|
|
uint64_t invalid_task_id = 99;
|
|
CHECK(!lardon3d_project_enqueue_geometric_verifier_task(
|
|
NULL, &configuration, &invalid_task_id) &&
|
|
invalid_task_id == 0);
|
|
FreshParentFixture fresh;
|
|
CHECK(seed_fresh_parents(&state, 16, &fresh));
|
|
CHECK(fresh.first_match_result_id == 1 && fresh.last_match_result_id == 16);
|
|
CHECK(query_integer(database_path,
|
|
"SELECT COUNT(*) FROM geometric_verification_results",
|
|
0));
|
|
|
|
/* Fail after fourteen children at the independently safe CPU16 bound. Every
|
|
* created participant must be joined and every fresh opaque stage destroyed
|
|
* before callback-owned batch storage is released; owner publication and
|
|
* cursor mutation stay at zero. ASan supplies the exact lifetime oracle. */
|
|
CHECK(setenv("LARDON3D_TEST_GEOMETRIC_FORCE_PARTICIPANTS", "16", 1) == 0);
|
|
CHECK(setenv("LARDON3D_TEST_GEOMETRIC_THREAD_FAIL_AFTER", "14", 1) == 0);
|
|
uint64_t task_id = 0;
|
|
CHECK(lardon3d_project_enqueue_geometric_verifier_task(&state, &configuration,
|
|
&task_id));
|
|
Lardon3DTaskSnapshot snapshot;
|
|
CHECK(wait_state(state.task_queue, task_id, TASK_FAILED, &snapshot));
|
|
CHECK(wait_durable(state.project_db, task_id, TASK_FAILED));
|
|
CHECK(query_integer(database_path,
|
|
"SELECT after_match_result_id FROM "
|
|
"geometric_verifier_tasks WHERE task_id=(SELECT "
|
|
"MAX(task_id) FROM geometric_verifier_tasks)",
|
|
0));
|
|
CHECK(query_integer(database_path,
|
|
"SELECT COUNT(*) FROM geometric_verification_results",
|
|
0));
|
|
CHECK(unsetenv("LARDON3D_TEST_GEOMETRIC_THREAD_FAIL_AFTER") == 0);
|
|
CHECK(unsetenv("LARDON3D_TEST_GEOMETRIC_FORCE_PARTICIPANTS") == 0);
|
|
|
|
/* Index zero is a genuinely fresh, valid preparation. Removing only index
|
|
* one's immutable Match asset makes a later slot CORRUPT; the all-slot
|
|
* preflight must discard every successful stage before publishing index zero. */
|
|
CHECK(unlink(fresh.second_match_asset_path) == 0);
|
|
|
|
task_id = 0;
|
|
CHECK(lardon3d_project_enqueue_geometric_verifier_task(&state, &configuration,
|
|
&task_id));
|
|
CHECK(wait_state(state.task_queue, task_id, TASK_FAILED, &snapshot));
|
|
CHECK(wait_durable(state.project_db, task_id, TASK_FAILED));
|
|
CHECK(snapshot.message[0] != '\0' &&
|
|
strstr(snapshot.message, "Contrat de lot") == NULL);
|
|
|
|
CHECK(query_integer(database_path,
|
|
"SELECT after_match_result_id FROM geometric_verifier_tasks "
|
|
"WHERE task_id=(SELECT MAX(task_id) FROM "
|
|
"geometric_verifier_tasks)",
|
|
0));
|
|
|
|
CHECK(query_integer(database_path,
|
|
"SELECT COUNT(*) FROM geometric_verification_results", 0));
|
|
|
|
lardon3d_task_queue_destroy(state.task_queue);
|
|
lardon3d_resource_governor_destroy(state.resource_governor);
|
|
lardon3d_project_db_close(state.project_db);
|
|
CHECK(remove_tree(root));
|
|
return true;
|
|
}
|
|
|
|
static bool run_engaged_control_case(bool cancel, size_t parent_count) {
|
|
char root[] = "/tmp/lardon3d-geometric-task-control-XXXXXX";
|
|
CHECK(mkdtemp(root) != NULL);
|
|
char internal[PATH_MAX];
|
|
char checkpoints[PATH_MAX];
|
|
char database_path[PATH_MAX];
|
|
CHECK(fixture_join_path(internal, sizeof(internal), root, ".lardon3d") &&
|
|
fixture_join_path(checkpoints, sizeof(checkpoints), internal,
|
|
"checkpoints") &&
|
|
fixture_join_path(database_path, sizeof(database_path), internal,
|
|
"project.sqlite3"));
|
|
CHECK(mkdir(internal, 0700) == 0 && mkdir(checkpoints, 0700) == 0);
|
|
|
|
Lardon3DAppState state;
|
|
lardon3d_app_state_init(&state);
|
|
char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY];
|
|
CHECK(lardon3d_project_db_open(database_path, &state.project_db, error) ==
|
|
LARDON3D_PROJECT_DB_OK);
|
|
state.project_loaded = true;
|
|
(void)snprintf(state.project_path, sizeof(state.project_path), "%s", root);
|
|
state.hardware_profile = (Lardon3DHardwareProfile){
|
|
.logical_cpu_count = 16,
|
|
.page_size_bytes = 4096,
|
|
.memory_total_bytes = 16ULL * 1024 * 1024 * 1024,
|
|
.cpu_architecture = "test",
|
|
};
|
|
Lardon3DResourcePolicy resource_policy = policy();
|
|
state.resource_governor = lardon3d_resource_governor_create(
|
|
&state.hardware_profile, &resource_policy);
|
|
state.task_queue = lardon3d_task_queue_create(state.resource_governor, 16);
|
|
CHECK(state.resource_governor && state.task_queue);
|
|
|
|
FreshParentFixture fresh;
|
|
CHECK(seed_fresh_parents(&state, parent_count, &fresh));
|
|
CHECK(fresh.first_match_result_id == 1 &&
|
|
fresh.last_match_result_id == parent_count);
|
|
Lardon3DGeometricVerifierTaskConfiguration configuration = {
|
|
.verifier = lardon3d_geometric_verifier_default_parameters(),
|
|
};
|
|
lardon3d_geometric_verifier_task_test_arm_prepublication_barrier();
|
|
uint64_t task_id = 0;
|
|
CHECK(lardon3d_project_enqueue_geometric_verifier_task(&state, &configuration,
|
|
&task_id));
|
|
bool reached =
|
|
lardon3d_geometric_verifier_task_test_wait_prepublication_barrier();
|
|
if (!reached) {
|
|
lardon3d_geometric_verifier_task_test_release_prepublication_barrier();
|
|
}
|
|
CHECK(reached);
|
|
bool requested = cancel
|
|
? lardon3d_task_queue_cancel(state.task_queue, task_id)
|
|
: lardon3d_task_queue_pause(state.task_queue, task_id);
|
|
lardon3d_geometric_verifier_task_test_release_prepublication_barrier();
|
|
CHECK(requested);
|
|
|
|
Lardon3DTaskSnapshot snapshot;
|
|
Lardon3DTaskState expected_state = cancel ? TASK_CANCELLED : TASK_PAUSED;
|
|
CHECK(wait_state(state.task_queue, task_id, expected_state, &snapshot));
|
|
if (cancel) {
|
|
CHECK(wait_durable(state.project_db, task_id, TASK_CANCELLED));
|
|
}
|
|
const uint64_t engaged_cursor = fresh.first_match_result_id + 15;
|
|
Lardon3DProjectDbGeometricVerifierTask durable;
|
|
CHECK(lardon3d_project_db_load_geometric_verifier_task(
|
|
state.project_db, task_id, &durable) == LARDON3D_PROJECT_DB_OK &&
|
|
durable.after_match_result_id == engaged_cursor);
|
|
CHECK(query_integer(database_path,
|
|
"SELECT COUNT(*) FROM geometric_verification_results",
|
|
16));
|
|
char later_results_sql[256];
|
|
int sql_length = snprintf(
|
|
later_results_sql, sizeof(later_results_sql),
|
|
"SELECT COUNT(*) FROM geometric_verification_results WHERE "
|
|
"match_result_id>%llu",
|
|
(unsigned long long)engaged_cursor);
|
|
CHECK(sql_length > 0 && (size_t)sql_length < sizeof(later_results_sql) &&
|
|
query_integer(database_path, later_results_sql, 0));
|
|
|
|
Lardon3DProjectDbTask generic;
|
|
CHECK(lardon3d_project_db_load_task(state.project_db, task_id, &generic) ==
|
|
LARDON3D_PROJECT_DB_OK);
|
|
unsigned int engaged_progress = parent_count == 16 ? 100U : 99U;
|
|
CHECK(generic.progress == engaged_progress);
|
|
if (cancel) {
|
|
CHECK(generic.saved_state == TASK_CANCELLED);
|
|
} else {
|
|
/* The durable RUNNING snapshot is the post-batch checkpoint. Only after it
|
|
* commits does the in-memory Task honor the pending pause. */
|
|
CHECK(generic.saved_state == TASK_RUNNING);
|
|
CHECK(lardon3d_task_queue_resume(state.task_queue, task_id));
|
|
CHECK(wait_durable(state.project_db, task_id, TASK_COMPLETED));
|
|
CHECK(lardon3d_project_db_load_geometric_verifier_task(
|
|
state.project_db, task_id, &durable) == LARDON3D_PROJECT_DB_OK &&
|
|
durable.after_match_result_id == fresh.last_match_result_id);
|
|
CHECK(query_integer(database_path,
|
|
"SELECT COUNT(*) FROM geometric_verification_results",
|
|
(sqlite3_int64)parent_count));
|
|
}
|
|
|
|
lardon3d_task_queue_destroy(state.task_queue);
|
|
lardon3d_resource_governor_destroy(state.resource_governor);
|
|
lardon3d_project_db_close(state.project_db);
|
|
CHECK(remove_tree(root));
|
|
return true;
|
|
}
|
|
|
|
static bool run_engaged_control_regression_tests(void) {
|
|
/* Sixteen exercises the explicit exhausted-batch checkpoint. Seventeen
|
|
* leaves one undispatched parent, proving pause/cancel cannot start a second
|
|
* batch before the engaged prefix becomes the control boundary. */
|
|
return run_engaged_control_case(false, 16) &&
|
|
run_engaged_control_case(true, 16) &&
|
|
run_engaged_control_case(false, 17) &&
|
|
run_engaged_control_case(true, 17);
|
|
}
|
|
|
|
static bool run_task_test(void) {
|
|
char root[] = "/tmp/lardon3d-geometric-task-XXXXXX";
|
|
CHECK(mkdtemp(root) != NULL);
|
|
char internal[4096];
|
|
char checkpoints[4096];
|
|
char database_path[4096];
|
|
CHECK(fixture_join_path(internal, sizeof(internal), root, ".lardon3d") &&
|
|
fixture_join_path(checkpoints, sizeof(checkpoints), internal,
|
|
"checkpoints") &&
|
|
fixture_join_path(database_path, sizeof(database_path), internal,
|
|
"project.sqlite3"));
|
|
CHECK(mkdir(internal, 0700) == 0 && mkdir(checkpoints, 0700) == 0);
|
|
|
|
Lardon3DAppState state;
|
|
lardon3d_app_state_init(&state);
|
|
char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY];
|
|
CHECK(lardon3d_project_db_open(database_path, &state.project_db, error) ==
|
|
LARDON3D_PROJECT_DB_OK);
|
|
state.project_loaded = true;
|
|
(void)snprintf(state.project_path, sizeof(state.project_path), "%s", root);
|
|
state.hardware_profile = (Lardon3DHardwareProfile){
|
|
.logical_cpu_count = 16,
|
|
.page_size_bytes = 4096,
|
|
.memory_total_bytes = 16ULL * 1024 * 1024 * 1024,
|
|
.cpu_architecture = "test",
|
|
};
|
|
Lardon3DResourcePolicy resource_policy = policy();
|
|
state.resource_governor = lardon3d_resource_governor_create(
|
|
&state.hardware_profile, &resource_policy);
|
|
state.task_queue = lardon3d_task_queue_create(state.resource_governor, 16);
|
|
CHECK(state.resource_governor && state.task_queue);
|
|
|
|
Lardon3DGeometricVerifierTaskConfiguration configuration = {
|
|
.verifier = lardon3d_geometric_verifier_default_parameters(),
|
|
};
|
|
unsigned char fingerprint[32];
|
|
lardon3d_geometric_verifier_fingerprint(&configuration.verifier, fingerprint);
|
|
CHECK(setenv("LARDON3D_TEST_GEOMETRIC_PARENT_COUNT", "32", 1) == 0);
|
|
CHECK(seed_reusable_parents(database_path, fingerprint));
|
|
|
|
const Lardon3DTaskKindRegistry *registry =
|
|
lardon3d_task_kind_registry_production();
|
|
const Lardon3DTaskKindDescriptor *descriptor = NULL;
|
|
CHECK(lardon3d_task_kind_registry_lookup(
|
|
registry, LARDON3D_GEOMETRIC_VERIFIER_TASK_KIND, 1, &descriptor) ==
|
|
LARDON3D_TASK_KIND_OK);
|
|
uint64_t task_id = 0;
|
|
CHECK(lardon3d_project_enqueue_geometric_verifier_task(&state, &configuration,
|
|
&task_id));
|
|
Lardon3DTaskSnapshot snapshot;
|
|
CHECK(wait_durable(state.project_db, task_id, TASK_COMPLETED));
|
|
Lardon3DProjectDbGeometricVerifierTask durable;
|
|
CHECK(lardon3d_project_db_load_geometric_verifier_task(
|
|
state.project_db, task_id, &durable) == LARDON3D_PROJECT_DB_OK &&
|
|
durable.after_match_result_id == (uint64_t)fixture_parent_count() &&
|
|
memcmp(durable.parameter_fingerprint, fingerprint, 32) == 0);
|
|
|
|
/* Start with only one compute CPU, acknowledge the first durable sequence,
|
|
* then enlarge the host pool before the real sequence_break. Exact reuse
|
|
* intentionally records zero scientific work, so Governor slow-start stays
|
|
* at CPU1; the sequence count proves fresh admission without manufacturing
|
|
* throughput evidence. */
|
|
resource_policy.system_cpu_reserve = 15;
|
|
CHECK(lardon3d_resource_governor_set_policy(state.resource_governor,
|
|
&resource_policy));
|
|
lardon3d_geometric_verifier_task_test_reset_cpu_contracts();
|
|
lardon3d_geometric_verifier_task_test_arm_sequence_barrier();
|
|
CHECK(lardon3d_project_enqueue_geometric_verifier_task(
|
|
&state, &configuration, &task_id));
|
|
CHECK(lardon3d_geometric_verifier_task_test_wait_sequence_barrier());
|
|
CHECK(lardon3d_project_db_load_geometric_verifier_task(
|
|
state.project_db, task_id, &durable) == LARDON3D_PROJECT_DB_OK &&
|
|
durable.after_match_result_id > 0 &&
|
|
durable.after_match_result_id < (uint64_t)fixture_parent_count());
|
|
resource_policy.system_cpu_reserve = 8;
|
|
CHECK(lardon3d_resource_governor_set_policy(state.resource_governor,
|
|
&resource_policy));
|
|
lardon3d_geometric_verifier_task_test_release_sequence_barrier();
|
|
CHECK(wait_durable(state.project_db, task_id, TASK_COMPLETED));
|
|
CHECK(lardon3d_geometric_verifier_task_test_cpu_contracts() == (1U << 1));
|
|
Lardon3DProjectDbTask readmitted_task;
|
|
CHECK(lardon3d_project_db_load_task(state.project_db, task_id,
|
|
&readmitted_task) ==
|
|
LARDON3D_PROJECT_DB_OK &&
|
|
readmitted_task.sequence_count > 0);
|
|
resource_policy.system_cpu_reserve = 4;
|
|
CHECK(lardon3d_resource_governor_set_policy(state.resource_governor,
|
|
&resource_policy));
|
|
|
|
configuration.verifier.threshold_pixels = 1.6;
|
|
CHECK(lardon3d_geometric_verifier_fingerprint_for_version(
|
|
&configuration.verifier, LARDON3D_GEOMETRIC_VERIFIER_VERSION_V2,
|
|
fingerprint));
|
|
CHECK(add_reusable_results(database_path,
|
|
LARDON3D_GEOMETRIC_VERIFIER_VERSION_V2,
|
|
fingerprint));
|
|
unsigned char current_fingerprint[32];
|
|
CHECK(lardon3d_geometric_verifier_fingerprint_for_version(
|
|
&configuration.verifier, LARDON3D_GEOMETRIC_VERIFIER_VERSION_V3,
|
|
current_fingerprint));
|
|
CHECK(add_reusable_results(database_path,
|
|
LARDON3D_GEOMETRIC_VERIFIER_VERSION_V3,
|
|
current_fingerprint));
|
|
CHECK(setenv("LARDON3D_TEST_GEOMETRIC_PAUSE_AFTER_PUBLICATION", "1", 1) == 0);
|
|
CHECK(lardon3d_project_enqueue_geometric_verifier_task(&state, &configuration,
|
|
&task_id));
|
|
CHECK(wait_state(state.task_queue, task_id, TASK_PAUSED, &snapshot));
|
|
CHECK(lardon3d_project_db_load_geometric_verifier_task(
|
|
state.project_db, task_id, &durable) == LARDON3D_PROJECT_DB_OK &&
|
|
durable.after_match_result_id == 0);
|
|
CHECK(setenv("LARDON3D_TEST_GEOMETRIC_SKIP_FINISHED_CHECKPOINT", "1", 1) ==
|
|
0);
|
|
lardon3d_task_queue_destroy(state.task_queue);
|
|
state.task_queue = NULL;
|
|
lardon3d_project_db_close(state.project_db);
|
|
state.project_db = NULL;
|
|
// Simulate a historical v1 durable row at the crash boundary. Recovery must
|
|
// derive v1 from this exact fingerprint without a schema-version column.
|
|
CHECK(lardon3d_geometric_verifier_fingerprint_for_version(
|
|
&configuration.verifier, LARDON3D_GEOMETRIC_VERIFIER_VERSION_V1,
|
|
fingerprint));
|
|
CHECK(update_task_fingerprint(database_path, task_id, fingerprint));
|
|
CHECK(add_reusable_results(database_path,
|
|
LARDON3D_GEOMETRIC_VERIFIER_VERSION_V1,
|
|
fingerprint));
|
|
CHECK(lardon3d_project_db_open(database_path, &state.project_db, error) ==
|
|
LARDON3D_PROJECT_DB_OK);
|
|
state.task_queue = lardon3d_task_queue_create(state.resource_governor, 16);
|
|
CHECK(state.task_queue != NULL);
|
|
CHECK(unsetenv("LARDON3D_TEST_GEOMETRIC_PAUSE_AFTER_PUBLICATION") == 0);
|
|
CHECK(unsetenv("LARDON3D_TEST_GEOMETRIC_SKIP_FINISHED_CHECKPOINT") == 0);
|
|
Lardon3DProjectRecoverySummary recovery;
|
|
Lardon3DProjectDbResult recovery_result =
|
|
lardon3d_project_resume_recoverable_tasks(
|
|
&state, lardon3d_task_kind_registry_production(), &recovery);
|
|
if (recovery_result != LARDON3D_PROJECT_DB_OK || recovery.resumed != 1) {
|
|
(void)fprintf(
|
|
stderr,
|
|
"Recovery result=%d inspected=%zu resumed=%zu skipped=%zu failed=%zu\n",
|
|
recovery_result, recovery.inspected, recovery.resumed, recovery.skipped,
|
|
recovery.failed);
|
|
}
|
|
CHECK(recovery_result == LARDON3D_PROJECT_DB_OK && recovery.resumed == 1);
|
|
CHECK(wait_durable(state.project_db, task_id, TASK_COMPLETED));
|
|
CHECK(lardon3d_project_db_load_geometric_verifier_task(
|
|
state.project_db, task_id, &durable) == LARDON3D_PROJECT_DB_OK &&
|
|
durable.after_match_result_id == (uint64_t)fixture_parent_count());
|
|
|
|
configuration.verifier.threshold_pixels = 1.7;
|
|
CHECK(lardon3d_geometric_verifier_fingerprint_for_version(
|
|
&configuration.verifier, LARDON3D_GEOMETRIC_VERIFIER_VERSION_V2,
|
|
fingerprint));
|
|
CHECK(add_reusable_results(database_path,
|
|
LARDON3D_GEOMETRIC_VERIFIER_VERSION_V2,
|
|
fingerprint));
|
|
CHECK(lardon3d_geometric_verifier_fingerprint_for_version(
|
|
&configuration.verifier, LARDON3D_GEOMETRIC_VERIFIER_VERSION_V3,
|
|
current_fingerprint));
|
|
CHECK(add_reusable_results(database_path,
|
|
LARDON3D_GEOMETRIC_VERIFIER_VERSION_V3,
|
|
current_fingerprint));
|
|
CHECK(setenv("LARDON3D_TEST_GEOMETRIC_PAUSE_AFTER_PUBLICATION", "1", 1) == 0);
|
|
CHECK(lardon3d_project_enqueue_geometric_verifier_task(&state, &configuration,
|
|
&task_id));
|
|
CHECK(wait_state(state.task_queue, task_id, TASK_PAUSED, &snapshot));
|
|
CHECK(setenv("LARDON3D_TEST_GEOMETRIC_SKIP_FINISHED_CHECKPOINT", "1", 1) ==
|
|
0);
|
|
lardon3d_task_queue_destroy(state.task_queue);
|
|
state.task_queue = NULL;
|
|
lardon3d_project_db_close(state.project_db);
|
|
state.project_db = NULL;
|
|
// Historical v2 reconstruction uses its exact immutable fingerprint; the
|
|
// current v3 task identity must never relabel this durable row.
|
|
CHECK(update_task_fingerprint(database_path, task_id, fingerprint));
|
|
CHECK(lardon3d_project_db_open(database_path, &state.project_db, error) ==
|
|
LARDON3D_PROJECT_DB_OK);
|
|
state.task_queue = lardon3d_task_queue_create(state.resource_governor, 16);
|
|
CHECK(state.task_queue != NULL);
|
|
CHECK(unsetenv("LARDON3D_TEST_GEOMETRIC_PAUSE_AFTER_PUBLICATION") == 0);
|
|
CHECK(unsetenv("LARDON3D_TEST_GEOMETRIC_SKIP_FINISHED_CHECKPOINT") == 0);
|
|
recovery_result = lardon3d_project_resume_recoverable_tasks(
|
|
&state, lardon3d_task_kind_registry_production(), &recovery);
|
|
CHECK(recovery_result == LARDON3D_PROJECT_DB_OK && recovery.resumed == 1);
|
|
CHECK(wait_durable(state.project_db, task_id, TASK_COMPLETED));
|
|
|
|
configuration.verifier.threshold_pixels = 1.8;
|
|
CHECK(lardon3d_geometric_verifier_fingerprint_for_version(
|
|
&configuration.verifier, LARDON3D_GEOMETRIC_VERIFIER_VERSION_V3,
|
|
fingerprint));
|
|
CHECK(add_reusable_results(database_path,
|
|
LARDON3D_GEOMETRIC_VERIFIER_VERSION_V3,
|
|
fingerprint));
|
|
CHECK(setenv("LARDON3D_TEST_GEOMETRIC_PAUSE_AFTER_PUBLICATION", "1", 1) == 0);
|
|
CHECK(lardon3d_project_enqueue_geometric_verifier_task(&state, &configuration,
|
|
&task_id));
|
|
CHECK(wait_state(state.task_queue, task_id, TASK_PAUSED, &snapshot));
|
|
CHECK(lardon3d_task_queue_cancel(state.task_queue, task_id));
|
|
CHECK(wait_state(state.task_queue, task_id, TASK_CANCELLED, &snapshot));
|
|
CHECK(unsetenv("LARDON3D_TEST_GEOMETRIC_PAUSE_AFTER_PUBLICATION") == 0);
|
|
|
|
lardon3d_task_queue_destroy(state.task_queue);
|
|
lardon3d_resource_governor_destroy(state.resource_governor);
|
|
lardon3d_project_db_close(state.project_db);
|
|
CHECK(exec_sql(
|
|
database_path,
|
|
"PRAGMA foreign_keys=OFF;BEGIN IMMEDIATE;"
|
|
"DROP TABLE IF EXISTS feature_extract_batch_tasks;"
|
|
"DROP TABLE IF EXISTS raw_development_batch_tasks;"
|
|
"DROP TABLE IF EXISTS capture_calibration_selections;"
|
|
"DROP TABLE IF EXISTS optical_calibration_profiles;"
|
|
"DROP TABLE IF EXISTS capture_optical_configurations;"
|
|
"DROP INDEX IF EXISTS acquisition_campaign_capture_identity_v23;"
|
|
"DROP TABLE IF EXISTS acquisition_campaign_group_optics;"
|
|
"DROP TABLE IF EXISTS optical_configurations;"
|
|
"DROP TABLE IF EXISTS lens_profile_aliases;DROP TABLE IF EXISTS lens_profiles;"
|
|
"DROP TABLE IF EXISTS camera_body_aliases;DROP TABLE IF EXISTS camera_body_profiles;"
|
|
"DROP TABLE IF EXISTS asset_derivations;"
|
|
"DROP TABLE IF EXISTS capture_selections;"
|
|
"DROP TABLE IF EXISTS capture_assets;"
|
|
"DROP TABLE IF EXISTS capture_images;"
|
|
"DROP TABLE IF EXISTS captures;"
|
|
"DROP TABLE IF EXISTS incremental_reconstruction_tasks;"
|
|
"DROP TABLE IF EXISTS incremental_reconstructions;"
|
|
"DROP TABLE IF EXISTS sparse_sfm_tasks;"
|
|
"DROP TABLE IF EXISTS sparse_landmark_observations;"
|
|
"DROP TABLE IF EXISTS sparse_landmarks;"
|
|
"DROP TABLE IF EXISTS sparse_registered_images;"
|
|
"DROP TABLE IF EXISTS sparse_reconstruction_components;"
|
|
"DROP TABLE IF EXISTS sparse_reconstructions;"
|
|
"DROP TABLE IF EXISTS sparse_calibration_scope_images;"
|
|
"DROP TABLE IF EXISTS sparse_calibration_scopes;"
|
|
"DROP TABLE IF EXISTS sparse_calibrations;"
|
|
"DROP TABLE geometric_verifier_tasks;"
|
|
"DROP TABLE track_observations;"
|
|
"DROP TABLE tracks;"
|
|
"DROP TABLE track_sets;"
|
|
"DROP TABLE track_builder_tasks;"
|
|
"UPDATE metadata SET value=12 WHERE key='schema_version';COMMIT;"));
|
|
CHECK(setenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V13", "1", 1) == 0);
|
|
Lardon3DProjectDb *database = NULL;
|
|
CHECK(lardon3d_project_db_open(database_path, &database, error) ==
|
|
LARDON3D_PROJECT_DB_IO_ERROR);
|
|
CHECK(unsetenv("LARDON3D_TEST_PROJECT_DB_FAIL_MIGRATION_V13") == 0);
|
|
CHECK(query_integer(database_path,
|
|
"SELECT value FROM metadata WHERE key='schema_version'",
|
|
12));
|
|
CHECK(
|
|
query_integer(database_path,
|
|
"SELECT count(*) FROM sqlite_master WHERE type='table' AND "
|
|
"name='geometric_verifier_tasks'",
|
|
0));
|
|
CHECK(lardon3d_project_db_open(database_path, &database, error) ==
|
|
LARDON3D_PROJECT_DB_OK);
|
|
CHECK(lardon3d_project_db_schema_version(database) == LARDON3D_PROJECT_DB_SCHEMA_VERSION);
|
|
lardon3d_project_db_close(database);
|
|
CHECK(unsetenv("LARDON3D_TEST_GEOMETRIC_PARENT_COUNT") == 0);
|
|
CHECK(remove_tree(root));
|
|
return true;
|
|
}
|
|
|
|
int main(void) {
|
|
return (run_task_test() && run_task_mid_batch_failure_regression_test() &&
|
|
run_engaged_control_regression_tests())
|
|
? EXIT_SUCCESS
|
|
: EXIT_FAILURE;
|
|
}
|