void test_left_trim(void) {
astr *asleading;
astr *astrailing;
astr *asleading_trailing;
astr *asupper;
asleading = astr_create(leading);
aut_assert("1 test creation", strcmp(asleading->string, leading) == 0);
astrailing = astr_create(trailing);
aut_assert("2 test creation", strcmp(astrailing->string, trailing) == 0);
asleading_trailing = astr_create(leading_trailing);
aut_assert("3 test creation", strcmp(asleading_trailing->string, leading_trailing) == 0);
asupper = astr_create(upper);
asleading = astr_left_trim(asleading);
aut_assert("4 test left_trim", astr_equals(asleading, asupper) == 1);
astr_free(asleading);
astr_free(astrailing);
astr_free(asleading_trailing);
astr_free(asupper);
}
void test_to_lower_case(void) {
astr *aslower;
astr *asupper;
aslower = astr_create(lower);
aut_assert("1 test creation", strcmp(aslower->string, lower) == 0);
asupper = astr_create(upper);
aut_assert("2 test creation", strcmp(asupper->string, upper) == 0);
asupper = astr_to_lower_case(asupper);
aut_assert("3 test to_lower", astr_equals(aslower, asupper) == 1);
astr_free(aslower);
astr_free(asupper);
}
struct astr *astr_rchr(struct astr *str, char chr) {
char *rdata;
rdata = memrchr(str->data, chr, str->len);
if (rdata == NULL) {
return NULL;
}
return astr_create(str->len - ((size_t) (rdata - str->data)), rdata);
}
void test_pack_packed_string(void) {
astr *as;
as = astr_create(packed_dirty_string);
aut_assert("1 test creation", strcmp(as->string, packed_dirty_string) == 0);
as = astr_pack(as);
aut_assert("2 test pack", strcmp(as->string, packed_dirty_string) == 0);
}
void test_clean_cleaned_string(void) {
astr *as;
as = astr_create(cleaned_dirty_string);
aut_assert("1 test creation", strcmp(as->string, cleaned_dirty_string) == 0);
as = astr_clean(as);
aut_assert("2 test clean", strcmp(as->string, cleaned_dirty_string) == 0);
}
/*
* afile_set_open_modes
*
* Initialize an afile open mode string.
*
* This can only be set before the file is opened.
*
* Parameter: The afile instance
* Parameter: The file open modes
*/
void afile_set_open_modes(afile *af, astr *open_modes) {
if (af != NULL && af->file == NULL) {
if (!astr_is_empty(open_modes)) {
af->open_modes = astr_copy(open_modes);
}
else {
af->open_modes = astr_create(default_open_modes);
}
}
}
void spend_time() {
char *str = "STR";
astr *as;
int i;
as = astr_create(str);
for(i = 0; i < 10000; i++) {
astr_append(as, str);
}
astr_free(as);
}
struct astr *astr_cstrstr(struct astr *haystack, char *needle) {
char *rdata;
rdata = memmem(haystack->data, haystack->len, needle, strlen(needle));
if (rdata == NULL) {
return NULL;
}
return astr_create(haystack->len
- ((size_t) (rdata - haystack->data)),
rdata);
}
void test_reverse_string(void) {
astr *as;
as = astr_create(forward_string);
aut_assert("1 test reverse", strcmp(as->string, forward_string) == 0);
as = astr_reverse(as);
aut_assert("2 test reverse", strcmp(as->string, reverse_string) == 0);
as = astr_reverse(as);
aut_assert("3 test reverse", strcmp(as->string, forward_string) == 0);
}
void test_to_mixed_case(void) {
astr *aslower;
astr *asupper;
astr *asmixed;
aslower = astr_create(lower);
aut_assert("1 test creation", strcmp(aslower->string, lower) == 0);
asupper = astr_create(upper);
aut_assert("2 test creation", strcmp(asupper->string, upper) == 0);
asmixed = astr_create(mixed);
aut_assert("3 test creation", strcmp(asmixed->string, mixed) == 0);
asupper = astr_to_mixed_case(asupper);
aut_assert("3 test to_mixed", astr_equals(asmixed, asupper) == 1);
aslower = astr_to_mixed_case(aslower);
aut_assert("4 test to_mixed", astr_equals(asmixed, aslower) == 1);
astr_free(aslower);
astr_free(asupper);
astr_free(asmixed);
}
void test_not_empty(void) {
astr *as;
char *empty = "";
char *space_str = " ";
as = astr_create(lower);
aut_assert("1 test creation", strcmp(as->string, lower) == 0);
as = astr_not_empty(as);
aut_assert("2 test not empty", strcmp(as->string, lower) == 0);
as = astr_set(as, empty);
as = astr_not_empty(as);
aut_assert("3 test empty", strcmp(as->string, space_str) == 0);
}
void test_creation(void) {
char *str = "ABC";
char *buf = "DEF ";
astr *as_str;
astr *as_buf;
as_str = astr_create(str);
aut_assert("1 test_creation", strcmp(as_str->string, str) == 0);
as_buf = astr_create_from_buffer(buf, strlen(buf));
aut_assert("2 test_creation", strcmp(as_buf->string, buf) == 0);
astr_free(as_str);
astr_free(as_buf);
}
struct astr *astr_rstr(struct astr *haystack, struct astr *needle) {
size_t last;
size_t i;
if (haystack->len < needle->len) {
return NULL;
}
last = haystack->len - needle->len;
for (i = last; i <= last; i--) {
if (memcmp(haystack->data + i, needle->data, needle->len)
== 0) {
return astr_create(haystack->len - i,
haystack->data + i);
}
}
return NULL;
}
void test_astr_print(void) {
astr *as_str;
char *print;
as_str = astr_create(str);
aut_assert("1 print", strcmp(as_str->string, str) == 0);
print = astr_print(as_str);
aut_assert("2 print", print != NULL);
aut_assert("3 print", strlen(print) > 0);
/*
printf("%s", print);
*/
free(print);
astr_free(as_str);
}
void test_astr_hexdump(void) {
astr *as_str;
char *dump;
as_str = astr_create(str);
aut_assert("1 hexdump", strcmp(as_str->string, str) == 0);
dump = astr_hexdump(as_str);
aut_assert("2 hexdump", dump != NULL);
aut_assert("3 hexdump", strlen(dump) > 0);
/*
printf("%s", dump);
*/
free(dump);
astr_free(as_str);
}
struct astr *astr_cstrrstr(struct astr *haystack, char *needle) {
size_t last;
size_t i;
size_t needle_len;
needle_len = strlen(needle);
if (haystack->len < needle_len) {
return NULL;
}
last = haystack->len - needle_len;
for (i = last; i <= last; i--) {
if (memcmp(haystack->data + i, needle, needle_len) == 0) {
return astr_create(haystack->len - i,
haystack->data + i);
}
}
return NULL;
}
void test_not_empty_char(void) {
astr *as;
char *empty = "";
char space = ' ';
char bang = '!';
char *space_str = " ";
char *bang_str = "!";
as = astr_create(lower);
aut_assert("1 test creation", strcmp(as->string, lower) == 0);
as = astr_not_empty_char(as, bang);
aut_assert("2 test not empty", strcmp(as->string, lower) == 0);
as = astr_set(as, empty);
as = astr_not_empty_char(as, space);
aut_assert("3 test empty", strcmp(as->string, space_str) == 0);
as = astr_set(as, empty);
as = astr_not_empty_char(as, bang);
aut_assert("4 test empty", strcmp(as->string, bang_str) == 0);
}
struct astr *astr_cstrwrap(char *cstr) {
return astr_create(strlen(cstr), cstr);
}
