hcq/MaxScale
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MXS-2020 Replace ss[_info]_dassert with mxb_assert[_message]

Browse Source
This commit is contained in:
Johan Wikman
2018-08-22 09:59:02 +03:00
parent b1e405442f
commit 3f53eddbde
161 changed files with 1640 additions and 1643 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
server/core/test/profile_trxboundaryparser.cc
View File

@ -28,7 +28,7 @@ timespec timespec_subtract(const timespec& later, const timespec& earlier)
{
timespec result = { 0, 0 };
ss_dassert((later.tv_sec > earlier.tv_sec) ||
mxb_assert((later.tv_sec > earlier.tv_sec) ||
((later.tv_sec == earlier.tv_sec) && (later.tv_nsec > earlier.tv_nsec)));
if (later.tv_nsec >= earlier.tv_nsec)

6
server/core/test/test_atomic.cc
View File

@ -33,7 +33,7 @@ void test_add(void* data)
{
atomic_add(&expected, id);
atomic_add(&expected, -id);
ss_dassert(atomic_load_int32(&expected) >= 0);
mxb_assert(atomic_load_int32(&expected) >= 0);
}
}
@ -45,7 +45,7 @@ void test_load_store(void* data)
{
if (atomic_load_int32(&expected) % NTHR == id)
{
ss_dassert(atomic_add(&expected, 1) % NTHR == id + 1);
mxb_assert(atomic_add(&expected, 1) % NTHR == id + 1);
}
}
}
@ -72,7 +72,7 @@ void test_cas(void* data)
loops++;
}
ss_dassert(loops > 0);
mxb_assert(loops > 0);
}
int run_test(void(*func)(void*))

236
server/core/test/test_buffer.cc
View File

