fy59/trainlog
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
trainlog/tui/tests/test_training_context.c

371 lines
24 KiB
C
Raw Blame History

#include "trainlog/training_context.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sqlite3.h>
#define CHECK(test) do { if (!(test)) { fprintf(stderr, "CHECK failed: %s:%d: %s\n", \
__FILE__, __LINE__, #test); return 1; } } while (0)
static void base_occurrence(TrainlogSessionExerciseInput *value, const char *entry_id,
const char *exercise_id, const char *equipment_id, TrainlogLoadMode mode)
{
(void)memset(value, 0, sizeof(*value));
(void)snprintf(value->entry_id, sizeof(value->entry_id), "%s", entry_id);
(void)snprintf(value->exercise_id, sizeof(value->exercise_id), "%s", exercise_id);
(void)snprintf(value->equipment_id, sizeof(value->equipment_id), "%s", equipment_id);
value->recording_mode = TRAINLOG_RECORDING_SETS;
value->load_mode = mode;
value->rest_seconds = 60;
value->target_sets = 2;
value->target_reps = 10;
value->target_has_weight = mode != TRAINLOG_LOAD_NONE;
value->target_weight_kg = 20.0;
}
static int insert_session(TrainlogDatabase *database, const char *session_id, const char *started_at,
TrainlogSessionType type, TrainlogSessionExerciseInput *items, size_t count)
{
TrainlogSessionInput session = {0};
(void)snprintf(session.session_id, sizeof(session.session_id), "%s", session_id);
(void)snprintf(session.started_at, sizeof(session.started_at), "%s", started_at);
(void)snprintf(session.ended_at, sizeof(session.ended_at), "%s", started_at);
session.session_type = type;
session.exercises = items;
session.exercise_count = count;
return trainlog_database_insert_session(database, &session) == TRAINLOG_STATUS_OK;
}
int main(void)
{
const char *exercise_id = "ex_b432623f-bfe9-4daf-a653-60ec7fdffbde";
const char *zones[] = {"glutes"};
TrainlogDatabase *database = NULL;
TrainlogSessionExerciseInput occurrences[2];
TrainlogSessionExerciseInput max_occurrence;
TrainlogSessionExerciseInput assistance_occurrence;
TrainlogSessionExerciseInput continuous_occurrence;
TrainlogSessionExerciseInput large_occurrence;
TrainlogSessionExerciseInput temporal_occurrence;
TrainlogSessionExerciseInput temporal_max;
TrainlogSetInput first_sets[2] = {{8,0,false,0.0},{6,0,true,0.0}};
TrainlogSetInput second_sets[1] = {{11,0,true,30.0}};
TrainlogSetInput assistance_set[1] = {{9,0,true,15.0}};
TrainlogSetInput large_sets[65];
TrainlogTrainingExerciseContext context;
TrainlogExerciseOccurrence page[1];
TrainlogExerciseOccurrenceCursor next;
TrainlogExerciseOccurrenceCursor cursor;
bool has_more = false;
size_t count = 0U;
size_t index;
TrainlogOccurrenceSet set_page[64];
int next_position = -1;
char database_path[] = "/tmp/trainlog-context-XXXXXX";
int database_fd = mkstemp(database_path);
sqlite3 *raw = NULL;
CHECK(database_fd >= 0);
CHECK(close(database_fd) == 0);
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_insert_exercise_profiled(database, exercise_id, "Leg press renamed",
"leg press renamed", TRAINLOG_TRACKING_REPS, TRAINLOG_RECORDING_SETS, 0U) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_replace_exercise_body_zones(database, exercise_id, "thighs", zones, 1U)
== TRAINLOG_STATUS_OK);
base_occurrence(&occurrences[0], "entry_a", exercise_id, "leg_press", TRAINLOG_LOAD_EXTERNAL);
occurrences[0].sets=first_sets; occurrences[0].set_count=2U;
base_occurrence(&occurrences[1], "entry_b", exercise_id, "plate_loaded_leg_press", TRAINLOG_LOAD_EXTERNAL);
occurrences[1].sets=second_sets; occurrences[1].set_count=1U;
CHECK(insert_session(database,"session_b","2026-09-08T12:00:00+02:00",TRAINLOG_SESSION_TRAINING,occurrences,2U));
base_occurrence(&assistance_occurrence,"entry_assist",exercise_id,"leg_press",TRAINLOG_LOAD_ASSISTANCE);
assistance_occurrence.sets=assistance_set; assistance_occurrence.set_count=1U;
CHECK(insert_session(database,"session_a","2026-09-08T11:00:00+00:00",TRAINLOG_SESSION_TRAINING,&assistance_occurrence,1U));
base_occurrence(&max_occurrence,"entry_max",exercise_id,"leg_press",TRAINLOG_LOAD_EXTERNAL);
max_occurrence.has_max_weight=true; max_occurrence.max_weight_kg=120.0;
max_occurrence.target_sets=0; max_occurrence.target_reps=0;
max_occurrence.target_has_weight=false; max_occurrence.target_weight_kg=0.0;
max_occurrence.rest_seconds=0;
max_occurrence.load_mode=TRAINLOG_LOAD_NONE;
CHECK(insert_session(database,"session_max","2026-09-09T10:00:00+02:00",TRAINLOG_SESSION_MAX_TEST,&max_occurrence,1U));
CHECK(trainlog_database_latest_explicit_max_equipment_context(database,
exercise_id, "leg_press", &context.latest_max) == TRAINLOG_STATUS_OK);
CHECK(context.latest_max.found && context.latest_max.max_weight_kg == 120.0);
CHECK(trainlog_database_latest_explicit_max_equipment_context(database,
exercise_id, "plate_loaded_leg_press", &context.latest_max) == TRAINLOG_STATUS_OK);
CHECK(!context.latest_max.found);
CHECK(trainlog_database_latest_explicit_max_equipment_context(database,
exercise_id, "", &context.latest_max) == TRAINLOG_STATUS_INVALID_ARGUMENT);
CHECK(trainlog_training_exercise_context_load(database,exercise_id,4U,1U,&context)==TRAINLOG_STATUS_OK);
CHECK(strcmp(context.exercise.name,"Leg press renamed")==0);
CHECK(context.knowledge!=NULL && context.knowledge->interpretation!=NULL);
CHECK(context.persisted_zone_count==2U);
CHECK(context.compatible_equipment_count==2U);
CHECK(context.latest_max.found && context.latest_max.max_weight_kg==120.0);
CHECK(context.occurrence_count==4U);
CHECK(strcmp(context.occurrences[0].occurrence.entry_id,"entry_max")==0);
CHECK(context.occurrences[0].set_count==0U); /* explicit MAX is not a fake set */
CHECK(context.occurrences[1].occurrence.load_mode==TRAINLOG_LOAD_ASSISTANCE);
CHECK(strcmp(context.occurrences[2].occurrence.entry_id,"entry_b")==0);
CHECK(context.occurrences[2].set_count==1U && !context.occurrences[2].sets_have_more);
CHECK(strcmp(context.occurrences[3].occurrence.entry_id,"entry_a")==0);
CHECK(context.occurrences[3].set_count==1U && context.occurrences[3].sets_have_more);
CHECK(context.sets[context.occurrences[3].set_offset].has_weight==false);
trainlog_training_exercise_context_release(&context);
CHECK(trainlog_database_list_occurrence_sets_page(database,"entry_a",0,64U,set_page,&count,&has_more,
&next_position)==TRAINLOG_STATUS_OK);
CHECK(count==1U && !has_more && set_page[0].has_weight && set_page[0].weight_kg==0.0);
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,NULL,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_OK);
CHECK(count==1U && has_more);
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&next,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_OK);
CHECK(count==1U);
cursor=next; cursor.entry_id[0]='\0';
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_INVALID_ARGUMENT);
cursor=next; (void)memset(cursor.started_at,'x',sizeof(cursor.started_at));
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_INVALID_ARGUMENT);
cursor=next; (void)memset(cursor.session_id,'x',sizeof(cursor.session_id));
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_INVALID_ARGUMENT);
cursor=next; (void)memset(cursor.entry_id,'x',sizeof(cursor.entry_id));
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_INVALID_ARGUMENT);
cursor=next; (void)snprintf(cursor.started_at,sizeof(cursor.started_at),"not-a-date");
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_INVALID_ARGUMENT);
cursor=next; (void)snprintf(cursor.started_at,sizeof(cursor.started_at),"2026-13-01T00:00:00+00:00");
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_INVALID_ARGUMENT);
cursor=next; (void)snprintf(cursor.started_at,sizeof(cursor.started_at),"2026-02-30T00:00:00+00:00");
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_INVALID_ARGUMENT);
{
const char *invalid_timestamp[] = {
"0000-01-01T00:00:00Z", "2026-09-05 18:34:12Z", "20260905T183412Z",
"2026-W36-5T18:34:12Z", "2026-09-05T18:34:12,5Z",
"2026-09-05T18:34:12+0200", "2026-09-05T18:34:12+02",
"2026-09-05T18:34.5Z", "2026-09-05T18:34:60Z", "2026-09-05T18:34:12+24:00"
};
for(index=0U;index<sizeof(invalid_timestamp)/sizeof(invalid_timestamp[0]);++index){
(void)memset(&cursor,0,sizeof(cursor));
(void)snprintf(cursor.started_at,sizeof(cursor.started_at),"%s",invalid_timestamp[index]);
(void)snprintf(cursor.session_id,sizeof(cursor.session_id),"session_b");
(void)snprintf(cursor.entry_id,sizeof(cursor.entry_id),"entry_b");
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_INVALID_ARGUMENT);
}
}
cursor=next; (void)snprintf(cursor.started_at,sizeof(cursor.started_at),"2026-09-08T10:00:00+15:00");
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_OK);
(void)memset(&cursor,0,sizeof(cursor));
(void)snprintf(cursor.started_at,sizeof(cursor.started_at),"2026-09-08T10:00:00Z");
(void)snprintf(cursor.session_id,sizeof(cursor.session_id),"session_b");
(void)snprintf(cursor.entry_id,sizeof(cursor.entry_id),"entry_b");
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_OK);
/* TEMPORAL_READER_V1: production paging must preserve exceptional source
* spellings and use the same exact comparator for every exclusive cursor. */
base_occurrence(&temporal_occurrence,"entry_frac_low",exercise_id,"",TRAINLOG_LOAD_NONE);
temporal_occurrence.target_has_weight=false; temporal_occurrence.target_weight_kg=0.0;
CHECK(insert_session(database,"session_frac_low","2026-09-21T10:00:00.1234567890123456Z",
TRAINLOG_SESSION_TRAINING,&temporal_occurrence,1U));
base_occurrence(&temporal_occurrence,"entry_frac_high",exercise_id,"",TRAINLOG_LOAD_NONE);
temporal_occurrence.target_has_weight=false; temporal_occurrence.target_weight_kg=0.0;
CHECK(insert_session(database,"session_frac_high","2026-09-21T10:00:00.1234567890123457Z",
TRAINLOG_SESSION_TRAINING,&temporal_occurrence,1U));
base_occurrence(&temporal_occurrence,"entry_lower",exercise_id,"",TRAINLOG_LOAD_NONE);
temporal_occurrence.target_has_weight=false; temporal_occurrence.target_weight_kg=0.0;
CHECK(insert_session(database,"session_lower","2026-09-20t10:00:00z",TRAINLOG_SESSION_TRAINING,
&temporal_occurrence,1U));
base_occurrence(&temporal_occurrence,"entry_omit",exercise_id,"",TRAINLOG_LOAD_NONE);
temporal_occurrence.target_has_weight=false; temporal_occurrence.target_weight_kg=0.0;
CHECK(insert_session(database,"session_omit","2026-09-22T10:00+15:00",TRAINLOG_SESSION_TRAINING,
&temporal_occurrence,1U));
base_occurrence(&temporal_occurrence,"entry_high_offset",exercise_id,"",TRAINLOG_LOAD_NONE);
temporal_occurrence.target_has_weight=false; temporal_occurrence.target_weight_kg=0.0;
CHECK(insert_session(database,"session_high_offset","2026-09-22T10:00:00+23:59",TRAINLOG_SESSION_TRAINING,
&temporal_occurrence,1U));
base_occurrence(&temporal_occurrence,"entry_tie_a",exercise_id,"",TRAINLOG_LOAD_NONE);
temporal_occurrence.target_has_weight=false; temporal_occurrence.target_weight_kg=0.0;
CHECK(insert_session(database,"session_tie_a","2026-09-20T12:00:00+02:00",TRAINLOG_SESSION_TRAINING,
&temporal_occurrence,1U));
base_occurrence(&temporal_occurrence,"entry_tie_z",exercise_id,"",TRAINLOG_LOAD_NONE);
temporal_occurrence.target_has_weight=false; temporal_occurrence.target_weight_kg=0.0;
CHECK(insert_session(database,"session_tie_z","2026-09-20T10:00:00-00:00",TRAINLOG_SESSION_TRAINING,
&temporal_occurrence,1U));
{
const char *expected[] = {"entry_omit","entry_high_offset","entry_frac_high","entry_frac_low",
"entry_tie_z","entry_tie_a","entry_lower"};
TrainlogExerciseOccurrenceCursor temporal_cursor;
const TrainlogExerciseOccurrenceCursor *after_temporal = NULL;
for(index=0U;index<7U;++index){
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,after_temporal,1U,
page,&count,&has_more,&temporal_cursor)==TRAINLOG_STATUS_OK);
CHECK(count==1U && strcmp(page[0].entry_id,expected[index])==0);
CHECK(strcmp(page[0].started_at,temporal_cursor.started_at)==0);
after_temporal=&temporal_cursor;
}
}
base_occurrence(&temporal_max,"entry_max_offset",exercise_id,"",TRAINLOG_LOAD_NONE);
temporal_max.target_sets=0; temporal_max.target_reps=0; temporal_max.target_has_weight=false;
temporal_max.rest_seconds=0; temporal_max.has_max_weight=true; temporal_max.max_weight_kg=151.0;
CHECK(insert_session(database,"session_max_offset","2026-09-23T10:00:00+15:00",
TRAINLOG_SESSION_MAX_TEST,&temporal_max,1U));
base_occurrence(&temporal_max,"entry_max_true",exercise_id,"",TRAINLOG_LOAD_NONE);
temporal_max.target_sets=0; temporal_max.target_reps=0; temporal_max.target_has_weight=false;
temporal_max.rest_seconds=0; temporal_max.has_max_weight=true; temporal_max.max_weight_kg=152.0;
CHECK(insert_session(database,"session_max_true","2026-09-22T20:00:00Z",
TRAINLOG_SESSION_MAX_TEST,&temporal_max,1U));
CHECK(trainlog_database_latest_explicit_max_context(database,exercise_id,&context.latest_max)==TRAINLOG_STATUS_OK);
CHECK(context.latest_max.found && strcmp(context.latest_max.entry_id,"entry_max_true")==0 &&
context.latest_max.max_weight_kg==152.0);
(void)memset(&cursor,0,sizeof(cursor));
(void)snprintf(cursor.started_at,sizeof(cursor.started_at),"2026-09-08T12:00:00+02:00");
(void)snprintf(cursor.session_id,sizeof(cursor.session_id),"session_b");
(void)snprintf(cursor.entry_id,sizeof(cursor.entry_id),"entry_b");
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,&cursor,1U,page,&count,
&has_more,&next)==TRAINLOG_STATUS_OK);
CHECK(trainlog_database_insert_exercise(database,"ex_unknown_runtime","Custom renamed","custom renamed",
TRAINLOG_TRACKING_REPS)==TRAINLOG_STATUS_OK);
CHECK(trainlog_training_exercise_context_load(database,"ex_unknown_runtime",1U,1U,&context)==TRAINLOG_STATUS_OK);
CHECK(context.knowledge==NULL && context.occurrence_count==0U);
trainlog_training_exercise_context_release(&context);
CHECK(trainlog_database_insert_exercise_profiled(database,"ex_b1e6ffc6-75b5-45ff-a3c0-e7433c58013d",
"Marche renommée","marche renommee",TRAINLOG_TRACKING_DURATION,TRAINLOG_RECORDING_CONTINUOUS,
TRAINLOG_EXERCISE_DATA_SPEED_KMH)==TRAINLOG_STATUS_OK);
(void)memset(&continuous_occurrence,0,sizeof(continuous_occurrence));
(void)snprintf(continuous_occurrence.entry_id,sizeof(continuous_occurrence.entry_id),"entry_walk");
(void)snprintf(continuous_occurrence.exercise_id,sizeof(continuous_occurrence.exercise_id),"%s",
"ex_b1e6ffc6-75b5-45ff-a3c0-e7433c58013d");
(void)snprintf(continuous_occurrence.equipment_id,sizeof(continuous_occurrence.equipment_id),"treadmill");
continuous_occurrence.recording_mode=TRAINLOG_RECORDING_CONTINUOUS;
continuous_occurrence.data_fields=TRAINLOG_EXERCISE_DATA_SPEED_KMH;
continuous_occurrence.load_mode=TRAINLOG_LOAD_NONE;
continuous_occurrence.continuous_duration_seconds=900;
continuous_occurrence.continuous_has_speed=true;
continuous_occurrence.continuous_speed_kmh=5.0;
CHECK(insert_session(database,"session_walk","2026-09-06T10:00:00+02:00",TRAINLOG_SESSION_TRAINING,&continuous_occurrence,1U));
CHECK(trainlog_training_exercise_context_load(database,continuous_occurrence.exercise_id,1U,1U,&context)==TRAINLOG_STATUS_OK);
CHECK(context.occurrence_count==1U && context.occurrences[0].occurrence.continuous_duration_seconds==900);
CHECK(context.occurrences[0].set_count==0U);
trainlog_training_exercise_context_release(&context);
for(index=0U;index<65U;++index){large_sets[index].reps=(int)(index+1U);large_sets[index].duration_seconds=0;
large_sets[index].has_weight=false;large_sets[index].weight_kg=0.0;}
base_occurrence(&large_occurrence,"entry_large","ex_unknown_runtime","",TRAINLOG_LOAD_NONE);
large_occurrence.target_sets=65; large_occurrence.sets=large_sets; large_occurrence.set_count=65U;
CHECK(insert_session(database,"session_large","2026-09-05T10:00:00+02:00",TRAINLOG_SESSION_TRAINING,&large_occurrence,1U));
CHECK(trainlog_database_list_occurrence_sets_page(database,"entry_large",-1,64U,set_page,&count,&has_more,
&next_position)==TRAINLOG_STATUS_OK);
CHECK(count==64U && has_more && next_position==63);
CHECK(trainlog_database_list_occurrence_sets_page(database,"entry_large",next_position,64U,set_page,&count,
&has_more,&next_position)==TRAINLOG_STATUS_OK);
CHECK(count==1U && !has_more && set_page[0].position==64U);
trainlog_database_close(database);
CHECK(sqlite3_open(database_path, &raw) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "UPDATE sessions SET started_at='2026-09-20 10:00:00Z' WHERE session_id='session_lower';",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_close(raw) == SQLITE_OK); raw = NULL;
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,NULL,1U,page,&count,&has_more,
&next)==TRAINLOG_STATUS_DATABASE_ERROR);
trainlog_database_close(database);
CHECK(sqlite3_open(database_path, &raw) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "UPDATE sessions SET started_at='2020-01-01T00:00:00.123456789012345678901234567890Z' WHERE session_id='session_lower';",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_close(raw) == SQLITE_OK); raw = NULL;
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,NULL,1U,page,&count,&has_more,
&next)==TRAINLOG_STATUS_OK);
trainlog_database_close(database);
CHECK(sqlite3_open(database_path, &raw) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "UPDATE sessions SET started_at='9999-12-31T23:59:59.123456789012345678901234567890Z' WHERE session_id='session_lower';",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_close(raw) == SQLITE_OK); raw = NULL;
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,NULL,1U,page,&count,&has_more,
&next)==TRAINLOG_STATUS_DATABASE_ERROR);
trainlog_database_close(database);
CHECK(sqlite3_open(database_path, &raw) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "UPDATE sessions SET started_at='2026-09-20t10:00:00z' WHERE session_id='session_lower';",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "UPDATE sessions SET started_at='9999-12-31T23:59:59.123456789012345678901234567890Z' WHERE session_id='session_max_true';",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_close(raw) == SQLITE_OK); raw = NULL;
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_latest_explicit_max_context(database,exercise_id,&context.latest_max)
== TRAINLOG_STATUS_DATABASE_ERROR);
trainlog_database_close(database);
CHECK(sqlite3_open(database_path, &raw) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "UPDATE sessions SET started_at='2026-09-22T20:00:00Z' WHERE session_id='session_max_true';",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "UPDATE continuous_activity SET duration_seconds=2147483648 WHERE "
"session_exercise_row_id=(SELECT id FROM session_exercises WHERE entry_id='entry_walk');",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_close(raw) == SQLITE_OK); raw = NULL;
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_list_exercise_occurrences_page(database,continuous_occurrence.exercise_id,NULL,1U,
page,&count,&has_more,&next)==TRAINLOG_STATUS_DATABASE_ERROR);
trainlog_database_close(database);
CHECK(sqlite3_open(database_path, &raw) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "UPDATE performed_sets SET reps=2147483648 WHERE position=0 AND "
"session_exercise_row_id=(SELECT id FROM session_exercises WHERE entry_id='entry_large');",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_close(raw) == SQLITE_OK); raw = NULL;
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_list_occurrence_sets_page(database,"entry_large",-1,64U,set_page,&count,&has_more,
&next_position)==TRAINLOG_STATUS_DATABASE_ERROR);
trainlog_database_close(database);
CHECK(sqlite3_open(database_path, &raw) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "UPDATE performed_sets SET reps=0,duration_seconds=NULL,weight_kg=NULL WHERE position=0 AND "
"session_exercise_row_id=(SELECT id FROM session_exercises WHERE entry_id='entry_large');",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_close(raw) == SQLITE_OK); raw = NULL;
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_list_occurrence_sets_page(database,"entry_large",-1,1U,set_page,&count,&has_more,
&next_position)==TRAINLOG_STATUS_OK);
CHECK(count==1U && set_page[0].has_reps && set_page[0].reps==0 && !set_page[0].has_duration &&
!set_page[0].has_weight);
trainlog_database_close(database);
CHECK(sqlite3_open(database_path, &raw) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "UPDATE performed_sets SET reps=NULL,duration_seconds='bad' WHERE position=0 AND "
"session_exercise_row_id=(SELECT id FROM session_exercises WHERE entry_id='entry_large');",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_close(raw) == SQLITE_OK); raw = NULL;
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_list_occurrence_sets_page(database,"entry_large",-1,64U,set_page,&count,&has_more,
&next_position)==TRAINLOG_STATUS_DATABASE_ERROR);
trainlog_database_close(database);
CHECK(sqlite3_open(database_path, &raw) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "PRAGMA ignore_check_constraints=ON; UPDATE performed_sets SET duration_seconds=NULL,position='bad'||position WHERE "
"session_exercise_row_id=(SELECT id FROM session_exercises WHERE entry_id='entry_large');",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_close(raw) == SQLITE_OK); raw = NULL;
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_list_occurrence_sets_page(database,"entry_large",-1,64U,set_page,&count,&has_more,
&next_position)==TRAINLOG_STATUS_DATABASE_ERROR);
trainlog_database_close(database);
CHECK(sqlite3_open(database_path, &raw) == SQLITE_OK);
CHECK(sqlite3_exec(raw, "PRAGMA ignore_check_constraints=ON; UPDATE session_exercises SET data_fields='bad' WHERE "
"exercise_row_id=(SELECT id FROM exercises WHERE exercise_id='ex_b432623f-bfe9-4daf-a653-60ec7fdffbde');",
NULL, NULL, NULL) == SQLITE_OK);
CHECK(sqlite3_close(raw) == SQLITE_OK); raw = NULL;
CHECK(trainlog_database_open(database_path, &database) == TRAINLOG_STATUS_OK);
CHECK(trainlog_database_list_exercise_occurrences_page(database,exercise_id,NULL,1U,page,&count,&has_more,
&next)==TRAINLOG_STATUS_DATABASE_ERROR);
trainlog_database_close(database);
CHECK(unlink(database_path) == 0);
return 0;
}
Reference in a new issue View git blame Copy permalink