// Print a row. If wrap is enabled and the text excceeds width, return true (printed text up to column width, repetition possible to print the rest), otherwise false
static boolean_t _printRow(T t) {
boolean_t repeat = false;
for (int i = 0; i < t->columnsCount; i++) {
StringBuffer_append(t->b, COLOR_DARKGRAY BOX_VERTICAL COLOR_RESET " ");
if (*(t->columns[i]._color))
StringBuffer_append(t->b, "%s", t->columns[i]._color);
if (! t->columns[i].value || t->columns[i]._cursor > strlen(t->columns[i].value) - 1) {
// Empty column pading
StringBuffer_append(t->b, "%*s", t->columns[i].width, " ");
} else if (strlen(t->columns[i].value + t->columns[i]._cursor) > t->columns[i].width) {
if (t->columns[i].wrap) {
// The value exceeds the column width and should be wrapped
int column = 0;
for (; t->columns[i].value[t->columns[i]._cursor] && (column == 0 || t->columns[i]._cursor % t->columns[i].width > 0); t->columns[i]._cursor++, column++)
StringBuffer_append(t->b, "%c", t->columns[i].value[t->columns[i]._cursor]);
if (t->columns[i]._cursor < t->columns[i]._valueLength)
repeat = true;
} else {
// The value exceeds the column width and should be truncated
Str_trunc(t->columns[i].value, t->columns[i].width);
StringBuffer_append(t->b, t->columns[i].align == BoxAlign_Right ? "%*s" : "%-*s", t->columns[i].width, t->columns[i].value);
t->columns[i]._cursor = t->columns[i]._valueLength;
}
} else {
// The whole value fits in the column width
StringBuffer_append(t->b, t->columns[i].align == BoxAlign_Right ? "%*s" : "%-*s", t->columns[i].width, t->columns[i].value + t->columns[i]._cursor);
t->columns[i]._cursor = t->columns[i]._valueLength;
}
StringBuffer_append(t->b, " ");
if (*(t->columns[i]._color))
StringBuffer_append(t->b, COLOR_RESET);
}
StringBuffer_append(t->b, COLOR_DARKGRAY BOX_VERTICAL COLOR_RESET "\n");
t->index.row++;
return repeat;
}
/**
* Generic service test.
*
* @file
*/
void check_generic(Socket_T socket) {
ASSERT(socket);
Generic_T g = NULL;
if (Socket_getPort(socket))
g = ((Port_T)(Socket_getPort(socket)))->parameters.generic.sendexpect;
char *buf = CALLOC(sizeof(char), Run.limits.sendExpectBuffer + 1);
while (g != NULL) {
if (g->send != NULL) {
/* Unescape any \0x00 escaped chars in g's send string to allow sending a string containing \0 bytes also */
char *X = Str_dup(g->send);
int l = Util_handle0Escapes(X);
if (Socket_write(socket, X, l) < 0) {
FREE(X);
FREE(buf);
THROW(IOException, "GENERIC: error sending data -- %s", STRERROR);
} else {
DEBUG("GENERIC: successfully sent: '%s'\n", g->send);
}
FREE(X);
} else if (g->expect != NULL) {
/* Since the protocol is unknown we need to wait on EOF. To avoid waiting
timeout seconds on EOF we first read one byte to fill the socket's read
buffer and then set a low timeout on next read which reads remaining bytes
as well as wait on EOF */
int first_byte = Socket_readByte(socket);
if (first_byte < 0) {
FREE(buf);
THROW(IOException, "GENERIC: error receiving data -- %s", STRERROR);
}
*buf = first_byte;
int timeout = Socket_getTimeout(socket);
Socket_setTimeout(socket, 200);
int n = Socket_read(socket, buf + 1, Run.limits.sendExpectBuffer - 1) + 1;
buf[n] = 0;
if (n > 0)
_escapeZeroInExpectBuffer(buf, n);
Socket_setTimeout(socket, timeout); // Reset back original timeout for next send/expect
#ifdef HAVE_REGEX_H
int regex_return = regexec(g->expect, buf, 0, NULL, 0);
if (regex_return != 0) {
char e[STRLEN];
regerror(regex_return, g->expect, e, STRLEN);
FREE(buf);
THROW(IOException, "GENERIC: received unexpected data -- %s", e);
} else {
DEBUG("GENERIC: successfully received: '%s'\n", Str_trunc(buf, STRLEN - 4));
}
#else
/* w/o regex support */
if (strncmp(buf, g->expect, strlen(g->expect)) != 0) {
FREE(buf);
THROW(IOException, "GENERIC: received unexpected data");
} else {
DEBUG("GENERIC: successfully received: '%s'\n", Str_trunc(buf, STRLEN - 4));
}
#endif
} else {
/* This should not happen */
FREE(buf);
THROW(IOException, "GENERIC: unexpected strangeness");
}
g = g->next;
}
FREE(buf);
}
/**
* Generic service test.
*
* @file
*/
int check_generic(Socket_T socket) {
Generic_T g = NULL;
char *buf;
#ifdef HAVE_REGEX_H
int regex_return;
#endif
ASSERT(socket);
if(socket_get_Port(socket))
g = ((Port_T)(socket_get_Port(socket)))->generic;
buf = CALLOC(sizeof(char), Run.expectbuffer + 1);
while (g != NULL) {
if (g->send != NULL) {
/* Unescape any \0x00 escaped chars in g's send string
to allow sending a string containing \0 bytes also */
char *X = Str_dup(g->send);
int l = Util_handle0Escapes(X);
if(socket_write(socket, X, l) < 0) {
socket_setError(socket, "GENERIC: error sending data -- %s", STRERROR);
FREE(X);
FREE(buf);
return FALSE;
} else
DEBUG("GENERIC: successfully sent: '%s'\n", g->send);
FREE(X);
} else if (g->expect != NULL) {
int n;
/* Need read, not readln here */
if((n = socket_read(socket, buf, Run.expectbuffer)) < 0) {
socket_setError(socket, "GENERIC: error receiving data -- %s", STRERROR);
FREE(buf);
return FALSE;
}
buf[n] = 0;
if (n > 0)
_escapeZeroInExpectBuffer(buf, n);
#ifdef HAVE_REGEX_H
regex_return = regexec(g->expect, buf, 0, NULL, 0);
if (regex_return != 0) {
char e[STRLEN];
regerror(regex_return, g->expect, e, STRLEN);
socket_setError(socket, "GENERIC: receiving unexpected data [%s] -- %s", Str_trunc(buf, STRLEN - 4), e);
FREE(buf);
return FALSE;
} else
DEBUG("GENERIC: successfully received: '%s'\n", Str_trunc(buf, STRLEN - 4));
#else
/* w/o regex support */
if (strncmp(buf, g->expect, strlen(g->expect)) != 0) {
socket_setError(socket, "GENERIC: receiving unexpected data [%s]", Str_trunc(buf, STRLEN - 4));
FREE(buf);
return FALSE;
} else
DEBUG("GENERIC: successfully received: '%s'\n", Str_trunc(buf, STRLEN - 4));
#endif
} else {
/* This should not happen */
socket_setError(socket, "GENERIC: unexpected strangeness");
FREE(buf);
return FALSE;
}
g = g->next;
}
FREE(buf);
return TRUE;
}
int main(void) {
Bootstrap(); // Need to initialize library
printf("============> Start Str Tests\n\n");
printf("=> Test1: copy\n");
{
char s3[STRLEN];
printf("\tResult: %s\n", Str_copy(s3, "The abc house", 7));
assert(Str_isEqual(s3, "The abc"));
printf("\tTesting for NULL argument\n");
assert(!Str_copy(NULL, NULL, 7));
}
printf("=> Test1: OK\n\n");
printf("=> Test2: dup\n");
{
char *s4 = Str_dup("abc123");
printf("\tResult: %s\n", s4);
assert(Str_isEqual(s4, "abc123"));
printf("\tTesting for NULL argument\n");
assert(!Str_dup(NULL));
FREE(s4);
}
printf("=> Test2: OK\n\n");
printf("=> Test3: ndup\n");
{
char *s5 = Str_ndup("abc123", 3);
printf("\tResult: %s\n", s5);
assert(Str_isEqual(s5, "abc"));
printf("\tTesting for NULL argument\n");
assert(!Str_ndup(NULL, 3));
FREE(s5);
}
printf("=> Test3: OK\n\n");
printf("=> Test4: Str_cat & Str_vcat\n");
{
char *s6;
s6 = Str_cat("%s://%s%s?%s", "https", "foo.bar",
"/uri", "abc=123");
printf("\tResult: %s\n", s6);
assert(Str_isEqual(s6, "https://foo.bar/uri?abc=123"));
FREE(s6);
printf("\tTesting for NULL arguments\n");
s6 = Str_cat(NULL);
assert(s6==NULL);
FREE(s6);
}
printf("=> Test4: OK\n\n");
printf("=> Test5: chomp\n");
{
char s3[] = "abc\r\n123";
printf("\tResult: %s\n", Str_chomp(s3));
assert(Str_isEqual(s3, "abc"));
printf("\tTesting for NULL argument\n");
assert(!Str_chomp(NULL));
}
printf("=> Test5: OK\n\n");
printf("=> Test6: trim\n");
{
char e[] = " ";
char o[] = " a ";
char s[] = " abcdef";
char s4[] = " \t abc \r\n\t ";
assert(Str_isEqual(Str_ltrim(s), "abcdef"));
printf("\tResult: %s\n", Str_trim(s4));
assert(Str_isEqual(s4, "abc"));
printf("\tTesting for NULL argument\n");
assert(!Str_trim(NULL));
assert(Str_isEqual(Str_ltrim(e), ""));
memcpy(e, " ", sizeof(" ") - 1);
assert(Str_isEqual(Str_rtrim(e), ""));
memcpy(e, " ", sizeof(" ") - 1);
assert(Str_isEqual(Str_trim(e), ""));
assert(Str_isEqual(Str_ltrim(o), "a "));
memcpy(o, " a ", sizeof(" a ") - 1);
assert(Str_isEqual(Str_rtrim(o), " a"));
memcpy(o, " a ", sizeof(" a ") - 1);
assert(Str_isEqual(Str_trim(o), "a"));
assert(Str_isEqual(Str_trim(o), "a"));
}
printf("=> Test6: OK\n\n");
printf("=> Test7: trim quotes\n");
{
char s5[] = "\"'abc'\"";
char s5a[] = "\"'abc";
char s5b[] = "abc'\"";
char s5c[] = "'\"";
char s5d[] = " \t abc def '\" ";
printf("\tResult: %s\n", Str_unquote(s5));
assert(Str_isEqual(s5, "abc"));
printf("\tResult: %s\n", Str_unquote(s5a));
assert(Str_isEqual(s5, "abc"));
printf("\tResult: %s\n", Str_unquote(s5b));
assert(Str_isEqual(s5, "abc"));
printf("\tResult: %s\n", Str_unquote(s5b));
assert(Str_isEqual(s5, "abc"));
printf("\tTesting for NULL argument\n");
assert(!Str_unquote(NULL));
printf("\tTesting for quotes-only argument\n");
assert(Str_isEqual("", Str_unquote(s5c)));
printf("\tTesting for quotes and white-space removal\n");
assert(Str_isEqual("abc def", Str_unquote(s5d)));
}
printf("=> Test7: OK\n\n");
printf("=> Test8: toLowerCase\n");
{
char s6[] = "AbC";
printf("\tResult: %s\n", Str_toLower(s6));
assert(Str_isEqual(s6, "abc"));
printf("\tTesting for NULL argument\n");
assert(!Str_toLower(NULL));
}
printf("=> Test8: OK\n\n");
printf("=> Test9: toUpperCase\n");
{
char s7[] = "aBc";
printf("\tResult: %s\n", Str_toUpper(s7));
assert(Str_isEqual(s7, "ABC"));
printf("\tTesting for NULL argument\n");
assert(!Str_toUpper(NULL));
}
printf("=> Test9: OK\n\n");
printf("=> Test10: parseInt, parseLLong, parseDouble\n");
{
char i[STRLEN] = " -2812 bla";
char ll[STRLEN] = " 2147483642 blabla";
char d[STRLEN] = " 2.718281828 this is e";
char de[STRLEN] = "1.495E+08 kilometer = An Astronomical Unit";
char ie[STRLEN] = " 9999999999999999999999999999999999999999";
printf("\tResult:\n");
printf("\tParsed int = %d\n", Str_parseInt(i));
assert(Str_parseInt(i)==-2812);
printf("\tParsed long long = %lld\n", Str_parseLLong(ll));
assert(Str_parseLLong(ll)==2147483642);
printf("\tParsed double = %.9f\n", Str_parseDouble(d));
assert(Str_parseDouble(d)==2.718281828);
printf("\tParsed double exp = %.3e\n", Str_parseDouble(de));
assert(Str_parseDouble(de)==1.495e+08);
TRY
Str_parseInt(ie);
assert(false);
CATCH(NumberFormatException)
printf("=> Test11: OK\n\n");
END_TRY;
}
printf("=> Test10: OK\n\n");
printf("=> Test11: replace\n");
{
char s9[] = "abccba";
printf("\tResult: %s\n", Str_replaceChar(s9, 'b', 'X'));
assert(Str_isEqual(s9, "aXccXa"));
printf("\tTesting for NULL argument\n");
assert(!Str_replaceChar(NULL, 'b', 'X'));
}
printf("=> Test11: OK\n\n");
printf("=> Test12: startsWith\n");
{
char *a = "mysql://*****:*****@ ]+@([-a-zA-Z0-9]+\\.)+[a-zA-Z]{2,}$";
char *valid_phone1 = "+4797141255";
char *valid_phone2 = "(47)-97-14-12-55";
char *invalid_phone1 = "141255";
char *invalid_phone2 = "(47)971412551234567890123456789012345678901234567890";
char *invalid_phone3 = "";
char *invalid_phone4 = "abc123";
char *valid_email1 = "*****@*****.**";
char *valid_email2 = "*****@*****.**";
char *invalid_email1 = "hauktildeslash.com";
char *invalid_email2 = "";
char *invalid_email3 = "hauk@tildeslashcom";
char *invalid_email4 = "hauk@æøåtildeslash.com";
// phone
printf("\tResult: match(%s, %s)\n", phone_pattern, valid_phone1);
assert(Str_match(phone_pattern, valid_phone1));
printf("\tResult: match(%s, %s)\n", phone_pattern, valid_phone2);
assert(Str_match(phone_pattern, valid_phone2));
printf("\tResult: match(%s, %s)\n", phone_pattern, invalid_phone1);
assert(! Str_match(phone_pattern, invalid_phone1));
printf("\tResult: match(%s, %s)\n", phone_pattern, invalid_phone2);
assert(! Str_match(phone_pattern, invalid_phone2));
printf("\tResult: match(%s, %s)\n", phone_pattern, invalid_phone3);
assert(! Str_match(phone_pattern, invalid_phone3));
printf("\tResult: match(%s, %s)\n", phone_pattern, invalid_phone4);
assert(! Str_match(phone_pattern, invalid_phone4));
// email
printf("\tResult: match(%s, %s)\n", email_pattern, valid_email1);
assert(Str_match(email_pattern, valid_email1));
printf("\tResult: match(%s, %s)\n", email_pattern, valid_email2);
assert(Str_match(email_pattern, valid_email2));
printf("\tResult: match(%s, %s)\n", email_pattern, invalid_email1);
assert(! Str_match(email_pattern, invalid_email1));
printf("\tResult: match(%s, %s)\n", email_pattern, invalid_email2);
assert(! Str_match(email_pattern, invalid_email2));
printf("\tResult: match(%s, %s)\n", email_pattern, invalid_email3);
assert(! Str_match(email_pattern, invalid_email3));
printf("\tResult: match(%s, %s)\n", email_pattern, invalid_email4);
assert(! Str_match(email_pattern, invalid_email4));
}
printf("=> Test17: OK\n\n");
printf("=> Test18: lim\n");
{
char *zero = "";
char *two = "12";
char *ten = "1234567890";
assert(! Str_lim(zero, 0));
assert(!Str_lim(zero, 1));
assert(Str_lim(two, 0));
assert(Str_lim(two, 1));
assert(!Str_lim(two, 2));
assert(Str_lim(ten, 0));
assert(Str_lim(ten, 5));
assert(Str_lim(ten, 9));
assert(!Str_lim(ten, 10));
assert(! Str_lim(ten, 100));
}
printf("=> Test18: OK\n\n");
printf("=> Test19: substring\n");
{
assert(Str_sub("foo bar baz", "bar"));
assert(! Str_sub("foo bar baz", "barx"));
assert(Str_isEqual(Str_sub("foo bar baz", "baz"), "baz"));
assert(Str_sub("foo bar baz", "foo bar baz"));
assert(Str_sub("a", "a"));
assert(! Str_sub("a", "b"));
assert(! Str_sub("", ""));
assert(! Str_sub("foo", ""));
assert(! Str_sub("abc", "abcdef"));
assert(! Str_sub("foo", "foo bar"));
assert(Str_isEqual(Str_sub("foo foo bar", "foo bar"), "foo bar"));
assert(Str_sub("foo foo bar foo bar baz fuu", "foo bar baz"));
assert(Str_isEqual(Str_sub("abcd abcc", "abcc"), "abcc"));
}
printf("=> Test19: OK\n\n");
printf("=> Test20: Str_join\n");
{
char *p = NULL;
char dest[10+1] = "xxxxxxxxx";
char a[] = "abc";
char *b = "def";
char *c = "xxx123";
assert(Str_isEqual(Str_join(dest, 10, a, b, "ghi"), "abcdefghi"));
assert(Str_isEqual(Str_join(dest, 10, p), ""));
assert(Str_isEqual(Str_join(dest, 10), ""));
assert(Str_isEqual(Str_join(dest, 10, "012", "3456789", "0123456789"), "0123456789"));
assert(Str_isEqual(Str_join(dest, 4, "a", "b", "cd", "ghi", "jklmnopq"), "abcd"));
assert(Str_isEqual(Str_join(dest, 10, a, c + 3), "abc123"));
Str_join(dest, 0);
assert(dest[0]==0);
}
printf("=> Test20: OK\n\n");
printf("=> Test21: Str_has\n");
{
char *foo = "'bar' (baz)";
assert(Str_has("(')", foo));
assert(! Str_has(",;", foo));
}
printf("=> Test21: OK\n\n");
printf("=> Test22: Str_curtail\n");
{
char s[] = "<text>Hello World</text>";
assert(Str_isByteEqual(Str_curtail(s, "</text>"), "<text>Hello World"));
assert(Str_isByteEqual(Str_curtail(s, ">"), "<text"));
assert(Str_isByteEqual(Str_curtail(s, "@"), "<text"));
}
printf("=> Test22: OK\n\n");
printf("=> Test23: Str_ton\n");
{
char str[43];
long l1 = 42, l2 = 0, l3 = -42, l4 = LONG_MAX, l5 = LONG_MIN;
assert(Str_isByteEqual("42", Str_ton(42, (char[43]){0})));
assert(Str_isByteEqual("42", Str_ton(l1, str)));
assert(Str_isByteEqual("0", Str_ton(l2, str)));
assert(Str_isByteEqual("-42", Str_ton(l3, str)));
assert(l4 == Str_parseLLong(Str_ton(l4, str)));
assert(l5 == Str_parseLLong(Str_ton(l5, str)));
}