@ -109,9 +109,9 @@ void split_buffer(int n, int offset)
int len = gwbuf_length(buffer);
GWBUF* newbuf = gwbuf_split(&buffer, cutoff);
ss_info_dassert(buffer && newbuf, "Both buffers should be non-NULL");
ss_info_dassert(gwbuf_length(newbuf) == cutoff, "New buffer should be have correct length");
ss_info_dassert(gwbuf_length(buffer) == len - cutoff, "Old buffer should be have correct length");
mxb_assert_message(buffer && newbuf, "Both buffers should be non-NULL");
mxb_assert_message(gwbuf_length(newbuf) == cutoff, "New buffer should be have correct length");
mxb_assert_message(gwbuf_length(buffer) == len - cutoff, "Old buffer should be have correct length");
gwbuf_free(buffer);
gwbuf_free(newbuf);
}
@ -124,8 +124,8 @@ void consume_buffer(int n, int offset)
int len = gwbuf_length(buffer);
buffer = gwbuf_consume(buffer, cutoff);
ss_info_dassert(buffer, "Buffer should be non-NULL");
ss_info_dassert(gwbuf_length(buffer) == len - cutoff, "Buffer should be have correct length");
mxb_assert_message(buffer, "Buffer should be non-NULL");
mxb_assert_message(gwbuf_length(buffer) == len - cutoff, "Buffer should be have correct length");
gwbuf_free(buffer);
}
@ -138,8 +138,8 @@ void copy_buffer(int n, int offset)
uint8_t dest[cutoff];
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(buffer, 0, cutoff, dest) == cutoff, "All bytes should be read");
ss_info_dassert(memcmp(data, dest, sizeof(dest)) == 0, "Data should be OK");
mxb_assert_message(gwbuf_copy_data(buffer, 0, cutoff, dest) == cutoff, "All bytes should be read");
mxb_assert_message(memcmp(data, dest, sizeof(dest)) == 0, "Data should be OK");
gwbuf_free(buffer);
MXS_FREE(data);
}
@ -151,56 +151,56 @@ void test_split()
size_t tailsize = 20;
GWBUF* oldchain = gwbuf_append(gwbuf_alloc(headsize), gwbuf_alloc(tailsize));
ss_info_dassert(gwbuf_length(oldchain) == headsize + tailsize, "Allocated buffer should be 30 bytes");
mxb_assert_message(gwbuf_length(oldchain) == headsize + tailsize, "Allocated buffer should be 30 bytes");
GWBUF* newchain = gwbuf_split(&oldchain, headsize + 5);
ss_info_dassert(newchain && oldchain, "Both chains should be non-NULL");
ss_info_dassert(gwbuf_length(newchain) == headsize + 5, "New chain should be 15 bytes long");
ss_info_dassert(GWBUF_LENGTH(newchain) == headsize && GWBUF_LENGTH(newchain->next) == 5,
mxb_assert_message(newchain && oldchain, "Both chains should be non-NULL");
mxb_assert_message(gwbuf_length(newchain) == headsize + 5, "New chain should be 15 bytes long");
mxb_assert_message(GWBUF_LENGTH(newchain) == headsize && GWBUF_LENGTH(newchain->next) == 5,
"The new chain should have a 10 byte buffer and a 5 byte buffer");
ss_info_dassert(gwbuf_length(oldchain) == tailsize - 5, "Old chain should be 15 bytes long");
ss_info_dassert(GWBUF_LENGTH(oldchain) == tailsize - 5 && oldchain->next == NULL,
mxb_assert_message(gwbuf_length(oldchain) == tailsize - 5, "Old chain should be 15 bytes long");
mxb_assert_message(GWBUF_LENGTH(oldchain) == tailsize - 5 && oldchain->next == NULL,
"The old chain should have a 15 byte buffer and no next buffer");
gwbuf_free(oldchain);
gwbuf_free(newchain);
oldchain = gwbuf_append(gwbuf_alloc(headsize), gwbuf_alloc(tailsize));
newchain = gwbuf_split(&oldchain, headsize);
ss_info_dassert(gwbuf_length(newchain) == headsize, "New chain should be 10 bytes long");
ss_info_dassert(gwbuf_length(oldchain) == tailsize, "Old chain should be 20 bytes long");
ss_info_dassert(oldchain->tail == oldchain, "Old chain tail should point to old chain");
ss_info_dassert(oldchain->next == NULL, "Old chain should not have next buffer");
ss_info_dassert(newchain->tail == newchain, "Old chain tail should point to old chain");
ss_info_dassert(newchain->next == NULL, "new chain should not have next buffer");
mxb_assert_message(gwbuf_length(newchain) == headsize, "New chain should be 10 bytes long");
mxb_assert_message(gwbuf_length(oldchain) == tailsize, "Old chain should be 20 bytes long");
mxb_assert_message(oldchain->tail == oldchain, "Old chain tail should point to old chain");
mxb_assert_message(oldchain->next == NULL, "Old chain should not have next buffer");
mxb_assert_message(newchain->tail == newchain, "Old chain tail should point to old chain");
mxb_assert_message(newchain->next == NULL, "new chain should not have next buffer");
gwbuf_free(oldchain);
gwbuf_free(newchain);
oldchain = gwbuf_append(gwbuf_alloc(headsize), gwbuf_alloc(tailsize));
newchain = gwbuf_split(&oldchain, headsize + tailsize);
ss_info_dassert(newchain, "New chain should be non-NULL");
ss_info_dassert(gwbuf_length(newchain) == headsize + tailsize, "New chain should be 30 bytes long");
ss_info_dassert(oldchain == NULL, "Old chain should be NULL");
mxb_assert_message(newchain, "New chain should be non-NULL");
mxb_assert_message(gwbuf_length(newchain) == headsize + tailsize, "New chain should be 30 bytes long");
mxb_assert_message(oldchain == NULL, "Old chain should be NULL");
gwbuf_free(newchain);
/** Splitting of contiguous memory */
GWBUF* buffer = gwbuf_alloc(10);
GWBUF* newbuf = gwbuf_split(&buffer, 5);
ss_info_dassert(buffer != newbuf, "gwbuf_split should return different pointers");
ss_info_dassert(gwbuf_length(buffer) == 5 && GWBUF_LENGTH(buffer) == 5, "Old buffer should be 5 bytes");
ss_info_dassert(gwbuf_length(newbuf) == 5 && GWBUF_LENGTH(newbuf) == 5, "New buffer should be 5 bytes");
ss_info_dassert(buffer->tail == buffer, "Old buffer's tail should point to itself");
ss_info_dassert(newbuf->tail == newbuf, "New buffer's tail should point to itself");
ss_info_dassert(buffer->next == NULL, "Old buffer's next pointer should be NULL");
ss_info_dassert(newbuf->next == NULL, "New buffer's next pointer should be NULL");
mxb_assert_message(buffer != newbuf, "gwbuf_split should return different pointers");
mxb_assert_message(gwbuf_length(buffer) == 5 && GWBUF_LENGTH(buffer) == 5, "Old buffer should be 5 bytes");
mxb_assert_message(gwbuf_length(newbuf) == 5 && GWBUF_LENGTH(newbuf) == 5, "New buffer should be 5 bytes");
mxb_assert_message(buffer->tail == buffer, "Old buffer's tail should point to itself");
mxb_assert_message(newbuf->tail == newbuf, "New buffer's tail should point to itself");
mxb_assert_message(buffer->next == NULL, "Old buffer's next pointer should be NULL");
mxb_assert_message(newbuf->next == NULL, "New buffer's next pointer should be NULL");
gwbuf_free(buffer);
gwbuf_free(newbuf);
/** Bad parameter tests */
GWBUF* ptr = NULL;
ss_info_dassert(gwbuf_split(NULL, 0) == NULL, "gwbuf_split with NULL parameter should return NULL");
ss_info_dassert(gwbuf_split(&ptr, 0) == NULL, "gwbuf_split with pointer to a NULL value should return NULL");
mxb_assert_message(gwbuf_split(NULL, 0) == NULL, "gwbuf_split with NULL parameter should return NULL");
mxb_assert_message(gwbuf_split(&ptr, 0) == NULL, "gwbuf_split with pointer to a NULL value should return NULL");
buffer = gwbuf_alloc(10);
ss_info_dassert(gwbuf_split(&buffer, 0) == NULL, "gwbuf_split with length of 0 should return NULL");
ss_info_dassert(gwbuf_length(buffer) == 10, "Buffer should be 10 bytes");
mxb_assert_message(gwbuf_split(&buffer, 0) == NULL, "gwbuf_split with length of 0 should return NULL");
mxb_assert_message(gwbuf_length(buffer) == 10, "Buffer should be 10 bytes");
gwbuf_free(buffer);
/** Splitting near buffer boudaries */
@ -223,45 +223,45 @@ void test_load_and_copy()
GWBUF* head = gwbuf_alloc_and_load(4, data);
GWBUF* tail = gwbuf_alloc_and_load(4, data + 4);
ss_info_dassert(memcmp(GWBUF_DATA(head), data, 4) == 0, "Loading 4 bytes should succeed");
ss_info_dassert(memcmp(GWBUF_DATA(tail), data + 4, 4) == 0, "Loading 4 bytes should succeed");
mxb_assert_message(memcmp(GWBUF_DATA(head), data, 4) == 0, "Loading 4 bytes should succeed");
mxb_assert_message(memcmp(GWBUF_DATA(tail), data + 4, 4) == 0, "Loading 4 bytes should succeed");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 0, 4, dest) == 4, "Copying 4 bytes should succeed");
ss_info_dassert(memcmp(dest, data, 4) == 0, "Copied data should be from 1 to 4");
mxb_assert_message(gwbuf_copy_data(head, 0, 4, dest) == 4, "Copying 4 bytes should succeed");
mxb_assert_message(memcmp(dest, data, 4) == 0, "Copied data should be from 1 to 4");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(tail, 0, 4, dest) == 4, "Copying 4 bytes should succeed");
ss_info_dassert(memcmp(dest, data + 4, 4) == 0, "Copied data should be from 5 to 8");
mxb_assert_message(gwbuf_copy_data(tail, 0, 4, dest) == 4, "Copying 4 bytes should succeed");
mxb_assert_message(memcmp(dest, data + 4, 4) == 0, "Copied data should be from 5 to 8");
head = gwbuf_append(head, tail);
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 0, 8, dest) == 8, "Copying 8 bytes should succeed");
ss_info_dassert(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
mxb_assert_message(gwbuf_copy_data(head, 0, 8, dest) == 8, "Copying 8 bytes should succeed");
mxb_assert_message(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 4, 4, dest) == 4, "Copying 4 bytes at offset 4 should succeed");
ss_info_dassert(memcmp(dest, data + 4, 4) == 0, "Copied data should be from 5 to 8");
mxb_assert_message(gwbuf_copy_data(head, 4, 4, dest) == 4, "Copying 4 bytes at offset 4 should succeed");
mxb_assert_message(memcmp(dest, data + 4, 4) == 0, "Copied data should be from 5 to 8");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 2, 4, dest) == 4, "Copying 4 bytes at offset 2 should succeed");
ss_info_dassert(memcmp(dest, data + 2, 4) == 0, "Copied data should be from 5 to 8");
mxb_assert_message(gwbuf_copy_data(head, 2, 4, dest) == 4, "Copying 4 bytes at offset 2 should succeed");
mxb_assert_message(memcmp(dest, data + 2, 4) == 0, "Copied data should be from 5 to 8");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 0, 10, dest) == 8, "Copying 10 bytes should only copy 8 bytes");
ss_info_dassert(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
mxb_assert_message(gwbuf_copy_data(head, 0, 10, dest) == 8, "Copying 10 bytes should only copy 8 bytes");
mxb_assert_message(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 0, 0, dest) == 0, "Copying 0 bytes should not copy any bytes");
mxb_assert_message(gwbuf_copy_data(head, 0, 0, dest) == 0, "Copying 0 bytes should not copy any bytes");
memset(dest, 0, sizeof(dest));
ss_info_dassert(gwbuf_copy_data(head, 0, -1, dest) == sizeof(data),
mxb_assert_message(gwbuf_copy_data(head, 0, -1, dest) == sizeof(data),
"Copying -1 bytes should copy all available data (cast to unsigned)");
ss_info_dassert(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
mxb_assert_message(memcmp(dest, data, 8) == 0, "Copied data should be from 1 to 8");
ss_info_dassert(gwbuf_copy_data(head, -1, -1, dest) == 0,
mxb_assert_message(gwbuf_copy_data(head, -1, -1, dest) == 0,
"Copying -1 bytes at an offset of -1 should not copy any bytes");
ss_info_dassert(gwbuf_copy_data(head, -1, 0, dest) == 0,
mxb_assert_message(gwbuf_copy_data(head, -1, 0, dest) == 0,
"Copying 0 bytes at an offset of -1 should not copy any bytes");
gwbuf_free(head);
@ -283,27 +283,27 @@ void test_consume()
GWBUF* buffer = gwbuf_append(gwbuf_alloc_and_load(5, data),
gwbuf_alloc_and_load(5, data + 5));
ss_info_dassert(gwbuf_consume(buffer, 0) == buffer,
mxb_assert_message(gwbuf_consume(buffer, 0) == buffer,
"Consuming 0 bytes from a buffer should return original buffer");
ss_info_dassert(gwbuf_length(buffer) == 10, "Buffer should be 10 bytes after consuming 0 bytes");
mxb_assert_message(gwbuf_length(buffer) == 10, "Buffer should be 10 bytes after consuming 0 bytes");
buffer = gwbuf_consume(buffer, 1);
ss_info_dassert(GWBUF_LENGTH(buffer) == 4, "First buffer should be 4 bytes long");
ss_info_dassert(buffer->next, "Buffer should have next pointer set");
ss_info_dassert(GWBUF_LENGTH(buffer->next) == 5, "Next buffer should be 5 bytes long");
ss_info_dassert(gwbuf_length(buffer) == 9, "Buffer should be 9 bytes after consuming 1 bytes");
ss_info_dassert(*((uint8_t*)buffer->start) == 2, "First byte should be 2");
mxb_assert_message(GWBUF_LENGTH(buffer) == 4, "First buffer should be 4 bytes long");
mxb_assert_message(buffer->next, "Buffer should have next pointer set");
mxb_assert_message(GWBUF_LENGTH(buffer->next) == 5, "Next buffer should be 5 bytes long");
mxb_assert_message(gwbuf_length(buffer) == 9, "Buffer should be 9 bytes after consuming 1 bytes");
mxb_assert_message(*((uint8_t*)buffer->start) == 2, "First byte should be 2");
buffer = gwbuf_consume(buffer, 5);
ss_info_dassert(buffer->next == NULL, "Buffer should not have the next pointer set");
ss_info_dassert(GWBUF_LENGTH(buffer) == 4, "Buffer should be 4 bytes after consuming 6 bytes");
ss_info_dassert(gwbuf_length(buffer) == 4, "Buffer should be 4 bytes after consuming 6 bytes");
ss_info_dassert(*((uint8_t*)buffer->start) == 7, "First byte should be 7");
ss_info_dassert(gwbuf_consume(buffer, 4) == NULL, "Consuming all bytes should return NULL");
mxb_assert_message(buffer->next == NULL, "Buffer should not have the next pointer set");
mxb_assert_message(GWBUF_LENGTH(buffer) == 4, "Buffer should be 4 bytes after consuming 6 bytes");
mxb_assert_message(gwbuf_length(buffer) == 4, "Buffer should be 4 bytes after consuming 6 bytes");
mxb_assert_message(*((uint8_t*)buffer->start) == 7, "First byte should be 7");
mxb_assert_message(gwbuf_consume(buffer, 4) == NULL, "Consuming all bytes should return NULL");
buffer = gwbuf_append(gwbuf_alloc_and_load(5, data),
gwbuf_alloc_and_load(5, data + 5));
ss_info_dassert(gwbuf_consume(buffer, 100) == NULL,
mxb_assert_message(gwbuf_consume(buffer, 100) == NULL,
"Consuming more bytes than are available should return NULL");
@ -329,26 +329,26 @@ void test_compare()
GWBUF* rhs = NULL;
// Both NULL
ss_dassert(gwbuf_compare(lhs, rhs) == 0);
mxb_assert(gwbuf_compare(lhs, rhs) == 0);
// Either (but not both) NULL
lhs = gwbuf_alloc_and_load(10, data);
ss_dassert(gwbuf_compare(lhs, rhs) > 0);
ss_dassert(gwbuf_compare(rhs, lhs) < 0);
mxb_assert(gwbuf_compare(lhs, rhs) > 0);
mxb_assert(gwbuf_compare(rhs, lhs) < 0);
// The same array
ss_dassert(gwbuf_compare(lhs, lhs) == 0);
mxb_assert(gwbuf_compare(lhs, lhs) == 0);
// Identical array
gwbuf_free(rhs);
rhs = gwbuf_alloc_and_load(10, data);
ss_dassert(gwbuf_compare(lhs, rhs) == 0);
mxb_assert(gwbuf_compare(lhs, rhs) == 0);
// One shorter
gwbuf_free(rhs);
rhs = gwbuf_alloc_and_load(9, data + 1);
ss_dassert(gwbuf_compare(lhs, rhs) > 0);
ss_dassert(gwbuf_compare(rhs, lhs) < 0);
mxb_assert(gwbuf_compare(lhs, rhs) > 0);
mxb_assert(gwbuf_compare(rhs, lhs) < 0);
// One segmented, but otherwise identical.
gwbuf_free(rhs);
@ -357,8 +357,8 @@ void test_compare()
rhs = gwbuf_append(rhs, gwbuf_alloc_and_load(3, data + 3));
rhs = gwbuf_append(rhs, gwbuf_alloc_and_load(4, data + 3 + 3));
ss_dassert(gwbuf_compare(lhs, rhs) == 0);
ss_dassert(gwbuf_compare(rhs, rhs) == 0);
mxb_assert(gwbuf_compare(lhs, rhs) == 0);
mxb_assert(gwbuf_compare(rhs, rhs) == 0);
// Both segmented, but otherwise identical.
gwbuf_free(lhs);
@ -366,8 +366,8 @@ void test_compare()
lhs = gwbuf_append(lhs, gwbuf_alloc_and_load(5, data));
lhs = gwbuf_append(lhs, gwbuf_alloc_and_load(5, data + 5));
ss_dassert(gwbuf_compare(lhs, rhs) == 0);
ss_dassert(gwbuf_compare(rhs, lhs) == 0);
mxb_assert(gwbuf_compare(lhs, rhs) == 0);
mxb_assert(gwbuf_compare(rhs, lhs) == 0);
// Both segmented and of same length, but different.
gwbuf_free(lhs);
@ -375,8 +375,8 @@ void test_compare()
lhs = gwbuf_append(lhs, gwbuf_alloc_and_load(5, data + 5)); // Values in different order
lhs = gwbuf_append(lhs, gwbuf_alloc_and_load(5, data));
ss_dassert(gwbuf_compare(lhs, rhs) > 0); // 5 > 1
ss_dassert(gwbuf_compare(rhs, lhs) < 0); // 5 > 1
mxb_assert(gwbuf_compare(lhs, rhs) > 0); // 5 > 1
mxb_assert(gwbuf_compare(rhs, lhs) < 0); // 5 > 1
// Identical, but one containing empty segments.
gwbuf_free(rhs);
@ -387,8 +387,8 @@ void test_compare()
rhs = gwbuf_append(rhs, gwbuf_alloc_and_load(5, data));
rhs = gwbuf_append(rhs, gwbuf_alloc_and_load(0, data));
ss_dassert(gwbuf_compare(lhs, rhs) == 0);
ss_dassert(gwbuf_compare(rhs, lhs) == 0);
mxb_assert(gwbuf_compare(lhs, rhs) == 0);
mxb_assert(gwbuf_compare(rhs, lhs) == 0);
gwbuf_free(lhs);
gwbuf_free(rhs);
@ -413,12 +413,12 @@ void test_clone()
GWBUF* o = original;
GWBUF* c = clone;
ss_dassert(gwbuf_length(o) == gwbuf_length(c));
mxb_assert(gwbuf_length(o) == gwbuf_length(c));
while (o)
{
ss_dassert(c);
ss_dassert(GWBUF_LENGTH(o) == GWBUF_LENGTH(c));
mxb_assert(c);
mxb_assert(GWBUF_LENGTH(o) == GWBUF_LENGTH(c));
const char* i = (char*)GWBUF_DATA(o);
const char* end = i + GWBUF_LENGTH(o);
@ -426,7 +426,7 @@ void test_clone()
while (i != end)
{
ss_dassert(*i == *j);
mxb_assert(*i == *j);
++i;
++j;
}
@ -435,7 +435,7 @@ void test_clone()
c = c->next;
}
ss_dassert(c == NULL);
mxb_assert(c == NULL);
gwbuf_free(clone);
gwbuf_free(original);
@ -464,48 +464,48 @@ test1()
fprintf(stderr, "\t..done\nAllocated buffer of size %lu.", size);
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "\nBuffer length is now %lu", buflen);
ss_info_dassert(size == buflen, "Incorrect buffer size");
ss_info_dassert(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
ss_info_dassert(GWBUF_IS_TYPE_UNDEFINED(buffer), "Buffer type should be undefined");
mxb_assert_message(size == buflen, "Incorrect buffer size");
mxb_assert_message(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
mxb_assert_message(GWBUF_IS_TYPE_UNDEFINED(buffer), "Buffer type should be undefined");
fprintf(stderr, "\t..done\nSet a property for the buffer");
gwbuf_add_property(buffer, (char*)"name", (char*)"value");
ss_info_dassert(0 == strcmp("value", gwbuf_get_property(buffer, (char*)"name")),
mxb_assert_message(0 == strcmp("value", gwbuf_get_property(buffer, (char*)"name")),
"Should now have correct property");
strcpy((char*)GWBUF_DATA(buffer), "The quick brown fox jumps over the lazy dog");
fprintf(stderr, "\t..done\nLoad some data into the buffer");
ss_info_dassert('q' == GWBUF_DATA_CHAR(buffer, 4), "Fourth character of buffer must be 'q'");
ss_info_dassert(-1 == GWBUF_DATA_CHAR(buffer, 105), "Hundred and fifth character of buffer must return -1");
ss_info_dassert(0 == GWBUF_IS_SQL(buffer), "Must say buffer is not SQL, as it does not have marker");
mxb_assert_message('q' == GWBUF_DATA_CHAR(buffer, 4), "Fourth character of buffer must be 'q'");
mxb_assert_message(-1 == GWBUF_DATA_CHAR(buffer, 105), "Hundred and fifth character of buffer must return -1");
mxb_assert_message(0 == GWBUF_IS_SQL(buffer), "Must say buffer is not SQL, as it does not have marker");
strcpy((char*)GWBUF_DATA(buffer), "1234\x03SELECT * FROM sometable");
fprintf(stderr, "\t..done\nLoad SQL data into the buffer");
ss_info_dassert(1 == GWBUF_IS_SQL(buffer), "Must say buffer is SQL, as it does have marker");
mxb_assert_message(1 == GWBUF_IS_SQL(buffer), "Must say buffer is SQL, as it does have marker");
clone = gwbuf_clone(buffer);
fprintf(stderr, "\t..done\nCloned buffer");
buflen = GWBUF_LENGTH(clone);
fprintf(stderr, "\nCloned buffer length is now %lu", buflen);
ss_info_dassert(size == buflen, "Incorrect buffer size");
ss_info_dassert(0 == GWBUF_EMPTY(clone), "Cloned buffer should not be empty");
mxb_assert_message(size == buflen, "Incorrect buffer size");
mxb_assert_message(0 == GWBUF_EMPTY(clone), "Cloned buffer should not be empty");
fprintf(stderr, "\t..done\n");
gwbuf_free(clone);
fprintf(stderr, "Freed cloned buffer");
fprintf(stderr, "\t..done\n");
buffer = gwbuf_consume(buffer, bite1);
ss_info_dassert(NULL != buffer, "Buffer should not be null");
mxb_assert_message(NULL != buffer, "Buffer should not be null");
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "Consumed %lu bytes, now have %lu, should have %lu", bite1, buflen, size - bite1);
ss_info_dassert((size - bite1) == buflen, "Incorrect buffer size");
ss_info_dassert(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
mxb_assert_message((size - bite1) == buflen, "Incorrect buffer size");
mxb_assert_message(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
fprintf(stderr, "\t..done\n");
buffer = gwbuf_consume(buffer, bite2);
ss_info_dassert(NULL != buffer, "Buffer should not be null");
mxb_assert_message(NULL != buffer, "Buffer should not be null");
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "Consumed %lu bytes, now have %lu, should have %lu", bite2, buflen, size - bite1 - bite2);
ss_info_dassert((size - bite1 - bite2) == buflen, "Incorrect buffer size");
ss_info_dassert(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
mxb_assert_message((size - bite1 - bite2) == buflen, "Incorrect buffer size");
mxb_assert_message(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
fprintf(stderr, "\t..done\n");
buffer = gwbuf_consume(buffer, bite3);
fprintf(stderr, "Consumed %lu bytes, should have null buffer", bite3);
ss_info_dassert(NULL == buffer, "Buffer should be null");
mxb_assert_message(NULL == buffer, "Buffer should be null");
/* Buffer list tests */
size = 100000;
@ -513,26 +513,26 @@ test1()
fprintf(stderr, "\t..done\nAllocated buffer of size %lu.", size);
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "\nBuffer length is now %lu", buflen);
ss_info_dassert(size == buflen, "Incorrect buffer size");
ss_info_dassert(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
ss_info_dassert(GWBUF_IS_TYPE_UNDEFINED(buffer), "Buffer type should be undefined");
mxb_assert_message(size == buflen, "Incorrect buffer size");
mxb_assert_message(0 == GWBUF_EMPTY(buffer), "Buffer should not be empty");
mxb_assert_message(GWBUF_IS_TYPE_UNDEFINED(buffer), "Buffer type should be undefined");
extra = gwbuf_alloc(size);
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "\t..done\nAllocated extra buffer of size %lu.", size);
ss_info_dassert(size == buflen, "Incorrect buffer size");
mxb_assert_message(size == buflen, "Incorrect buffer size");
buffer = gwbuf_append(buffer, extra);
buflen = gwbuf_length(buffer);
fprintf(stderr, "\t..done\nAppended extra buffer to original buffer to create list of size %lu", buflen);
ss_info_dassert((size * 2) == gwbuf_length(buffer), "Incorrect size for set of buffers");
mxb_assert_message((size * 2) == gwbuf_length(buffer), "Incorrect size for set of buffers");
buffer = gwbuf_rtrim(buffer, 60000);
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "\t..done\nTrimmed 60 bytes from buffer, now size is %lu.", buflen);
ss_info_dassert((size - 60000) == buflen, "Incorrect buffer size");
mxb_assert_message((size - 60000) == buflen, "Incorrect buffer size");
buffer = gwbuf_rtrim(buffer, 60000);
buflen = GWBUF_LENGTH(buffer);
fprintf(stderr, "\t..done\nTrimmed another 60 bytes from buffer, now size is %lu.", buflen);
ss_info_dassert(100000 == buflen, "Incorrect buffer size");
ss_info_dassert(buffer == extra, "The buffer pointer should now point to the extra buffer");
mxb_assert_message(100000 == buflen, "Incorrect buffer size");
mxb_assert_message(buffer == extra, "The buffer pointer should now point to the extra buffer");
fprintf(stderr, "\t..done\n");
gwbuf_free(buffer);
/** gwbuf_clone_all test */
@ -541,16 +541,16 @@ test1()
size_t tailsize = 20;
GWBUF* tail = gwbuf_alloc(tailsize);
ss_info_dassert(head && tail, "Head and tail buffers should both be non-NULL");
mxb_assert_message(head && tail, "Head and tail buffers should both be non-NULL");
GWBUF* append = gwbuf_append(head, tail);
ss_info_dassert(append == head, "gwbuf_append should return head");
ss_info_dassert(append->next == tail, "After append tail should be in the next pointer of head");
ss_info_dassert(append->tail == tail, "After append tail should be in the tail pointer of head");
mxb_assert_message(append == head, "gwbuf_append should return head");
mxb_assert_message(append->next == tail, "After append tail should be in the next pointer of head");
mxb_assert_message(append->tail == tail, "After append tail should be in the tail pointer of head");
GWBUF* all_clones = gwbuf_clone(head);
ss_info_dassert(all_clones && all_clones->next, "Cloning all should work");
ss_info_dassert(GWBUF_LENGTH(all_clones) == headsize, "First buffer should be 10 bytes");
ss_info_dassert(GWBUF_LENGTH(all_clones->next) == tailsize, "Second buffer should be 20 bytes");
ss_info_dassert(gwbuf_length(all_clones) == headsize + tailsize, "Total buffer length should be 30 bytes");
mxb_assert_message(all_clones && all_clones->next, "Cloning all should work");
mxb_assert_message(GWBUF_LENGTH(all_clones) == headsize, "First buffer should be 10 bytes");
mxb_assert_message(GWBUF_LENGTH(all_clones->next) == tailsize, "Second buffer should be 20 bytes");
mxb_assert_message(gwbuf_length(all_clones) == headsize + tailsize, "Total buffer length should be 30 bytes");
gwbuf_free(all_clones);
gwbuf_free(head);

2
server/core/test/test_event.cc
View File

@ -424,7 +424,7 @@ int test_event_configuration()
}
else
{
ss_dassert(c.what == What::LEVEL);
mxb_assert(c.what == What::LEVEL);
int32_t level = event::get_log_level(c.id);

6
server/core/test/test_hint.cc
View File

@ -51,9 +51,9 @@ test1()
char* name = MXS_STRDUP_A("name");
hint = hint_create_parameter(NULL, name, "value");
MXS_FREE(name);
ss_info_dassert(NULL != hint, "New hint list should not be null");
ss_info_dassert(0 == strcmp("value", (char*)hint->value), "Hint value should be correct");
ss_info_dassert(0 != hint_exists(&hint, HINT_PARAMETER), "Hint of parameter type should exist");
mxb_assert_message(NULL != hint, "New hint list should not be null");
mxb_assert_message(0 == strcmp("value", (char*)hint->value), "Hint value should be correct");
mxb_assert_message(0 != hint_exists(&hint, HINT_PARAMETER), "Hint of parameter type should exist");
fprintf(stderr, "\t..done\nFree hints.");
if (NULL != hint)
{

4
server/core/test/test_http.cc
View File

@ -32,8 +32,8 @@ int main(int argc, char** argv)
cout << "Converted Linux time: " << converted_now << endl;
cout << "Converted HTTP-date: " << converted_date << endl;
ss_dassert(now == converted_now);
ss_dassert(date == converted_date);
mxb_assert(now == converted_now);
mxb_assert(date == converted_date);
return 0;
}

42
server/core/test/test_json.cc
View File

@ -259,33 +259,33 @@ int test1()
json_error_t err = {};
json_t* json = json_loads(test1_json, 0, &err);
ss_dassert(json);
mxb_assert(json);
ss_dassert(mxs_json_pointer(json, "") == json);
ss_dassert(mxs_json_pointer(json, "links") == json_object_get(json, "links"));
ss_dassert(json_is_string(mxs_json_pointer(json, "links/self")));
mxb_assert(mxs_json_pointer(json, "") == json);
mxb_assert(mxs_json_pointer(json, "links") == json_object_get(json, "links"));
mxb_assert(json_is_string(mxs_json_pointer(json, "links/self")));
ss_dassert(mxs_json_pointer(json, "data") == json_object_get(json, "data"));
ss_dassert(json_is_array(mxs_json_pointer(json, "data")));
mxb_assert(mxs_json_pointer(json, "data") == json_object_get(json, "data"));
mxb_assert(json_is_array(mxs_json_pointer(json, "data")));
ss_dassert(json_is_object(mxs_json_pointer(json, "data/0")));
ss_dassert(json_is_string(mxs_json_pointer(json, "data/0/id")));
mxb_assert(json_is_object(mxs_json_pointer(json, "data/0")));
mxb_assert(json_is_string(mxs_json_pointer(json, "data/0/id")));
string s = json_string_value(mxs_json_pointer(json, "data/0/id"));
ss_dassert(s == "server1");
mxb_assert(s == "server1");
ss_dassert(json_is_object(mxs_json_pointer(json, "data/1")));
ss_dassert(json_is_string(mxs_json_pointer(json, "data/1/id")));
mxb_assert(json_is_object(mxs_json_pointer(json, "data/1")));
mxb_assert(json_is_string(mxs_json_pointer(json, "data/1/id")));
s = json_string_value(mxs_json_pointer(json, "data/1/id"));
ss_dassert(s == "server2");
mxb_assert(s == "server2");
ss_dassert(json_is_object(mxs_json_pointer(json, "data/0/attributes")));
ss_dassert(json_is_object(mxs_json_pointer(json, "data/0/attributes/parameters")));
ss_dassert(json_is_integer(mxs_json_pointer(json, "data/0/attributes/parameters/port")));
mxb_assert(json_is_object(mxs_json_pointer(json, "data/0/attributes")));
mxb_assert(json_is_object(mxs_json_pointer(json, "data/0/attributes/parameters")));
mxb_assert(json_is_integer(mxs_json_pointer(json, "data/0/attributes/parameters/port")));
int i = json_integer_value(mxs_json_pointer(json, "data/0/attributes/parameters/port"));
ss_dassert(i == 3000);
mxb_assert(i == 3000);
ss_dassert(json_is_array(mxs_json_pointer(json, "data/0/attributes/slaves")));
ss_dassert(json_array_size(mxs_json_pointer(json, "data/0/attributes/slaves")) == 3);
mxb_assert(json_is_array(mxs_json_pointer(json, "data/0/attributes/slaves")));
mxb_assert(json_array_size(mxs_json_pointer(json, "data/0/attributes/slaves")) == 3);
json_decref(json);
@ -300,7 +300,7 @@ int test2()
err = mxs_json_error("%s", "This is an error!");
s = json_dumps(err, 0);
printf("%s\n", s);
ss_dassert(strcmp(s, "{\"errors\": [{\"detail\": \"This is an error!\"}]}") == 0);
mxb_assert(strcmp(s, "{\"errors\": [{\"detail\": \"This is an error!\"}]}") == 0);
MXS_FREE(s);
json_decref(err);
@ -308,13 +308,13 @@ int test2()
err = mxs_json_error_append(NULL, "%s", "This is an error!");
s = json_dumps(err, 0);
printf("%s\n", s);
ss_dassert(strcmp(s, "{\"errors\": [{\"detail\": \"This is an error!\"}]}") == 0);
mxb_assert(strcmp(s, "{\"errors\": [{\"detail\": \"This is an error!\"}]}") == 0);
MXS_FREE(s);
err = mxs_json_error_append(err, "%s", "This is another error!");
s = json_dumps(err, 0);
printf("%s\n", s);
ss_dassert(strcmp(s,
mxb_assert(strcmp(s,
"{\"errors\": [{\"detail\": \"This is an error!\"}, "
"{\"detail\": \"This is another error!\"}]}") == 0);
MXS_FREE(s);

92
server/core/test/test_log.cc
View File

@ -44,7 +44,7 @@ int main(int argc, char* argv[])
succp = mxs_log_init(NULL, "/tmp", MXS_LOG_TARGET_FS);
ss_info_dassert(succp, "Log manager initialization failed");
mxb_assert_message(succp, "Log manager initialization failed");
t = time(NULL);
localtime_r(&t, &tm);
@ -58,55 +58,55 @@ int main(int argc, char* argv[])
logstr = ("First write with flush.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("Second write with flush.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("Third write, no flush.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("Fourth write, no flush. Next flush only.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "My name is %s %d years and %d months.";
err = MXS_INFO(logstr, "TraceyTracey", 3, 7);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "My name is Tracey Tracey 47 years and 7 months.";
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "My name is Stacey %s";
err = MXS_INFO(logstr, " ");
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "My name is Philip";
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "Philip.";
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = "Ph%dlip.";
err = MXS_INFO(logstr, 1);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("A terrible error has occurred!");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("Hi, how are you?");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("I'm doing fine!");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("Rather more surprising, at least at first sight, is the fact that a reference to "
"a[i] can also be written as *(a+i). In evaluating a[i], C converts it to *(a+i) "
@ -114,128 +114,128 @@ int main(int argc, char* argv[])
"of this equivalence, it follows that &a[i] and a+i are also identical: a+i is the "
"address of the i-th element beyond a.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("I was wondering, you know, it has been such a lovely weather whole morning and I "
"thought that would you like to come to my place and have a little piece of cheese "
"with us. Just me and my mom - and you, of course. Then, if you wish, we could "
"listen to the radio and keep company for our little Steven, my mom's cat, you know.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("\tTEST 3 - test enabling and disabling logs.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_disable(LOG_INFO);
logstr = ("1.\tWrite once to ERROR and twice to MESSAGE log.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_INFO);
logstr = ("2.\tWrite to once to ERROR, twice to MESSAGE and "
"three times to TRACE log.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_disable(LOG_ERR);
logstr = ("3.\tWrite to once to MESSAGE and twice to TRACE log.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_disable(LOG_NOTICE);
skygw_log_disable(LOG_INFO);
logstr = ("4.\tWrite to none.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_ERR);
skygw_log_enable(LOG_NOTICE);
logstr = ("4.\tWrite once to ERROR and twice to MESSAGE log.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_INFO);
logstr = ("\tTEST 4 - test spreading logs down to other logs.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("1.\tWrite to ERROR and thus also to MESSAGE and TRACE logs.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("2.\tWrite to MESSAGE and thus to TRACE logs.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_INFO);
logstr = ("3.\tWrite to TRACE log only.");
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_disable(LOG_NOTICE);
logstr = ("4.\tWrite to ERROR and thus also to TRACE log. "
"MESSAGE is disabled.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("5.\tThis should not appear anywhere since MESSAGE "
"is disabled.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_INFO);
logstr = ("6.\tWrite to ERROR and thus also to MESSAGE and TRACE logs.");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("7.\tWrite to MESSAGE and thus to TRACE logs.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("8.\tWrite to TRACE log only.");
skygw_log_enable(LOG_INFO);
err = MXS_INFO("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_disable(LOG_NOTICE);
logstr = ("9.\tWrite to ERROR and thus also to TRACE log. "
"MESSAGE is disabled");
err = MXS_ERROR("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
logstr = ("10.\tThis should not appear anywhere since MESSAGE is "
"disabled.");
err = MXS_NOTICE("%s", logstr);
ss_dassert(err == 0);
mxb_assert(err == 0);
skygw_log_enable(LOG_NOTICE);
@ -244,20 +244,20 @@ int main(int argc, char* argv[])
(int)3,
"foo",
(int)3);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("12.\tWrite to MESSAGE and TRACE log some "
"formattings "
": %d %s %d",
(int)3,
"foo",
(int)3);
ss_dassert(err == 0);
mxb_assert(err == 0);
err = MXS_ERROR("13.\tWrite to TRACE log some formattings "
": %d %s %d",
(int)3,
"foo",
(int)3);
ss_dassert(err == 0);
mxb_assert(err == 0);
mxs_log_finish();

2
server/core/test/test_logorder.cc
View File

@ -80,7 +80,7 @@ int main(int argc, char** argv)
{
fprintf(stderr, "Error, log manager initialization failed.\n");
}
ss_dassert(succp);
mxb_assert(succp);
skygw_log_disable(LOG_INFO);
skygw_log_disable(LOG_NOTICE);

256
server/core/test/test_modutil.cc
View File

@ -53,16 +53,16 @@ test1()
fprintf(stderr,
"testmodutil : Rudimentary tests.");
buffer = gwbuf_alloc(100);
ss_info_dassert(GWBUF_IS_CONTIGUOUS(buffer), "Allocated buffer should be continuos");
mxb_assert_message(GWBUF_IS_CONTIGUOUS(buffer), "Allocated buffer should be continuos");
memset(GWBUF_DATA(buffer), 0, GWBUF_LENGTH(buffer));
ss_info_dassert(0 == modutil_is_SQL(buffer), "Default buffer should be diagnosed as not SQL");
mxb_assert_message(0 == modutil_is_SQL(buffer), "Default buffer should be diagnosed as not SQL");
/* There would ideally be some straightforward way to create a SQL buffer? */
fprintf(stderr, "\t..done\nExtract SQL from buffer");
ss_info_dassert(0 == modutil_extract_SQL(buffer, &sql, &length), "Default buffer should fail");
mxb_assert_message(0 == modutil_extract_SQL(buffer, &sql, &length), "Default buffer should fail");
fprintf(stderr, "\t..done\nExtract SQL from buffer different way?");
ss_info_dassert(0 == modutil_MySQL_Query(buffer, &sql, &length, &residual), "Default buffer should fail");
mxb_assert_message(0 == modutil_MySQL_Query(buffer, &sql, &length, &residual), "Default buffer should fail");
fprintf(stderr, "\t..done\nReplace SQL in buffer");
ss_info_dassert(0 == modutil_replace_SQL(buffer, (char*)"select * from some_table;"),
mxb_assert_message(0 == modutil_replace_SQL(buffer, (char*)"select * from some_table;"),
"Default buffer should fail");
fprintf(stderr, "\t..done\nTidy up.");
gwbuf_free(buffer);
@ -81,7 +81,7 @@ test2()
/** Allocate space for the COM_QUERY header and payload */
buffer = gwbuf_alloc(5 + 128);
ss_info_dassert((buffer != NULL), "Buffer should not be null");
mxb_assert_message((buffer != NULL), "Buffer should not be null");
memset(query, ';', 128);
memset(query + 128, '\0', 1);
@ -92,7 +92,7 @@ test2()
*((unsigned char*)buffer->start + 4) = 0x03;
memcpy((uint8_t*)buffer->start + 5, query, strlen(query));
char* result = modutil_get_SQL(buffer);
ss_dassert(strcmp(result, query) == 0);
mxb_assert(strcmp(result, query) == 0);
gwbuf_free(buffer);
MXS_FREE(result);
fprintf(stderr, "\t..done\n");
@ -164,27 +164,27 @@ void test_single_sql_packet1()
/** Single packet */
GWBUF* buffer = gwbuf_alloc_and_load(sizeof(ok), ok);
GWBUF* complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL");
ss_info_dassert(complete, "Complete packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(complete) == sizeof(ok), "Complete packet buffer should contain enough data");
ss_info_dassert(memcmp(GWBUF_DATA(complete), ok, GWBUF_LENGTH(complete)) == 0,
mxb_assert_message(buffer == NULL, "Old buffer should be NULL");
mxb_assert_message(complete, "Complete packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(complete) == sizeof(ok), "Complete packet buffer should contain enough data");
mxb_assert_message(memcmp(GWBUF_DATA(complete), ok, GWBUF_LENGTH(complete)) == 0,
"Complete packet buffer's data should be equal to original data");
gwbuf_free(complete);
/** Partial single packet */
buffer = gwbuf_alloc_and_load(sizeof(ok) - 4, ok);
complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer, "Old buffer should be not NULL");
ss_info_dassert(complete == NULL, "Complete packet buffer should be NULL");
ss_info_dassert(gwbuf_length(buffer) == sizeof(ok) - 4, "Old buffer should contain right amount of data");
mxb_assert_message(buffer, "Old buffer should be not NULL");
mxb_assert_message(complete == NULL, "Complete packet buffer should be NULL");
mxb_assert_message(gwbuf_length(buffer) == sizeof(ok) - 4, "Old buffer should contain right amount of data");
/** Add the missing data */
buffer = gwbuf_append(buffer, gwbuf_alloc_and_load(4, ok + sizeof(ok) - 4));
complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL");
ss_info_dassert(complete, "Complete packet buffer should not be NULL");
ss_info_dassert(complete->next, "The complete packet should be a chain of buffers");
ss_info_dassert(gwbuf_length(complete) == sizeof(ok), "Buffer should contain all data");
mxb_assert_message(buffer == NULL, "Old buffer should be NULL");
mxb_assert_message(complete, "Complete packet buffer should not be NULL");
mxb_assert_message(complete->next, "The complete packet should be a chain of buffers");
mxb_assert_message(gwbuf_length(complete) == sizeof(ok), "Buffer should contain all data");
gwbuf_free(complete);
}
@ -194,11 +194,11 @@ void test_multiple_sql_packets1()
/** All of the data */
GWBUF* buffer = gwbuf_alloc_and_load(sizeof(resultset), resultset);
GWBUF* complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL");
ss_info_dassert(complete, "Complete packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(complete) == sizeof(resultset),
mxb_assert_message(buffer == NULL, "Old buffer should be NULL");
mxb_assert_message(complete, "Complete packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(complete) == sizeof(resultset),
"Complete packet buffer should contain enough data");
ss_info_dassert(memcmp(GWBUF_DATA(complete), resultset, GWBUF_LENGTH(complete)) == 0,
mxb_assert_message(memcmp(GWBUF_DATA(complete), resultset, GWBUF_LENGTH(complete)) == 0,
"Complete packet buffer's data should be equal to original data");
gwbuf_free(complete);
@ -206,18 +206,18 @@ void test_multiple_sql_packets1()
GWBUF* head = gwbuf_alloc_and_load(7, resultset);
GWBUF* tail = gwbuf_alloc_and_load(sizeof(resultset) - 7, resultset + 7);
complete = modutil_get_complete_packets(&head);
ss_info_dassert(head, "Old buffer should not be NULL");
ss_info_dassert(complete, "Complete buffer should not be NULL");
ss_info_dassert(gwbuf_length(complete) == 5, "Complete buffer should contain first packet only");
ss_info_dassert(gwbuf_length(head) == 2, "Complete buffer should contain first packet only");
mxb_assert_message(head, "Old buffer should not be NULL");
mxb_assert_message(complete, "Complete buffer should not be NULL");
mxb_assert_message(gwbuf_length(complete) == 5, "Complete buffer should contain first packet only");
mxb_assert_message(gwbuf_length(head) == 2, "Complete buffer should contain first packet only");
gwbuf_free(complete);
/** All packets are available */
head = gwbuf_append(head, tail);
complete = modutil_get_complete_packets(&head);
ss_info_dassert(head == NULL, "Old buffer should be NULL");
ss_info_dassert(complete, "Complete packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(complete) == sizeof(resultset) - 5,
mxb_assert_message(head == NULL, "Old buffer should be NULL");
mxb_assert_message(complete, "Complete packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(complete) == sizeof(resultset) - 5,
"Complete packet should be sizeof(resultset) - 5 bytes");
gwbuf_free(complete);
@ -230,12 +230,12 @@ void test_multiple_sql_packets1()
complete = modutil_get_complete_packets(&head);
int headlen = gwbuf_length(head);
int completelen = complete ? gwbuf_length(complete) : 0;
ss_info_dassert(headlen + completelen == sizeof(resultset),
mxb_assert_message(headlen + completelen == sizeof(resultset),
"Both buffers should sum up to sizeof(resutlset) bytes");
uint8_t databuf[sizeof(resultset)];
gwbuf_copy_data(complete, 0, completelen, databuf);
gwbuf_copy_data(head, 0, headlen, databuf + completelen);
ss_info_dassert(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
mxb_assert_message(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
gwbuf_free(head);
gwbuf_free(complete);
}
@ -253,48 +253,48 @@ void test_multiple_sql_packets1()
}
while (total < sizeof(resultset));
ss_info_dassert(gwbuf_length(head) == sizeof(resultset), "Head should be sizeof(resulset) bytes long");
mxb_assert_message(gwbuf_length(head) == sizeof(resultset), "Head should be sizeof(resulset) bytes long");
complete = modutil_get_complete_packets(&head);
ss_info_dassert(head == NULL, "Head should be NULL");
ss_info_dassert(complete, "Complete should not be NULL");
ss_info_dassert(gwbuf_length(complete) == sizeof(resultset),
mxb_assert_message(head == NULL, "Head should be NULL");
mxb_assert_message(complete, "Complete should not be NULL");
mxb_assert_message(gwbuf_length(complete) == sizeof(resultset),
"Complete should be sizeof(resulset) bytes long");
unsigned int headlen = gwbuf_length(head);
unsigned int completelen = complete ? gwbuf_length(complete) : 0;
uint8_t databuf[sizeof(resultset)];
ss_info_dassert(gwbuf_copy_data(complete, 0, completelen, databuf) == completelen,
mxb_assert_message(gwbuf_copy_data(complete, 0, completelen, databuf) == completelen,
"Expected data should be readable");
ss_info_dassert(gwbuf_copy_data(head, 0, headlen, databuf + completelen) == headlen,
mxb_assert_message(gwbuf_copy_data(head, 0, headlen, databuf + completelen) == headlen,
"Expected data should be readable");
ss_info_dassert(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
mxb_assert_message(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
/** Fragmented buffer split into multiple chains and then reassembled as a complete resultset */
GWBUF* half = complete;
GWBUF* quarter = gwbuf_split(&half, gwbuf_length(half) / 2);
head = gwbuf_split(&quarter, gwbuf_length(quarter) / 2);
ss_info_dassert(half && quarter && head, "gwbuf_split should work");
mxb_assert_message(half && quarter && head, "gwbuf_split should work");
complete = modutil_get_complete_packets(&head);
ss_info_dassert(complete && head, "Both buffers should have data");
ss_info_dassert(gwbuf_length(complete) + gwbuf_length(head) + gwbuf_length(quarter)
mxb_assert_message(complete && head, "Both buffers should have data");
mxb_assert_message(gwbuf_length(complete) + gwbuf_length(head) + gwbuf_length(quarter)
+ gwbuf_length(half) == sizeof(resultset), "25% of data should be available");
quarter = gwbuf_append(gwbuf_append(complete, head), quarter);
complete = modutil_get_complete_packets(&quarter);
ss_info_dassert(gwbuf_length(complete) + gwbuf_length(quarter) +
mxb_assert_message(gwbuf_length(complete) + gwbuf_length(quarter) +
gwbuf_length(half) == sizeof(resultset), "50% of data should be available");
half = gwbuf_append(gwbuf_append(complete, quarter), half);
complete = modutil_get_complete_packets(&half);
ss_info_dassert(complete, "Complete should not be NULL");
ss_info_dassert(half == NULL, "Old buffer should be NULL");
ss_info_dassert(gwbuf_length(complete) == sizeof(resultset), "Complete should contain 100% of data");
mxb_assert_message(complete, "Complete should not be NULL");
mxb_assert_message(half == NULL, "Old buffer should be NULL");
mxb_assert_message(gwbuf_length(complete) == sizeof(resultset), "Complete should contain 100% of data");
completelen = gwbuf_length(complete);
ss_info_dassert(gwbuf_copy_data(complete, 0, completelen, databuf) == completelen,
mxb_assert_message(gwbuf_copy_data(complete, 0, completelen, databuf) == completelen,
"All data should be readable");
ss_info_dassert(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
mxb_assert_message(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
gwbuf_free(complete);
}
@ -310,10 +310,10 @@ void test_single_sql_packet2()
buffer = gwbuf_alloc_and_load(sizeof(ok), ok);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL");
ss_info_dassert(next, "Next packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(next) == sizeof(ok), "Next packet buffer should contain enough data");
ss_info_dassert(memcmp(GWBUF_DATA(next), ok, GWBUF_LENGTH(next)) == 0,
mxb_assert_message(buffer == NULL, "Old buffer should be NULL");
mxb_assert_message(next, "Next packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(next) == sizeof(ok), "Next packet buffer should contain enough data");
mxb_assert_message(memcmp(GWBUF_DATA(next), ok, GWBUF_LENGTH(next)) == 0,
"Next packet buffer's data should be equal to original data");
gwbuf_free(buffer);
gwbuf_free(next);
@ -321,18 +321,18 @@ void test_single_sql_packet2()
/** Partial single packet */
buffer = gwbuf_alloc_and_load(sizeof(ok) - 4, ok);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should be not NULL");
ss_info_dassert(next == NULL, "Next packet buffer should be NULL");
ss_info_dassert(gwbuf_length(buffer) == sizeof(ok) - 4, "Old buffer should contain right amount of data");
mxb_assert_message(buffer, "Old buffer should be not NULL");
mxb_assert_message(next == NULL, "Next packet buffer should be NULL");
mxb_assert_message(gwbuf_length(buffer) == sizeof(ok) - 4, "Old buffer should contain right amount of data");
/** Add the missing data */
buffer = gwbuf_append(buffer, gwbuf_alloc_and_load(4, ok + sizeof(ok) - 4));
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL");
ss_info_dassert(next, "Next packet buffer should not be NULL");
mxb_assert_message(buffer == NULL, "Old buffer should be NULL");
mxb_assert_message(next, "Next packet buffer should not be NULL");
//To be put back when the current realloc behaviour is replaced with splitting behaviour.
//ss_info_dassert(next->next, "The next packet should be a chain of buffers");
ss_info_dassert(gwbuf_length(next) == sizeof(ok), "Buffer should contain all data");
//mxb_assert_message(next->next, "The next packet should be a chain of buffers");
mxb_assert_message(gwbuf_length(next) == sizeof(ok), "Buffer should contain all data");
gwbuf_free(next);
}
@ -348,38 +348,38 @@ void test_multiple_sql_packets2()
for (unsigned int i = 0; i < N_PACKETS; i++)
{
GWBUF* next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(next, "Next packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(next) == packets[i].length,
mxb_assert_message(next, "Next packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(next) == packets[i].length,
"Next packet buffer should contain enough data");
ss_info_dassert(memcmp(GWBUF_DATA(next), &resultset[packets[i].index], GWBUF_LENGTH(next)) == 0,
mxb_assert_message(memcmp(GWBUF_DATA(next), &resultset[packets[i].index], GWBUF_LENGTH(next)) == 0,
"Next packet buffer's data should be equal to original data");
gwbuf_free(next);
}
ss_info_dassert(buffer == NULL, "Buffer should be NULL");
mxb_assert_message(buffer == NULL, "Buffer should be NULL");
size_t len;
// Exactly one packet
len = PACKET_1_LEN;
buffer = gwbuf_alloc_and_load(len, resultset);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer == NULL, "Old buffer should be NULL.");
ss_info_dassert(next, "Next should not be NULL.");
ss_info_dassert(GWBUF_LENGTH(next) == PACKET_1_LEN, "Length should match.");
mxb_assert_message(buffer == NULL, "Old buffer should be NULL.");
mxb_assert_message(next, "Next should not be NULL.");
mxb_assert_message(GWBUF_LENGTH(next) == PACKET_1_LEN, "Length should match.");
gwbuf_free(next);
// Slightly less than one packet
len = PACKET_1_LEN - 1;
buffer = gwbuf_alloc_and_load(len, resultset);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should not be NULL.");
ss_info_dassert(next == NULL, "Next should be NULL.");
mxb_assert_message(buffer, "Old buffer should not be NULL.");
mxb_assert_message(next == NULL, "Next should be NULL.");
GWBUF *tail = gwbuf_alloc_and_load(sizeof(resultset) - len, resultset + len);
buffer = gwbuf_append(buffer, tail);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should not be NULL.");
ss_info_dassert(next, "Next should not be NULL.");
ss_info_dassert(gwbuf_length(next) == PACKET_1_LEN, "Length should match.");
mxb_assert_message(buffer, "Old buffer should not be NULL.");
mxb_assert_message(next, "Next should not be NULL.");
mxb_assert_message(gwbuf_length(next) == PACKET_1_LEN, "Length should match.");
gwbuf_free(buffer);
gwbuf_free(next);
@ -387,22 +387,22 @@ void test_multiple_sql_packets2()
len = PACKET_1_LEN + 1;
buffer = gwbuf_alloc_and_load(len, resultset);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should not be NULL.");
ss_info_dassert(next, "Next should not be NULL.");
ss_info_dassert(GWBUF_LENGTH(next) == PACKET_1_LEN, "Length should match.");
mxb_assert_message(buffer, "Old buffer should not be NULL.");
mxb_assert_message(next, "Next should not be NULL.");
mxb_assert_message(GWBUF_LENGTH(next) == PACKET_1_LEN, "Length should match.");
gwbuf_free(next);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should not be NULL.");
ss_info_dassert(next == NULL, "Next should be NULL.");
mxb_assert_message(buffer, "Old buffer should not be NULL.");
mxb_assert_message(next == NULL, "Next should be NULL.");
tail = gwbuf_alloc_and_load(sizeof(resultset) - len, resultset + len);
buffer = gwbuf_append(buffer, tail);
next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(buffer, "Old buffer should not be NULL.");
ss_info_dassert(next, "Next should not be NULL.");
ss_info_dassert(gwbuf_length(next) == PACKET_2_LEN, "Length should match.");
ss_info_dassert(memcmp(GWBUF_DATA(next), &resultset[PACKET_2_IDX], GWBUF_LENGTH(next)) == 0,
mxb_assert_message(buffer, "Old buffer should not be NULL.");
mxb_assert_message(next, "Next should not be NULL.");
mxb_assert_message(gwbuf_length(next) == PACKET_2_LEN, "Length should match.");
mxb_assert_message(memcmp(GWBUF_DATA(next), &resultset[PACKET_2_IDX], GWBUF_LENGTH(next)) == 0,
"Next packet buffer's data should be equal to original data");
gwbuf_free(buffer);
gwbuf_free(next);
@ -417,12 +417,12 @@ void test_multiple_sql_packets2()
next = modutil_get_next_MySQL_packet(&head);
int headlen = gwbuf_length(head);
int nextlen = next ? gwbuf_length(next) : 0;
ss_info_dassert(headlen + nextlen == sizeof(resultset),
mxb_assert_message(headlen + nextlen == sizeof(resultset),
"Both buffers should sum up to sizeof(resutlset) bytes");
uint8_t databuf[sizeof(resultset)];
gwbuf_copy_data(next, 0, nextlen, databuf);
gwbuf_copy_data(head, 0, headlen, databuf + nextlen);
ss_info_dassert(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
mxb_assert_message(memcmp(databuf, resultset, sizeof(resultset)) == 0, "Data should be OK");
gwbuf_free(head);
gwbuf_free(next);
}
@ -443,37 +443,37 @@ void test_multiple_sql_packets2()
for (unsigned int i = 0; i < N_PACKETS; i++)
{
GWBUF* next = modutil_get_next_MySQL_packet(&buffer);
ss_info_dassert(next, "Next packet buffer should not be NULL");
ss_info_dassert(gwbuf_length(next) == packets[i].length,
mxb_assert_message(next, "Next packet buffer should not be NULL");
mxb_assert_message(gwbuf_length(next) == packets[i].length,
"Next packet buffer should contain enough data");
next = gwbuf_make_contiguous(next);
ss_info_dassert(memcmp(GWBUF_DATA(next), &resultset[packets[i].index], GWBUF_LENGTH(next)) == 0,
mxb_assert_message(memcmp(GWBUF_DATA(next), &resultset[packets[i].index], GWBUF_LENGTH(next)) == 0,
"Next packet buffer's data should be equal to original data");
gwbuf_free(next);
}
ss_info_dassert(buffer == NULL, "Buffer should be NULL");
mxb_assert_message(buffer == NULL, "Buffer should be NULL");
}
void test_strnchr_esc_mysql()
{
char comment1[] = "This will -- fail.";
ss_info_dassert(strnchr_esc_mysql(comment1, '.', sizeof(comment1) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(comment1, '.', sizeof(comment1) - 1) == NULL,
"Commented character should return NULL");
char comment2[] = "This will # fail.";
ss_info_dassert(strnchr_esc_mysql(comment2, '.', sizeof(comment2) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(comment2, '.', sizeof(comment2) - 1) == NULL,
"Commented character should return NULL");
char comment3[] = "This will fail/* . */";
ss_info_dassert(strnchr_esc_mysql(comment3, '.', sizeof(comment3) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(comment3, '.', sizeof(comment3) - 1) == NULL,
"Commented character should return NULL");
char comment4[] = "This will not /* . */ fail.";
ss_info_dassert(strnchr_esc_mysql(comment4, '.', sizeof(comment4) - 1) == strrchr(comment4, '.'),
mxb_assert_message(strnchr_esc_mysql(comment4, '.', sizeof(comment4) - 1) == strrchr(comment4, '.'),
"Uncommented character should be matched");
char comment5[] = "This will fail/* . ";
ss_info_dassert(strnchr_esc_mysql(comment5, '.', sizeof(comment5) - 1) == NULL, "Bad comment should fail");
mxb_assert_message(strnchr_esc_mysql(comment5, '.', sizeof(comment5) - 1) == NULL, "Bad comment should fail");
}
@ -481,56 +481,56 @@ void test_strnchr_esc()
{
/** Single escaped and quoted characters */
char esc1[] = "This will fail\\.";
ss_info_dassert(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
ss_info_dassert(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
char esc2[] = "This will fail\".\"";
ss_info_dassert(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
ss_info_dassert(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
char esc3[] = "This will fail'.'";
ss_info_dassert(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
ss_info_dassert(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
mxb_assert_message(strnchr_esc_mysql(esc1, '.', sizeof(esc1) - 1) == NULL,
"Only escaped character should return NULL");
/** Test escaped and quoted characters */
char str1[] = "this \\. is a test.";
ss_info_dassert(strnchr_esc(str1, '.', sizeof(str1) - 1) == strrchr(str1, '.'),
mxb_assert_message(strnchr_esc(str1, '.', sizeof(str1) - 1) == strrchr(str1, '.'),
"Escaped characters should be ignored");
ss_info_dassert(strnchr_esc_mysql(str1, '.', sizeof(str1) - 1) == strrchr(str1, '.'),
mxb_assert_message(strnchr_esc_mysql(str1, '.', sizeof(str1) - 1) == strrchr(str1, '.'),
"Escaped characters should be ignored");
char str2[] = "this \"is . \" a test .";
ss_info_dassert(strnchr_esc(str2, '.', sizeof(str2) - 1) == strrchr(str2, '.'),
mxb_assert_message(strnchr_esc(str2, '.', sizeof(str2) - 1) == strrchr(str2, '.'),
"Double quoted characters should be ignored");
ss_info_dassert(strnchr_esc_mysql(str2, '.', sizeof(str2) - 1) == strrchr(str2, '.'),
mxb_assert_message(strnchr_esc_mysql(str2, '.', sizeof(str2) - 1) == strrchr(str2, '.'),
"Double quoted characters should be ignored");
char str3[] = "this 'is . ' a test .";
ss_info_dassert(strnchr_esc(str3, '.', sizeof(str3) - 1) == strrchr(str3, '.'),
mxb_assert_message(strnchr_esc(str3, '.', sizeof(str3) - 1) == strrchr(str3, '.'),
"Double quoted characters should be ignored");
ss_info_dassert(strnchr_esc_mysql(str3, '.', sizeof(str3) - 1) == strrchr(str3, '.'),
mxb_assert_message(strnchr_esc_mysql(str3, '.', sizeof(str3) - 1) == strrchr(str3, '.'),
"Double quoted characters should be ignored");
/** Bad quotation tests */
char bad1[] = "This will \" fail.";
ss_info_dassert(strnchr_esc(bad1, '.', sizeof(bad1) - 1) == NULL, "Bad quotation should fail");
ss_info_dassert(strnchr_esc_mysql(bad1, '.', sizeof(bad1) - 1) == NULL, "Bad quotation should fail");
mxb_assert_message(strnchr_esc(bad1, '.', sizeof(bad1) - 1) == NULL, "Bad quotation should fail");
mxb_assert_message(strnchr_esc_mysql(bad1, '.', sizeof(bad1) - 1) == NULL, "Bad quotation should fail");
char bad2[] = "This will ' fail.";
ss_info_dassert(strnchr_esc(bad2, '.', sizeof(bad2) - 1) == NULL, "Bad quotation should fail");
ss_info_dassert(strnchr_esc_mysql(bad2, '.', sizeof(bad2) - 1) == NULL, "Bad quotation should fail");
mxb_assert_message(strnchr_esc(bad2, '.', sizeof(bad2) - 1) == NULL, "Bad quotation should fail");
mxb_assert_message(strnchr_esc_mysql(bad2, '.', sizeof(bad2) - 1) == NULL, "Bad quotation should fail");
char bad3[] = "This will \" fail. '";
ss_info_dassert(strnchr_esc(bad3, '.', sizeof(bad3) - 1) == NULL, "Different quote pairs should fail");
ss_info_dassert(strnchr_esc_mysql(bad3, '.', sizeof(bad3) - 1) == NULL, "Different quote pairs should fail");
mxb_assert_message(strnchr_esc(bad3, '.', sizeof(bad3) - 1) == NULL, "Different quote pairs should fail");
mxb_assert_message(strnchr_esc_mysql(bad3, '.', sizeof(bad3) - 1) == NULL, "Different quote pairs should fail");
char bad4[] = "This will ' fail. \"";
ss_info_dassert(strnchr_esc(bad4, '.', sizeof(bad4) - 1) == NULL, "Different quote pairs should fail");
ss_info_dassert(strnchr_esc_mysql(bad4, '.', sizeof(bad4) - 1) == NULL, "Different quote pairs should fail");
mxb_assert_message(strnchr_esc(bad4, '.', sizeof(bad4) - 1) == NULL, "Different quote pairs should fail");
mxb_assert_message(strnchr_esc_mysql(bad4, '.', sizeof(bad4) - 1) == NULL, "Different quote pairs should fail");
}
GWBUF* create_buffer(size_t size)
@ -560,9 +560,9 @@ void test_large_packets()
size_t before = gwbuf_length(buffer);
GWBUF* complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer == NULL, "Original buffer should be NULL");
ss_info_dassert(complete, "Complete buffer should not be NULL");
ss_info_dassert(gwbuf_length(complete) == before, "Complete buffer should contain all data");
mxb_assert_message(buffer == NULL, "Original buffer should be NULL");
mxb_assert_message(complete, "Complete buffer should not be NULL");
mxb_assert_message(gwbuf_length(complete) == before, "Complete buffer should contain all data");
gwbuf_free(complete);
}
@ -572,8 +572,8 @@ void test_large_packets()
GWBUF* buffer = create_buffer(0x00ffffff - i);
buffer = gwbuf_rtrim(buffer, 4);
GWBUF* complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer, "Incomplete buffer is not NULL");
ss_info_dassert(complete == NULL, "The complete buffer is NULL");
mxb_assert_message(buffer, "Incomplete buffer is not NULL");
mxb_assert_message(complete == NULL, "The complete buffer is NULL");
gwbuf_free(buffer);
}
@ -581,12 +581,12 @@ void test_large_packets()
for (int i = 2; i < 8; i++)
{
GWBUF* buffer = gwbuf_append(create_buffer(0x00ffffff), create_buffer(i));
ss_dassert(gwbuf_length(buffer) == 0xffffffUL + i + 8);
mxb_assert(gwbuf_length(buffer) == 0xffffffUL + i + 8);
GWBUF_RTRIM(buffer->next, 1)
GWBUF* complete = modutil_get_complete_packets(&buffer);
ss_info_dassert(buffer, "Incomplete buffer is not NULL");
ss_info_dassert(complete, "The complete buffer is not NULL");
ss_info_dassert(gwbuf_length(complete) == 0xffffff + 4, "Length should be correct");
mxb_assert_message(buffer, "Incomplete buffer is not NULL");
mxb_assert_message(complete, "The complete buffer is not NULL");
mxb_assert_message(gwbuf_length(complete) == 0xffffff + 4, "Length should be correct");
gwbuf_free(buffer);
gwbuf_free(complete);
}
@ -602,31 +602,31 @@ void test_bypass_whitespace()
char* sql;
sql = bypass_whitespace("SELECT");
ss_info_dassert(*sql == 'S', "1");
mxb_assert_message(*sql == 'S', "1");
sql = bypass_whitespace(" SELECT");
ss_info_dassert(*sql == 'S', "2");
mxb_assert_message(*sql == 'S', "2");
sql = bypass_whitespace("\tSELECT");
ss_info_dassert(*sql == 'S', "3");
mxb_assert_message(*sql == 'S', "3");
sql = bypass_whitespace("\nSELECT");
ss_info_dassert(*sql == 'S', "4");
mxb_assert_message(*sql == 'S', "4");
sql = bypass_whitespace("/* comment */SELECT");
ss_info_dassert(*sql == 'S', "5");
mxb_assert_message(*sql == 'S', "5");
sql = bypass_whitespace(" /* comment */ SELECT");
ss_info_dassert(*sql == 'S', "6");
mxb_assert_message(*sql == 'S', "6");
sql = bypass_whitespace("-- comment\nSELECT");
ss_info_dassert(*sql == 'S', "7");
mxb_assert_message(*sql == 'S', "7");
sql = bypass_whitespace("-- comment\n /* comment */ SELECT");
ss_info_dassert(*sql == 'S', "8");
mxb_assert_message(*sql == 'S', "8");
sql = bypass_whitespace("# comment\nSELECT");
ss_info_dassert(*sql == 'S', "9");
mxb_assert_message(*sql == 'S', "9");
}
int main(int argc, char **argv)

18
server/core/test/test_server.cc
View File

@ -66,32 +66,32 @@ test1()
/* Server tests */
fprintf(stderr, "testserver : creating server called MyServer");
server = server_alloc("uniquename", params.params());
ss_info_dassert(server, "Allocating the server should not fail");
mxb_assert_message(server, "Allocating the server should not fail");
char buf[120];
fprintf(stderr, "\t..done\nTest Parameter for Server.");
ss_info_dassert(!server_get_parameter(server, "name", buf, sizeof(buf)), "Parameter should be null when not set");
mxb_assert_message(!server_get_parameter(server, "name", buf, sizeof(buf)), "Parameter should be null when not set");
server_add_parameter(server, "name", "value");
ss_dassert(server_get_parameter(server, "name", buf, sizeof(buf)));
ss_info_dassert(strcmp("value", buf) == 0, "Parameter should be returned correctly");
mxb_assert(server_get_parameter(server, "name", buf, sizeof(buf)));
mxb_assert_message(strcmp("value", buf) == 0, "Parameter should be returned correctly");
fprintf(stderr, "\t..done\nTesting Unique Name for Server.");
ss_info_dassert(NULL == server_find_by_unique_name("non-existent"),
mxb_assert_message(NULL == server_find_by_unique_name("non-existent"),
"Should not find non-existent unique name.");
ss_info_dassert(server == server_find_by_unique_name("uniquename"), "Should find by unique name.");
mxb_assert_message(server == server_find_by_unique_name("uniquename"), "Should find by unique name.");
fprintf(stderr, "\t..done\nTesting Status Setting for Server.");
status = server_status(server);
ss_info_dassert(0 == strcmp("Running", status), "Status of Server should be Running by default.");
mxb_assert_message(0 == strcmp("Running", status), "Status of Server should be Running by default.");
if (NULL != status)
{
MXS_FREE(status);
}
server_set_status_nolock(server, SERVER_MASTER);
status = server_status(server);
ss_info_dassert(0 == strcmp("Master, Running", status), "Should find correct status.");
mxb_assert_message(0 == strcmp("Master, Running", status), "Should find correct status.");
server_clear_status_nolock(server, SERVER_MASTER);
MXS_FREE(status);
status = server_status(server);
ss_info_dassert(0 == strcmp("Running", status),
mxb_assert_message(0 == strcmp("Running", status),
"Status of Server should be Running after master status cleared.");
if (NULL != status)
{

14
server/core/test/test_service.cc
View File

@ -66,19 +66,19 @@ test1()
fprintf(stderr,
"testservice : creating service called MyService with router nonexistent");
service = service_alloc("MyService", "non-existent", NULL);
ss_info_dassert(NULL == service, "New service with invalid router should be null");
ss_info_dassert(0 == service_isvalid(service), "Service must not be valid after incorrect creation");
mxb_assert_message(NULL == service, "New service with invalid router should be null");
mxb_assert_message(0 == service_isvalid(service), "Service must not be valid after incorrect creation");
fprintf(stderr, "\t..done\nValid service creation, router testroute.");
service = service_alloc("MyService", "readconnroute", NULL);
ss_info_dassert(NULL != service, "New service with valid router must not be null");
ss_info_dassert(0 != service_isvalid(service), "Service must be valid after creation");
ss_info_dassert(0 == strcmp("MyService", service->name), "Service must have given name");
mxb_assert_message(NULL != service, "New service with valid router must not be null");
mxb_assert_message(0 != service_isvalid(service), "Service must be valid after creation");
mxb_assert_message(0 == strcmp("MyService", service->name), "Service must have given name");
fprintf(stderr, "\t..done\nAdding protocol testprotocol.");
ss_info_dassert(serviceCreateListener(service, "TestProtocol", "mariadbclient",
mxb_assert_message(serviceCreateListener(service, "TestProtocol", "mariadbclient",
"localhost", 9876, "MySQLAuth", NULL, NULL),
"Add Protocol should succeed");
ss_info_dassert(0 != serviceHasListener(service, "TestProtocol", "mariadbclient", "localhost", 9876),
mxb_assert_message(0 != serviceHasListener(service, "TestProtocol", "mariadbclient", "localhost", 9876),
"Service should have new protocol as requested");
return 0;

22
server/core/test/test_session_track.cc
View File

@ -174,44 +174,44 @@ void test1()
//BEGIN
buffer = gwbuf_alloc_and_load(PACKET_1_LEN, resultset1 + PACKET_1_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "T_______", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "T_______", 8) == 0);
gwbuf_free(buffer);
//COMMIT
buffer = gwbuf_alloc_and_load(PACKET_2_LEN, resultset1 + PACKET_2_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "________", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "________", 8) == 0);
gwbuf_free(buffer);
//START TRANSACTION
buffer = gwbuf_alloc_and_load(PACKET_3_LEN, resultset1 + PACKET_3_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "T_______", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "T_______", 8) == 0);
gwbuf_free(buffer);
//START TRANSACTION READ ONLY
buffer = gwbuf_alloc_and_load(PACKET_4_LEN, resultset1 + PACKET_4_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_characteristics"),
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_characteristics"),
"START TRANSACTION READ ONLY;", 28) == 0);
gwbuf_free(buffer);
//COMMIT
buffer = gwbuf_alloc_and_load(PACKET_5_LEN, resultset1 + PACKET_5_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(gwbuf_get_property(buffer, (char *)"trx_characteristics") == NULL);
ss_dassert(gwbuf_get_property(buffer, (char *)"trx_state") == NULL);
mxb_assert(gwbuf_get_property(buffer, (char *)"trx_characteristics") == NULL);
mxb_assert(gwbuf_get_property(buffer, (char *)"trx_state") == NULL);
gwbuf_free(buffer);
//SET AUTOCOMMIT=0;
buffer = gwbuf_alloc_and_load(PACKET_6_LEN, resultset1 + PACKET_6_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"autocommit"), "OFF", 3) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"autocommit"), "OFF", 3) == 0);
gwbuf_free(buffer);
//INSERT INTO t1 VALUES(1);
buffer = gwbuf_alloc_and_load(PACKET_7_LEN, resultset1 + PACKET_7_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I___W___", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I___W___", 8) == 0);
gwbuf_free(buffer);
//COMMIT
buffer = gwbuf_alloc_and_load(PACKET_8_LEN, resultset1 + PACKET_8_IDX);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "________", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "________", 8) == 0);
gwbuf_free(buffer);
}
@ -224,7 +224,7 @@ void test2()
proto.num_eof_packets = 0;
buffer = gwbuf_alloc_and_load(sizeof(resultset2), resultset2);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I_R_W___", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I_R_W___", 8) == 0);
gwbuf_free(buffer);
}
@ -236,7 +236,7 @@ void test3()
fprintf(stderr, "test_session_track: protocol state test\n");
buffer = gwbuf_alloc_and_load(sizeof(resultset2), resultset2);
mxs_mysql_get_session_track_info(buffer, &proto);
ss_dassert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I_R_W___", 8) == 0);
mxb_assert(strncmp(gwbuf_get_property(buffer, (char *)"trx_state"), "I_R_W___", 8) == 0);
gwbuf_free(buffer);
}

2
server/core/test/test_trxcompare.cc
View File

@ -204,7 +204,7 @@ int main(int argc, char* argv[])
}
else
{
ss_dassert(n == 2);
mxb_assert(n == 2);
ifstream in(argv[argc - 1]);

18
server/core/test/test_users.cc
View File

@ -45,31 +45,31 @@ static int test1()
fprintf(stderr,
"testusers : Initialise the user table.");
users = users_alloc();
ss_info_dassert(NULL != users, "Allocating user table should not return NULL.");
mxb_assert_message(NULL != users, "Allocating user table should not return NULL.");
fprintf(stderr, "\t..done\nAdd a user");
rv = users_add(users, "username", "authorisation", USER_ACCOUNT_ADMIN);
ss_info_dassert(rv, "Should add one user");
mxb_assert_message(rv, "Should add one user");
rv = users_auth(users, "username", "authorisation");
ss_info_dassert(rv, "Fetch valid user must not return NULL");
mxb_assert_message(rv, "Fetch valid user must not return NULL");
rv = users_auth(users, "username", "newauth");
ss_info_dassert(rv == 0, "Fetch invalid user must return NULL");
mxb_assert_message(rv == 0, "Fetch invalid user must return NULL");
fprintf(stderr, "\t..done\nAdd another user");
rv = users_add(users, "username2", "authorisation2", USER_ACCOUNT_ADMIN);
ss_info_dassert(rv, "Should add one user");
mxb_assert_message(rv, "Should add one user");
fprintf(stderr, "\t..done\nDelete a user.");
rv = users_delete(users, "username");
ss_info_dassert(rv, "Should delete just one user");
mxb_assert_message(rv, "Should delete just one user");
fprintf(stderr, "\t..done\nDump users table.");
json_t* dump = users_to_json(users);
ss_info_dassert(dump, "Users should be dumped");
mxb_assert_message(dump, "Users should be dumped");
USERS* loaded_users = users_from_json(dump);
ss_info_dassert(dump, "Users should be loaded");
mxb_assert_message(dump, "Users should be loaded");
json_decref(dump);
rv = users_auth(loaded_users, "username2", "authorisation2");
users_free(loaded_users);
ss_info_dassert(rv, "Loaded users should contain users");
mxb_assert_message(rv, "Loaded users should contain users");
fprintf(stderr, "\t..done\nFree user table.");
users_free(users);

18
server/core/test/test_utils.cc
View File

@ -134,34 +134,34 @@ int test_checksums()
sum1.update(d1);
sum1.finalize();
sum2.finalize(d1);
ss_dassert(sum1 == sum2);
mxb_assert(sum1 == sum2);
sum1.reset();
sum2.reset();
// Check that the hex strings match
ss_dassert(sum1.hex() == sum2.hex());
mxb_assert(sum1.hex() == sum2.hex());
std::string saved = sum1.hex();
// The checksum must not be empty
ss_dassert(!saved.empty());
mxb_assert(!saved.empty());
// Repeat the same test, should produce the same checksums
sum1.update(d1);
sum1.finalize();
sum2.finalize(d1);
ss_dassert(sum1 == sum2);
ss_dassert(sum1.hex() == saved);
ss_dassert(sum2.hex() == saved);
mxb_assert(sum1 == sum2);
mxb_assert(sum1.hex() == saved);
mxb_assert(sum2.hex() == saved);
sum1.reset();
sum2.reset();
// Check that different buffers but same content produce the same checksum
sum1.finalize(d2);
sum2.finalize(d1);
ss_dassert(sum1 == sum2);
ss_dassert(sum1.hex() == saved);
ss_dassert(sum2.hex() == saved);
mxb_assert(sum1 == sum2);
mxb_assert(sum1.hex() == saved);
mxb_assert(sum2.hex() == saved);
gwbuf_free(d1);
gwbuf_free(d2);