// A single string should be extractable.
static char* test_global_single_string(void) {
data_processor_init("Hello", '|');
ProcessingState* state = data_processor_get_global();
const char* str = data_processor_get_string(state);
mu_assert(strcmp(str, "Hello") == 0, "Single string not extracted from global state");
return 0;
}
int main(int argc,char ** argv) {
const char *infile = "dump-raw-3.txt";
const char *outfile = "test-output.txt";
if (argc == 3) {
infile = argv[1];
outfile = argv[2];
}
float hz = 0;
data_processor_t dfft = NULL;
dfft = data_processor_init(2048, 214000);
if (!dfft) {
fprintf(stderr, "data_processor_init error\n");
return -1;
}
read_data(infile, dfft->cin, dfft->nfft);
int i = 100;
while (i-- > 0) {
hz = data_processor_run(dfft);
printf("hz = %12f\n", hz);
}
write_data(outfile, dfft->cout, dfft->nfft);
data_processor_close(dfft);
dfft = NULL;
return 0;
}
static void handle_details(char* data) {
free_safe(details);
data_processor_init(data, '|');
details = data_processor_get_string();
if (details_handler) {
details_handler(details);
}
}
// Multiple booleans should be extractable.
static char* test_global_multiple_booleans(void) {
data_processor_init("1|0|", '|');
bool boolean1 = data_processor_get_bool(data_processor_get_global());
bool boolean2 = data_processor_get_bool(data_processor_get_global());
bool boolean3 = data_processor_get_bool(data_processor_get_global());
mu_assert(true == boolean1 && false == boolean2 && false == boolean3, "Multipe booleans not extracted from global state");
return 0;
}
// Mixed values should be extractable from the global state.
static char* test_global_mixed(void) {
data_processor_init("8|This is a string!|0|6765444", '|');
int num1 = data_processor_get_int(data_processor_get_global());
char* string1 = data_processor_get_string(data_processor_get_global());
bool boolean1 = data_processor_get_bool(data_processor_get_global());
int num2 = data_processor_get_int(data_processor_get_global());
mu_assert(8 == num1 && 0 == strcmp("This is a string!", string1) && false == boolean1 && 6765444 == num2, "Mixed values not extracted from global state");
return 0;
}
// Multiple numbers should be extractable.
static char* test_global_multiple_numbers(void) {
data_processor_init("1|55555|0", '|');
ProcessingState* state = data_processor_get_global();
int num1 = data_processor_get_int(state);
int num2 = data_processor_get_int(state);
int num3 = data_processor_get_int(state);
mu_assert(1 == num1 && 55555 == num2 && 0 == num3, "Multiple numbers not extracted from global state");
return 0;
}
// Mixed values should be simultaneously be extractable from the global and a local state.
static char* test_local_and_global_mixed(void) {
ProcessingState* state1 = data_processor_create("8|This is a string!", '|');
data_processor_init("0|6765444", '|');
ProcessingState* state2 = data_processor_get_global();
int num1 = data_processor_get_int(state1);
bool boolean1 = data_processor_get_bool(state2);
char* string1 = data_processor_get_string(state1);
int num2 = data_processor_get_int(state2);
mu_assert(8 == num1 && 0 == strcmp("This is a string!", string1) && false == boolean1 && 6765444 == num2, "Mixed values not extracted from global state");
return 0;
}
static void handle_update(char* data) {
destroy_lines();
data_processor_init(data, '|');
num_lines = data_processor_get_int();
lines = malloc(sizeof(TubeLine*) * num_lines);
for (uint8_t l = 0; l < num_lines; l += 1) {
TubeLine* line = malloc(sizeof(TubeLine));
line->name = data_processor_get_string();
line->status = data_processor_get_string();
lines[l] = line;
}
update_handler();
}
// Several strings separated by delimiter should be extractable.
static char* test_global_multiple_strings(void) {
data_processor_init("Hello|Hi|Hey||", '|');
ProcessingState* state = data_processor_get_global();
const char* str1 = data_processor_get_string(state);
const char* str2 = data_processor_get_string(state);
const char* str3 = data_processor_get_string(state);
const char* str4 = data_processor_get_string(state);
const char* str5 = data_processor_get_string(state);
bool pass = strcmp(str1, "Hello") == 0;
pass = pass && strcmp(str2, "Hi") == 0;
pass = pass && strcmp(str3, "Hey") == 0;
pass = pass && strcmp(str4, "") == 0;
pass = pass && strcmp(str5, "") == 0;
mu_assert(pass, "Multiple strings not extracted from global state");
return 0;
}
/**
* Function to process the data of a preset update.
* @param data "DATA" response of the given message, formatted either
* as "stop_id|stop_name|route_id|route_name", or as "END" to signify the end
* of the preset messages.
*/
static void process_preset_data(char* data){
if (strcmp(data, "END") != 0){
data_processor_init(data, '|');
Preset *preset = malloc(sizeof(Preset));
strcpy(preset->stop_id, data_processor_get_string());
strcpy(preset->stop_name, data_processor_get_string());
strcpy(preset->route_id, data_processor_get_string());
strcpy(preset->route_name, data_processor_get_string());
preset->eta = -5;
presets_add(preset);
}
else{
send_all_eta_req();
refresh();
reset_selected_index();
update_time_text();
}
}
/**
* Function to process the data of an ETA update message.
* @param data the "DATA" response of the given method, which is formatted as "stop_id|route_id|eta"
*/
static void process_eta_data(char* data){
data_processor_init(data, '|');
char* stop_id = data_processor_get_string();
char* route_id = data_processor_get_string();
char* eta_string = data_processor_get_string();
int eta = PRESET_NO_ETA;
if (strcmp(eta_string, "NO ETA") != 0){
eta = atoi(eta_string);
}
for (int i = 0; i < presets_get_count(); i++){
Preset *preset = presets_get(i);
if (strcmp(preset->stop_id, stop_id) == 0 && strcmp(preset->route_id, route_id) == 0){
preset->eta = eta;
break;
}
}
free(stop_id);
free(route_id);
refresh();
update_time_text();
}
// The count of multiple subelements should be equal to the number of subelements.
static char* test_count_multiple(void) {
data_processor_init("Hello|Goodbye||", '|');
int count = data_processor_count(data_processor_get_global());
mu_assert(4 == count, "Count of multiple subelements not calculated correctly");
return 0;
}
// A single boolean should be extractable.
static char* test_global_single_boolean(void) {
data_processor_init("1", '|');
bool boolean = data_processor_get_bool(data_processor_get_global());
mu_assert(true == boolean, "Single boolean not extracted from global state");
return 0;
}
// The count of a single subelement should be 1.
static char* test_count_single(void) {
data_processor_init("Hello", '|');
int count = data_processor_count(data_processor_get_global());
mu_assert(1 == count, "Count of single subelement not calculated correctly");
return 0;
}
// A single number should be extractable.
static char* test_global_single_number(void) {
data_processor_init("1", '|');
int num = data_processor_get_int(data_processor_get_global());
mu_assert(1 == num, "Single number not extracted from global state");
return 0;
}
// The count of an empty string should be 0.
static char* test_count_none(void) {
data_processor_init("", '|');
int count = data_processor_count(data_processor_get_global());
mu_assert(0 == count, "Count of zero subelements not calculated correctly");
return 0;
}
// The global state object should be available after init.
static char* test_init(void) {
data_processor_init("", '|');
mu_assert(data_processor_get_global() != NULL, "Global state does not exist.");
return 0;
}