static lrec_t* lrec_reader_mmap_csvlite_process_multi_seps(void* pvstate, void* pvhandle, context_t* pctx) {
file_reader_mmap_state_t* phandle = pvhandle;
lrec_reader_mmap_csvlite_state_t* pstate = pvstate;
while (TRUE) {
if (pstate->expect_header_line_next) {
slls_t* pheader_fields = lrec_reader_mmap_csvlite_get_header_multi_seps(phandle, pstate);
if (pheader_fields == NULL) // EOF
return NULL;
pstate->expect_header_line_next = FALSE;
pstate->pheader_keeper = lhmslv_get(pstate->pheader_keepers, pheader_fields);
if (pstate->pheader_keeper == NULL) {
pstate->pheader_keeper = header_keeper_alloc(NULL, pheader_fields);
lhmslv_put(pstate->pheader_keepers, pheader_fields, pstate->pheader_keeper);
} else { // Re-use the header-keeper in the header cache
slls_free(pheader_fields);
}
}
int end_of_stanza = FALSE;
lrec_t* prec = lrec_reader_mmap_csvlite_get_record_multi_seps(phandle, pstate, pstate->pheader_keeper,
&end_of_stanza);
if (end_of_stanza) {
pstate->expect_header_line_next = TRUE;
} else if (prec == NULL) { // EOF
return NULL;
} else {
return prec;
}
}
}
// ----------------------------------------------------------------
static sllv_t* mapper_tail_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
mapper_tail_state_t* pstate = pvstate;
if (pinrec != NULL) {
slls_t* pgroup_by_field_values = mlr_selected_values_from_record(pinrec, pstate->pgroup_by_field_names);
sllv_t* precord_list_for_group = lhmslv_get(pstate->precord_lists_by_group, pgroup_by_field_values);
if (precord_list_for_group == NULL) {
precord_list_for_group = sllv_alloc();
lhmslv_put(pstate->precord_lists_by_group, slls_copy(pgroup_by_field_values), precord_list_for_group);
}
if (precord_list_for_group->length >= pstate->tail_count) {
lrec_t* porec = sllv_pop(precord_list_for_group);
if (porec != NULL)
lrec_free(porec);
}
sllv_add(precord_list_for_group, pinrec);
return NULL;
}
else {
sllv_t* poutrecs = sllv_alloc();
for (lhmslve_t* pa = pstate->precord_lists_by_group->phead; pa != NULL; pa = pa->pnext) {
sllv_t* precord_list_for_group = pa->pvvalue;
for (sllve_t* pb = precord_list_for_group->phead; pb != NULL; pb = pb->pnext) {
sllv_add(poutrecs, pb->pvdata);
}
}
sllv_add(poutrecs, NULL);
return poutrecs;
}
}
static lrec_t* lrec_reader_csvex_process(void* pvhandle, void* pvstate, context_t* pctx) {
lrec_reader_csvex_state_t* pstate = pvstate;
// xxx byte-reader open ...
// if (pstate->pfr == NULL) {
// pstate->pfr = pfr_alloc((FILE*)pvhandle, pstate->peek_buf_len);
// }
if (pstate->expect_header_line_next) {
slls_t* pheader_fields = lrec_reader_csvex_get_fields(pstate);
if (pheader_fields == NULL)
return NULL;
pstate->ilno++;
pstate->expect_header_line_next = FALSE;
pstate->pheader_keeper = lhmslv_get(pstate->pheader_keepers, pheader_fields);
if (pstate->pheader_keeper == NULL) {
pstate->pheader_keeper = header_keeper_alloc(NULL, pheader_fields);
lhmslv_put(pstate->pheader_keepers, pheader_fields, pstate->pheader_keeper);
} else { // Re-use the header-keeper in the header cache
slls_free(pheader_fields);
}
}
pstate->ilno++;
slls_t* pdata_fields = lrec_reader_csvex_get_fields(pstate);
return paste_header_and_data(pstate, pdata_fields);
}
// ----------------------------------------------------------------
static sllv_t* mapper_group_like_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
mapper_group_like_state_t* pstate = pvstate;
if (pinrec != NULL) {
slls_t* pkey_field_names = mlr_reference_keys_from_record(pinrec);
sllv_t* plist = lhmslv_get(pstate->precords_by_key_field_names, pkey_field_names);
if (plist == NULL) {
plist = sllv_alloc();
sllv_add(plist, pinrec);
lhmslv_put(pstate->precords_by_key_field_names, slls_copy(pkey_field_names), plist);
} else {
sllv_add(plist, pinrec);
}
return NULL;
}
else {
sllv_t* poutput = sllv_alloc();
for (lhmslve_t* pe = pstate->precords_by_key_field_names->phead; pe != NULL; pe = pe->pnext) {
sllv_t* plist = pe->pvvalue;
for (sllve_t* pf = plist->phead; pf != NULL; pf = pf->pnext) {
sllv_add(poutput, pf->pvdata);
}
}
sllv_add(poutput, NULL);
return poutput;
}
}
static lrec_t* lrec_reader_stdio_csv_process(void* pvhandle, void* pvstate, context_t* pctx) {
FILE* input_stream = pvhandle;
lrec_reader_stdio_csv_state_t* pstate = pvstate;
while (TRUE) {
if (pstate->expect_header_line_next) {
// xxx cmt
while (TRUE) {
char* hline = mlr_get_line(input_stream, pstate->irs);
if (hline == NULL) // EOF
return NULL;
pstate->ilno++;
slls_t* pheader_fields = split_csv_header_line(hline, pstate->ifs, pstate->allow_repeat_ifs);
if (pheader_fields->length == 0) {
pstate->expect_header_line_next = TRUE;
if (pstate->pheader_keeper != NULL) {
pstate->pheader_keeper = NULL;
}
} else {
pstate->expect_header_line_next = FALSE;
pstate->pheader_keeper = lhmslv_get(pstate->pheader_keepers, pheader_fields);
if (pstate->pheader_keeper == NULL) {
pstate->pheader_keeper = header_keeper_alloc(hline, pheader_fields);
lhmslv_put(pstate->pheader_keepers, pheader_fields, pstate->pheader_keeper);
} else { // Re-use the header-keeper in the header cache
slls_free(pheader_fields);
free(hline);
}
break;
}
}
}
char* line = mlr_get_line(input_stream, pstate->irs);
if (line == NULL) // EOF
return NULL;
// xxx empty-line check ... make a lib func is_empty_modulo_whitespace().
if (!*line) {
if (pstate->pheader_keeper != NULL) {
pstate->pheader_keeper = NULL;
pstate->expect_header_line_next = TRUE;
free(line);
continue;
}
} else {
pstate->ifnr++;
return lrec_parse_stdio_csv_data_line(pstate->pheader_keeper, line, pstate->ifs, pstate->allow_repeat_ifs);
}
}
}
// ----------------------------------------------------------------
static lrec_t* lrec_reader_mmap_csv_process(void* pvstate, void* pvhandle, context_t* pctx) {
lrec_reader_mmap_csv_state_t* pstate = pvstate;
file_reader_mmap_state_t* phandle = pvhandle;
if (pstate->expect_header_line_next) {
if (!lrec_reader_mmap_csv_get_fields(pstate, pstate->pfields, phandle))
return NULL;
pstate->ilno++;
slls_t* pheader_fields = slls_alloc();
int i = 0;
for (rsllse_t* pe = pstate->pfields->phead; i < pstate->pfields->length && pe != NULL; pe = pe->pnext, i++) {
if (*pe->value == 0) {
fprintf(stderr, "%s: unacceptable empty CSV key at file \"%s\" line %lld.\n",
MLR_GLOBALS.argv0, pctx->filename, pstate->ilno);
exit(1);
}
// Transfer pointer-free responsibility from the rslls to the
// header fields in the header keeper
slls_append(pheader_fields, pe->value, pe->free_flag);
pe->free_flag = 0;
}
rslls_reset(pstate->pfields);
pstate->pheader_keeper = lhmslv_get(pstate->pheader_keepers, pheader_fields);
if (pstate->pheader_keeper == NULL) {
pstate->pheader_keeper = header_keeper_alloc(NULL, pheader_fields);
lhmslv_put(pstate->pheader_keepers, pheader_fields, pstate->pheader_keeper,
NO_FREE); // freed by header-keeper
} else { // Re-use the header-keeper in the header cache
slls_free(pheader_fields);
}
pstate->expect_header_line_next = FALSE;
}
int rc = lrec_reader_mmap_csv_get_fields(pstate, pstate->pfields, phandle);
pstate->ilno++;
if (rc == FALSE) // EOF
return NULL;
else {
lrec_t* prec = pstate->use_implicit_header
? paste_indices_and_data(pstate, pstate->pfields, pctx)
: paste_header_and_data(pstate, pstate->pfields, pctx);
rslls_reset(pstate->pfields);
return prec;
}
}
// ----------------------------------------------------------------
// xxx if empty key then make a way to communicate back to the reader that it
// can stop reading further records -- ?
static sllv_t* mapper_head_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
mapper_head_state_t* pstate = pvstate;
if (pinrec != NULL) {
slls_t* pgroup_by_field_values = mlr_selected_values_from_record(pinrec, pstate->pgroup_by_field_names);
unsigned long long* pcount_for_group = lhmslv_get(pstate->precord_lists_by_group, pgroup_by_field_values);
if (pcount_for_group == NULL) {
pcount_for_group = mlr_malloc_or_die(sizeof(unsigned long long));
*pcount_for_group = 0LL;
lhmslv_put(pstate->precord_lists_by_group, slls_copy(pgroup_by_field_values), pcount_for_group);
}
(*pcount_for_group)++;
if (*pcount_for_group <= pstate->head_count) {
return sllv_single(pinrec);
} else {
lrec_free(pinrec);
return NULL;
}
}
else {
return sllv_single(NULL);
}
}
// ----------------------------------------------------------------
static sllv_t* mapper_regularize_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
if (pinrec != NULL) {
mapper_regularize_state_t* pstate = (mapper_regularize_state_t*)pvstate;
slls_t* current_sorted_field_names = mlr_reference_keys_from_record(pinrec);
slls_sort(current_sorted_field_names);
slls_t* previous_sorted_field_names = lhmslv_get(pstate->psorted_to_original, current_sorted_field_names);
if (previous_sorted_field_names == NULL) {
previous_sorted_field_names = slls_copy(current_sorted_field_names);
lhmslv_put(pstate->psorted_to_original, previous_sorted_field_names, mlr_copy_keys_from_record(pinrec));
return sllv_single(pinrec);
} else {
lrec_t* poutrec = lrec_unbacked_alloc();
for (sllse_t* pe = previous_sorted_field_names->phead; pe != NULL; pe = pe->pnext) {
lrec_put(poutrec, pe->value, strdup(lrec_get(pinrec, pe->value)), LREC_FREE_ENTRY_VALUE);
}
lrec_free(pinrec);
return sllv_single(poutrec);
}
}
else {
return sllv_single(NULL);
}
}
// ----------------------------------------------------------------
static lrec_t* lrec_reader_stdio_csvlite_process(void* pvstate, void* pvhandle, context_t* pctx) {
FILE* input_stream = pvhandle;
lrec_reader_stdio_csvlite_state_t* pstate = pvstate;
while (TRUE) {
if (pstate->expect_header_line_next) {
while (TRUE) {
char* hline = (pstate->irslen == 1)
? mlr_get_cline(input_stream, pstate->irs[0])
: mlr_get_sline(input_stream, pstate->irs, pstate->irslen);
if (hline == NULL) // EOF
return NULL;
pstate->ilno++;
slls_t* pheader_fields = (pstate->ifslen == 1)
? split_csvlite_header_line_single_ifs(hline, pstate->ifs[0], pstate->allow_repeat_ifs)
: split_csvlite_header_line_multi_ifs(hline, pstate->ifs, pstate->ifslen, pstate->allow_repeat_ifs);
if (pheader_fields->length == 0) {
pstate->expect_header_line_next = TRUE;
if (pstate->pheader_keeper != NULL) {
pstate->pheader_keeper = NULL;
}
} else {
for (sllse_t* pe = pheader_fields->phead; pe != NULL; pe = pe->pnext) {
if (*pe->value == 0) {
fprintf(stderr, "%s: unacceptable empty CSV key at file \"%s\" line %lld.\n",
MLR_GLOBALS.argv0, pctx->filename, pstate->ilno);
exit(1);
}
}
pstate->expect_header_line_next = FALSE;
pstate->pheader_keeper = lhmslv_get(pstate->pheader_keepers, pheader_fields);
if (pstate->pheader_keeper == NULL) {
pstate->pheader_keeper = header_keeper_alloc(hline, pheader_fields);
lhmslv_put(pstate->pheader_keepers, pheader_fields, pstate->pheader_keeper,
NO_FREE); // freed by header-keeper
} else { // Re-use the header-keeper in the header cache
slls_free(pheader_fields);
free(hline);
}
break;
}
}
}
char* line = (pstate->irslen == 1)
? mlr_get_cline(input_stream, pstate->irs[0])
: mlr_get_sline(input_stream, pstate->irs, pstate->irslen);
if (line == NULL) // EOF
return NULL;
pstate->ilno++;
if (!*line) {
if (pstate->pheader_keeper != NULL) {
pstate->pheader_keeper = NULL;
pstate->expect_header_line_next = TRUE;
free(line);
continue;
}
} else {
pstate->ifnr++;
if (pstate->ifslen == 1) {
return pstate->use_implicit_header
? lrec_parse_stdio_csvlite_data_line_single_ifs_implicit_header(
pstate->pheader_keeper, pctx->filename, pstate->ilno, line,
pstate->ifs[0], pstate->allow_repeat_ifs)
: lrec_parse_stdio_csvlite_data_line_single_ifs(pstate->pheader_keeper, pctx->filename, pstate->ilno, line,
pstate->ifs[0], pstate->allow_repeat_ifs);
} else {
return pstate->use_implicit_header
? lrec_parse_stdio_csvlite_data_line_multi_ifs_implicit_header(
pstate->pheader_keeper, pctx->filename, pstate->ilno, line,
pstate->ifs, pstate->ifslen, pstate->allow_repeat_ifs)
: lrec_parse_stdio_csvlite_data_line_multi_ifs(pstate->pheader_keeper, pctx->filename, pstate->ilno, line,
pstate->ifs, pstate->ifslen, pstate->allow_repeat_ifs);
}
}
}
}
static sllv_t* mapper_step_process(lrec_t* pinrec, context_t* pctx, void* pvstate) {
mapper_step_state_t* pstate = pvstate;
if (pinrec == NULL)
return sllv_single(NULL);
// ["s", "t"]
slls_t* pvalue_field_values = mlr_selected_values_from_record(pinrec, pstate->pvalue_field_names);
slls_t* pgroup_by_field_values = mlr_selected_values_from_record(pinrec, pstate->pgroup_by_field_names);
if (pgroup_by_field_values->length != pstate->pgroup_by_field_names->length) {
lrec_free(pinrec);
return NULL;
}
lhmsv_t* group_to_acc_field = lhmslv_get(pstate->groups, pgroup_by_field_values);
if (group_to_acc_field == NULL) {
group_to_acc_field = lhmsv_alloc();
lhmslv_put(pstate->groups, slls_copy(pgroup_by_field_values), group_to_acc_field);
}
sllse_t* pa = pstate->pvalue_field_names->phead;
sllse_t* pb = pvalue_field_values->phead;
// for x=1 and y=2
for ( ; pa != NULL && pb != NULL; pa = pa->pnext, pb = pb->pnext) {
char* value_field_name = pa->value;
char* value_field_sval = pb->value;
int have_dval = FALSE;
double value_field_dval = -999.0;
lhmsv_t* acc_field_to_acc_state = lhmsv_get(group_to_acc_field, value_field_name);
if (acc_field_to_acc_state == NULL) {
acc_field_to_acc_state = lhmsv_alloc();
lhmsv_put(group_to_acc_field, value_field_name, acc_field_to_acc_state);
}
// for "delta", "rsum"
sllse_t* pc = pstate->pstepper_names->phead;
for ( ; pc != NULL; pc = pc->pnext) {
char* step_name = pc->value;
step_t* pstep = lhmsv_get(acc_field_to_acc_state, step_name);
if (pstep == NULL) {
pstep = make_step(step_name, value_field_name);
if (pstep == NULL) {
fprintf(stderr, "mlr step: stepper \"%s\" not found.\n",
step_name);
exit(1);
}
lhmsv_put(acc_field_to_acc_state, step_name, pstep);
}
if (pstep->psprocess_func != NULL) {
pstep->psprocess_func(pstep->pvstate, value_field_sval, pinrec);
}
if (pstep->pdprocess_func != NULL) {
if (!have_dval) {
value_field_dval = mlr_double_from_string_or_die(value_field_sval);
have_dval = TRUE;
}
pstep->pdprocess_func(pstep->pvstate, value_field_dval, pinrec);
}
}
}
return sllv_single(pinrec);
}
// ----------------------------------------------------------------
static void mapper_stats1_ingest(lrec_t* pinrec, mapper_stats1_state_t* pstate) {
// E.g. ["s", "t"]
// To do: make value_field_values into a hashmap. Then accept partial
// population on that, but retain full-population requirement on group-by.
// E.g. if accumulating stats of x,y on a,b then skip record with x,y,a but
// process record with x,a,b.
slls_t* pvalue_field_values = mlr_selected_values_from_record(pinrec, pstate->pvalue_field_names);
slls_t* pgroup_by_field_values = mlr_selected_values_from_record(pinrec, pstate->pgroup_by_field_names);
if (pvalue_field_values->length != pstate->pvalue_field_names->length)
return;
if (pgroup_by_field_values->length != pstate->pgroup_by_field_names->length)
return;
lhmsv_t* group_to_acc_field = lhmslv_get(pstate->groups, pgroup_by_field_values);
if (group_to_acc_field == NULL) {
group_to_acc_field = lhmsv_alloc();
lhmslv_put(pstate->groups, slls_copy(pgroup_by_field_values), group_to_acc_field);
}
sllse_t* pa = pstate->pvalue_field_names->phead;
sllse_t* pb = pvalue_field_values->phead;
// for x=1 and y=2
for ( ; pa != NULL && pb != NULL; pa = pa->pnext, pb = pb->pnext) {
char* value_field_name = pa->value;
char* value_field_sval = pb->value;
int have_dval = FALSE;
double value_field_dval = -999.0;
lhmsv_t* acc_field_to_acc_state = lhmsv_get(group_to_acc_field, value_field_name);
if (acc_field_to_acc_state == NULL) {
acc_field_to_acc_state = lhmsv_alloc();
lhmsv_put(group_to_acc_field, value_field_name, acc_field_to_acc_state);
}
// Look up presence of all accumulators at this level's hashmap.
char* presence = lhmsv_get(acc_field_to_acc_state, fake_acc_name_for_setups);
if (presence == NULL) {
make_accs(pstate->paccumulator_names, acc_field_to_acc_state);
lhmsv_put(acc_field_to_acc_state, fake_acc_name_for_setups, fake_acc_name_for_setups);
}
// There isn't a one-to-one mapping between user-specified acc_names
// and internal acc_t's. Here in the ingestor we feed each datum into
// an acc_t. In the emitter, we loop over the acc_names in
// user-specified order. Example: they ask for p10,mean,p90. Then there
// is only one percentiles accumulator to be told about each point. In
// the emitter it will be asked to produce output twice: once for the
// 10th percentile & once for the 90th.
for (lhmsve_t* pc = acc_field_to_acc_state->phead; pc != NULL; pc = pc->pnext) {
char* acc_name = pc->key;
if (streq(acc_name, fake_acc_name_for_setups))
continue;
acc_t* pacc = pc->pvvalue;
if (pacc->psingest_func != NULL) {
pacc->psingest_func(pacc->pvstate, value_field_sval);
}
if (pacc->pdingest_func != NULL) {
if (!have_dval) {
value_field_dval = mlr_double_from_string_or_die(value_field_sval);
have_dval = TRUE;
}
pacc->pdingest_func(pacc->pvstate, value_field_dval);
}
}
}
}
// ----------------------------------------------------------------
static lrec_t* lrec_reader_stdio_csv_process(void* pvstate, void* pvhandle, context_t* pctx) {
lrec_reader_stdio_csv_state_t* pstate = pvstate;
// Ingest the next header line, if expected
if (pstate->expect_header_line_next) {
while (TRUE) {
if (!lrec_reader_stdio_csv_get_fields(pstate, pstate->pfields, pctx, TRUE))
return NULL;
pstate->ilno++;
// We check for comments here rather than within the parser since it's important
// for users to be able to comment out lines containing double-quoted newlines.
if (pstate->comment_string != NULL && pstate->pfields->phead != NULL) {
if (streqn(pstate->pfields->phead->value, pstate->comment_string, pstate->comment_string_length)) {
if (pstate->comment_handling == PASS_COMMENTS) {
int i = 0;
for (
rsllse_t* pe = pstate->pfields->phead;
i < pstate->pfields->length && pe != NULL;
pe = pe->pnext, i++)
{
if (i > 0)
fputs(pstate->ifs, stdout);
fputs(pe->value, stdout);
}
if (pstate->do_auto_line_term) {
fputs(pctx->auto_line_term, stdout);
} else {
fputs(pstate->irs, stdout);
}
}
rslls_reset(pstate->pfields);
continue;
}
}
slls_t* pheader_fields = slls_alloc();
int i = 0;
for (rsllse_t* pe = pstate->pfields->phead; i < pstate->pfields->length && pe != NULL; pe = pe->pnext) {
if (*pe->value == 0) {
fprintf(stderr, "%s: unacceptable empty CSV key at file \"%s\" line %lld.\n",
MLR_GLOBALS.bargv0, pctx->filename, pstate->ilno);
exit(1);
}
// Transfer pointer-free responsibility from the rslls to the
// header fields in the header keeper
slls_append(pheader_fields, pe->value, pe->free_flag);
pe->free_flag = 0;
}
rslls_reset(pstate->pfields);
pstate->pheader_keeper = lhmslv_get(pstate->pheader_keepers, pheader_fields);
if (pstate->pheader_keeper == NULL) {
pstate->pheader_keeper = header_keeper_alloc(NULL, pheader_fields);
lhmslv_put(pstate->pheader_keepers, pheader_fields, pstate->pheader_keeper,
NO_FREE); // freed by header-keeper
} else { // Re-use the header-keeper in the header cache
slls_free(pheader_fields);
}
pstate->expect_header_line_next = FALSE;
break;
}
}
// Ingest the next data line, if expected
while (TRUE) {
int rc = lrec_reader_stdio_csv_get_fields(pstate, pstate->pfields, pctx, FALSE);
pstate->ilno++;
if (rc == FALSE) // EOF
return NULL;
// We check for comments here rather than within the parser since it's important
// for users to be able to comment out lines containing double-quoted newlines.
if (pstate->comment_string != NULL && pstate->pfields->phead != NULL) {
if (streqn(pstate->pfields->phead->value, pstate->comment_string, pstate->comment_string_length)) {
if (pstate->comment_handling == PASS_COMMENTS) {
int i = 0;
for (
rsllse_t* pe = pstate->pfields->phead;
i < pstate->pfields->length && pe != NULL;
pe = pe->pnext, i++)
{
if (i > 0)
fputs(pstate->ifs, stdout);
fputs(pe->value, stdout);
}
if (pstate->do_auto_line_term) {
fputs(pctx->auto_line_term, stdout);
} else {
fputs(pstate->irs, stdout);
}
}
rslls_reset(pstate->pfields);
continue;
}
}
lrec_t* prec = pstate->use_implicit_header
? paste_indices_and_data(pstate, pstate->pfields, pctx)
: paste_header_and_data(pstate, pstate->pfields, pctx);
rslls_reset(pstate->pfields);
return prec;
}
}
// ----------------------------------------------------------------
static char* test_lhmslv() {
slls_t* aw = slls_alloc(); slls_add_no_free(aw, "a"); slls_add_no_free(aw, "w");
slls_t* ax = slls_alloc(); slls_add_no_free(ax, "a"); slls_add_no_free(ax, "x");
slls_t* ay = slls_alloc(); slls_add_no_free(ay, "a"); slls_add_no_free(ay, "y");
slls_t* bz = slls_alloc(); slls_add_no_free(bz, "b"); slls_add_no_free(bz, "z");
lhmslv_t *pmap = lhmslv_alloc();
mu_assert_lf(pmap->num_occupied == 0);
mu_assert_lf(!lhmslv_has_key(pmap, aw)); mu_assert_lf(lhmslv_get(pmap, aw) == NULL);
mu_assert_lf(!lhmslv_has_key(pmap, ax)); mu_assert_lf(lhmslv_get(pmap, ax) == NULL);
mu_assert_lf(!lhmslv_has_key(pmap, ay)); mu_assert_lf(lhmslv_get(pmap, ay) == NULL);
mu_assert_lf(!lhmslv_has_key(pmap, bz)); mu_assert_lf(lhmslv_get(pmap, bz) == NULL);
mu_assert_lf(lhmslv_check_counts(pmap));
lhmslv_put(pmap, ax, "3");
mu_assert_lf(pmap->num_occupied == 1);
mu_assert_lf(!lhmslv_has_key(pmap, aw)); mu_assert_lf(lhmslv_get(pmap, aw) == NULL);
mu_assert_lf( lhmslv_has_key(pmap, ax)); mu_assert_lf(streq(lhmslv_get(pmap, ax), "3"));
mu_assert_lf(!lhmslv_has_key(pmap, ay)); mu_assert_lf(lhmslv_get(pmap, ay) == NULL);
mu_assert_lf(!lhmslv_has_key(pmap, bz)); mu_assert_lf(lhmslv_get(pmap, bz) == NULL);
mu_assert_lf(lhmslv_check_counts(pmap));
lhmslv_put(pmap, ay, "5");
mu_assert_lf(pmap->num_occupied == 2);
mu_assert_lf(!lhmslv_has_key(pmap, aw)); mu_assert_lf(lhmslv_get(pmap, aw) == NULL);
mu_assert_lf( lhmslv_has_key(pmap, ax)); mu_assert_lf(streq(lhmslv_get(pmap, ax), "3"));
mu_assert_lf( lhmslv_has_key(pmap, ay)); mu_assert_lf(streq(lhmslv_get(pmap, ay), "5"));
mu_assert_lf(!lhmslv_has_key(pmap, bz)); mu_assert_lf(lhmslv_get(pmap, bz) == NULL);
mu_assert_lf(lhmslv_check_counts(pmap));
lhmslv_put(pmap, ax, "4");
mu_assert_lf(pmap->num_occupied == 2);
mu_assert_lf(!lhmslv_has_key(pmap, aw)); mu_assert_lf(lhmslv_get(pmap, aw) == NULL);
mu_assert_lf( lhmslv_has_key(pmap, ax)); mu_assert_lf(streq(lhmslv_get(pmap, ax), "4"));
mu_assert_lf( lhmslv_has_key(pmap, ay)); mu_assert_lf(streq(lhmslv_get(pmap, ay), "5"));
mu_assert_lf(!lhmslv_has_key(pmap, bz)); mu_assert_lf(lhmslv_get(pmap, bz) == NULL);
mu_assert_lf(lhmslv_check_counts(pmap));
lhmslv_put(pmap, bz, "7");
mu_assert_lf(pmap->num_occupied == 3);
mu_assert_lf(!lhmslv_has_key(pmap, aw)); mu_assert_lf(lhmslv_get(pmap, aw) == NULL);
mu_assert_lf( lhmslv_has_key(pmap, ax)); mu_assert_lf(streq(lhmslv_get(pmap, ax), "4"));
mu_assert_lf( lhmslv_has_key(pmap, ay)); mu_assert_lf(streq(lhmslv_get(pmap, ay), "5"));
mu_assert_lf( lhmslv_has_key(pmap, bz)); mu_assert_lf(streq(lhmslv_get(pmap, bz), "7"));
mu_assert_lf(lhmslv_check_counts(pmap));
lhmslv_remove(pmap, ay);
mu_assert_lf(pmap->num_occupied == 2);
mu_assert_lf(!lhmslv_has_key(pmap, aw)); mu_assert_lf(lhmslv_get(pmap, aw) == NULL);
mu_assert_lf( lhmslv_has_key(pmap, ax)); mu_assert_lf(streq(lhmslv_get(pmap, ax), "4"));
mu_assert_lf(!lhmslv_has_key(pmap, ay)); mu_assert_lf(lhmslv_get(pmap, ay) == NULL);
mu_assert_lf( lhmslv_has_key(pmap, bz)); mu_assert_lf(streq(lhmslv_get(pmap, bz), "7"));
mu_assert_lf(lhmslv_check_counts(pmap));
lhmslv_clear(pmap);
mu_assert_lf(pmap->num_occupied == 0);
mu_assert_lf(!lhmslv_has_key(pmap, aw)); mu_assert_lf(lhmslv_get(pmap, aw) == NULL);
mu_assert_lf(!lhmslv_has_key(pmap, ax)); mu_assert_lf(lhmslv_get(pmap, ax) == NULL);
mu_assert_lf(!lhmslv_has_key(pmap, ay)); mu_assert_lf(lhmslv_get(pmap, ay) == NULL);
mu_assert_lf(!lhmslv_has_key(pmap, bz)); mu_assert_lf(lhmslv_get(pmap, bz) == NULL);
mu_assert_lf(lhmslv_check_counts(pmap));
lhmslv_free(pmap);
return NULL;
}