diff options
Diffstat (limited to 'unittest')
| -rw-r--r-- | unittest/examples/CMakeLists.txt | 23 | ||||
| -rw-r--r-- | unittest/examples/no_plan-t.c | 2 | ||||
| -rw-r--r-- | unittest/examples/skip-t.c | 3 | ||||
| -rw-r--r-- | unittest/examples/skip_all-t.c | 3 | ||||
| -rw-r--r-- | unittest/examples/todo-t.c | 3 | ||||
| -rw-r--r-- | unittest/mysys/CMakeLists.txt | 19 | ||||
| -rw-r--r-- | unittest/mysys/base64-t.c | 6 | ||||
| -rw-r--r-- | unittest/mysys/bitmap-t.c | 24 | ||||
| -rw-r--r-- | unittest/mysys/ma_dyncol-t.c | 795 | ||||
| -rw-r--r-- | unittest/mysys/my_malloc-t.c | 5 | ||||
| -rw-r--r-- | unittest/mysys/thr_template.c | 10 | ||||
| -rw-r--r-- | unittest/mysys/waiting_threads-t.c | 291 | ||||
| -rw-r--r-- | unittest/mytap/CMakeLists.txt | 4 | ||||
| -rw-r--r-- | unittest/mytap/t/basic-t.c | 3 | ||||
| -rw-r--r-- | unittest/mytap/tap.c | 92 | ||||
| -rw-r--r-- | unittest/mytap/tap.h | 6 | ||||
| -rw-r--r-- | unittest/strings/CMakeLists.txt | 3 | ||||
| -rw-r--r-- | unittest/strings/strings-t.c | 4 | ||||
| -rw-r--r-- | unittest/unit.pl | 5 |
19 files changed, 1231 insertions, 70 deletions
diff --git a/unittest/examples/CMakeLists.txt b/unittest/examples/CMakeLists.txt index 52272bc412e..86c4a5bea9e 100644 --- a/unittest/examples/CMakeLists.txt +++ b/unittest/examples/CMakeLists.txt @@ -13,25 +13,4 @@ # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include ${CMAKE_SOURCE_DIR}/zlib - ${CMAKE_SOURCE_DIR}/sql - ${CMAKE_SOURCE_DIR}/regex - ${CMAKE_SOURCE_DIR}/extra/yassl/include - ${CMAKE_SOURCE_DIR}/unittest/mytap) -ADD_EXECUTABLE(simple-t simple-t.c) -TARGET_LINK_LIBRARIES(simple-t mytap) - -ADD_EXECUTABLE(skip-t skip-t.c) -TARGET_LINK_LIBRARIES(skip-t mytap) - -ADD_EXECUTABLE(todo-t todo-t.c) -TARGET_LINK_LIBRARIES(todo-t mytap) - -ADD_EXECUTABLE(skip_all-t skip_all-t.c) -TARGET_LINK_LIBRARIES(skip_all-t mytap) - -ADD_EXECUTABLE(no_plan-t no_plan-t.c) -TARGET_LINK_LIBRARIES(no_plan-t mytap) - -ADD_EXECUTABLE(core-t core-t.c) -TARGET_LINK_LIBRARIES(core-t mytap) +MY_ADD_TESTS(simple skip todo skip_all no_plan) diff --git a/unittest/examples/no_plan-t.c b/unittest/examples/no_plan-t.c index 9aeb5c7666a..b795b2ca655 100644 --- a/unittest/examples/no_plan-t.c +++ b/unittest/examples/no_plan-t.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. +/* Copyright (c) 2006, 2010, Oracle and/or its affiliates This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by diff --git a/unittest/examples/skip-t.c b/unittest/examples/skip-t.c index aa105385c17..4b1115e50f3 100644 --- a/unittest/examples/skip-t.c +++ b/unittest/examples/skip-t.c @@ -1,4 +1,5 @@ -/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. +/* + Copyright (c) 2006, 2010, Oracle and/or its affiliates This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by diff --git a/unittest/examples/skip_all-t.c b/unittest/examples/skip_all-t.c index 940d9f0186f..9d31e0c3af8 100644 --- a/unittest/examples/skip_all-t.c +++ b/unittest/examples/skip_all-t.c @@ -1,4 +1,5 @@ -/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. +/* + Copyright (c) 2006, 2010, Oracle and/or its affiliates This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by diff --git a/unittest/examples/todo-t.c b/unittest/examples/todo-t.c index 53aaa1c2813..e1be2e8eacd 100644 --- a/unittest/examples/todo-t.c +++ b/unittest/examples/todo-t.c @@ -1,4 +1,5 @@ -/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. +/* + Copyright (c) 2006, 2010, Oracle and/or its affiliates This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by diff --git a/unittest/mysys/CMakeLists.txt b/unittest/mysys/CMakeLists.txt index 7bf046162c5..1de1bd19143 100644 --- a/unittest/mysys/CMakeLists.txt +++ b/unittest/mysys/CMakeLists.txt @@ -13,20 +13,9 @@ # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include - ${CMAKE_SOURCE_DIR}/sql +INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/sql ${CMAKE_SOURCE_DIR}/regex - ${CMAKE_SOURCE_DIR}/extra/yassl/include - ${CMAKE_SOURCE_DIR}/unittest/mytap) + ${CMAKE_SOURCE_DIR}/extra/yassl/include) - -MACRO (MY_ADD_TEST name) - ADD_EXECUTABLE(${name}-t ${name}-t.c) - TARGET_LINK_LIBRARIES(${name}-t mytap mysys strings) - ADD_TEST(${name} ${name}-t) -ENDMACRO() - - -FOREACH(testname bitmap base64 my_vsnprintf my_atomic my_rdtsc lf my_malloc) - MY_ADD_TEST(${testname}) -ENDFOREACH() +MY_ADD_TESTS(bitmap base64 my_vsnprintf my_atomic my_rdtsc lf my_malloc + LINK_LIBRARIES mysys) diff --git a/unittest/mysys/base64-t.c b/unittest/mysys/base64-t.c index c01d7cfdfa6..a8a5d166a1a 100644 --- a/unittest/mysys/base64-t.c +++ b/unittest/mysys/base64-t.c @@ -24,11 +24,11 @@ #define BASE64_ROWS 4 /* Number of ok(..) */ int -main(void) +main(int argc,char *argv[]) { int i, cmp; size_t j, k, l, dst_len, needed_length; - MY_INIT("base64-t"); + MY_INIT(argv[0]); plan(BASE64_LOOP_COUNT * BASE64_ROWS); @@ -67,6 +67,7 @@ main(void) ok(cmp == 0, "Comparing encode-decode result"); if (cmp != 0) { + /* FIXME: This only prints last value of the compared strings */ char buf[80]; diag(" --------- src --------- --------- dst ---------"); for (k= 0; k<src_len; k+=8) @@ -91,5 +92,6 @@ main(void) (uint) src_len, (uint) dst_len); } } + my_end(0); return exit_status(); } diff --git a/unittest/mysys/bitmap-t.c b/unittest/mysys/bitmap-t.c index a7bbd663598..bcfb9835c10 100644 --- a/unittest/mysys/bitmap-t.c +++ b/unittest/mysys/bitmap-t.c @@ -1,5 +1,5 @@ /* - Copyright (c) 2006, 2012, Oracle and/or its affiliates. All rights reserved. + Copyright (c) 2006, 2012, Oracle and/or its affiliates. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -78,6 +78,7 @@ error2: return TRUE; } + my_bool test_get_all_bits(MY_BITMAP *map, uint bitsize) { uint i; @@ -126,8 +127,8 @@ my_bool test_compare_operators(MY_BITMAP *map, uint bitsize) uint no_loops= bitsize > 128 ? 128 : bitsize; MY_BITMAP map2_obj, map3_obj; MY_BITMAP *map2= &map2_obj, *map3= &map3_obj; - uint32 map2buf[MAX_TESTED_BITMAP_SIZE]; - uint32 map3buf[MAX_TESTED_BITMAP_SIZE]; + my_bitmap_map map2buf[MAX_TESTED_BITMAP_SIZE]; + my_bitmap_map map3buf[MAX_TESTED_BITMAP_SIZE]; bitmap_init(&map2_obj, map2buf, bitsize, FALSE); bitmap_init(&map3_obj, map3buf, bitsize, FALSE); bitmap_clear_all(map2); @@ -479,7 +480,7 @@ error: my_bool do_test(uint bitsize) { MY_BITMAP map; - uint32 buf[MAX_TESTED_BITMAP_SIZE]; + my_bitmap_map buf[MAX_TESTED_BITMAP_SIZE]; if (bitmap_init(&map, buf, bitsize, FALSE)) { diag("init error for bitsize %d", bitsize); @@ -519,15 +520,22 @@ error: return TRUE; } -int main() +int main(int argc,char *argv[]) { int i; int const min_size = 1; int const max_size = MAX_TESTED_BITMAP_SIZE; - MY_INIT("bitmap-t"); + MY_INIT(argv[0]); + + plan((max_size - min_size)/7+1); - plan(max_size - min_size); - for (i= min_size; i < max_size; i++) + /* + It's ok to do steps in 7, as i module 64 will go trough all values 1..63. + Any errors in the code should manifest as we are working with integers + of size 16, 32, or 64 bits... + */ + for (i= min_size; i < max_size; i+=7) ok(do_test(i) == 0, "bitmap size %d", i); + my_end(0); return exit_status(); } diff --git a/unittest/mysys/ma_dyncol-t.c b/unittest/mysys/ma_dyncol-t.c new file mode 100644 index 00000000000..11731ae81d4 --- /dev/null +++ b/unittest/mysys/ma_dyncol-t.c @@ -0,0 +1,795 @@ +/* Copyright (c) 2011, Monty Program Ab + Copyright (c) 2011, Oleksandr Byelkin + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are + met: + + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + + 2. Redistributions in binary form must the following disclaimer in + the documentation and/or other materials provided with the + distribution. + + THIS SOFTWARE IS PROVIDED BY <COPYRIGHT HOLDER> ``AS IS'' AND ANY + EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR + CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. +*/ + +#include <my_global.h> +#include <my_sys.h> +#include <m_string.h> +#include <ma_dyncol.h> +#include <tap.h> + +void test_value_single_null() +{ + int rc= FALSE; + DYNAMIC_COLUMN_VALUE val, res; + DYNAMIC_COLUMN str; + /* init values */ + val.type= DYN_COL_NULL; + dynamic_column_value_init(&res); + /* create column */ + if (dynamic_column_create(&str, 1, &val)) + goto err; + dynstr_append(&str, "\1"); str.length--; //check for overflow + /* read column */ + if (dynamic_column_get(&str, 1, &res)) + goto err; + rc= (res.type == DYN_COL_NULL); +err: + ok(rc, "%s", "NULL"); + /* cleanup */ + dynamic_column_column_free(&str); +} + +void test_value_single_uint(ulonglong num, const char *name) +{ + int rc= FALSE; + DYNAMIC_COLUMN_VALUE val, res; + DYNAMIC_COLUMN str; + /* init values */ + val.type= DYN_COL_UINT; + val.x.ulong_value= num; + dynamic_column_value_init(&res); + /* create column */ + if (dynamic_column_create(&str, 1, &val)) + goto err; + dynstr_append(&str, "\1"); str.length--; //check for overflow + /* read column */ + if (dynamic_column_get(&str, 1, &res)) + goto err; + rc= (res.type == DYN_COL_UINT) && (res.x.ulong_value == num); + num= res.x.ulong_value; +err: + ok(rc, "%s - %llu", name, num); + /* cleanup */ + dynamic_column_column_free(&str); +} + +void test_value_single_sint(longlong num, const char *name) +{ + int rc= FALSE; + DYNAMIC_COLUMN_VALUE val, res; + DYNAMIC_COLUMN str; + /* init values */ + val.type= DYN_COL_INT; + val.x.long_value= num; + dynamic_column_value_init(&res); + /* create column */ + if (dynamic_column_create(&str, 1, &val)) + goto err; + dynstr_append(&str, "\1"); str.length--; //check for overflow + /* read column */ + if (dynamic_column_get(&str, 1, &res)) + goto err; + rc= (res.type == DYN_COL_INT) && (res.x.long_value == num); + num= res.x.ulong_value; +err: + ok(rc, "%s - %lld", name, num); + /* cleanup */ + dynamic_column_column_free(&str); +} + + +void test_value_single_double(double num, const char *name) +{ + int rc= FALSE; + DYNAMIC_COLUMN_VALUE val, res; + DYNAMIC_COLUMN str; + /* init values */ + val.type= DYN_COL_DOUBLE; + val.x.double_value= num; + dynamic_column_value_init(&res); + /* create column */ + if (dynamic_column_create(&str, 1, &val)) + goto err; + dynstr_append(&str, "\1"); str.length--; //check for overflow + /* read column */ + if (dynamic_column_get(&str, 1, &res)) + goto err; + rc= (res.type == DYN_COL_DOUBLE) && (res.x.double_value == num); + num= res.x.ulong_value; +err: + ok(rc, "%s - %lf", name, num); + /* cleanup */ + dynamic_column_column_free(&str); +} + +void test_value_single_decimal(const char *num) +{ + char *end= (((char*)num) + strlen(num)); + char buff[80]; + int rc= FALSE; + int length= 80; + DYNAMIC_COLUMN_VALUE val, res; + DYNAMIC_COLUMN str; + + /* init values */ + dynamic_column_prepare_decimal(&val); // special procedure for decimal!!! + if (string2decimal(num, &val.x.decimal.value, &end) != E_DEC_OK) + goto err; + dynamic_column_value_init(&res); + + /* create column */ + if (dynamic_column_create(&str, 1, &val)) + goto err; + dynstr_append(&str, "\1"); str.length--; //check for overflow + /* read column */ + if (dynamic_column_get(&str, 1, &res)) + goto err; + rc= ((res.type == DYN_COL_DECIMAL) && + (decimal_cmp(&res.x.decimal.value, &val.x.decimal.value) == 0)); + decimal2string(&res.x.decimal.value, buff, &length, 0, 0, ' '); +err: + ok(rc, "%s - %s", num, buff); + /* cleanup */ + dynamic_column_column_free(&str); +} + +static CHARSET_INFO *charset_list[]= +{ +#ifdef HAVE_CHARSET_big5 + &my_charset_big5_chinese_ci, + &my_charset_big5_bin, +#endif +#ifdef HAVE_CHARSET_euckr + &my_charset_euckr_korean_ci, + &my_charset_euckr_bin, +#endif +#ifdef HAVE_CHARSET_gb2312 + &my_charset_gb2312_chinese_ci, + &my_charset_gb2312_bin, +#endif +#ifdef HAVE_CHARSET_gbk + &my_charset_gbk_chinese_ci, + &my_charset_gbk_bin, +#endif +#ifdef HAVE_CHARSET_latin1 + &my_charset_latin1, + &my_charset_latin1_bin, +#endif +#ifdef HAVE_CHARSET_sjis + &my_charset_sjis_japanese_ci, + &my_charset_sjis_bin, +#endif +#ifdef HAVE_CHARSET_tis620 + &my_charset_tis620_thai_ci, + &my_charset_tis620_bin, +#endif +#ifdef HAVE_CHARSET_ujis + &my_charset_ujis_japanese_ci, + &my_charset_ujis_bin, +#endif +#ifdef HAVE_CHARSET_utf8 + &my_charset_utf8_general_ci, +#ifdef HAVE_HAVE_UCA_COLLATIONS + &my_charset_utf8_unicode_ci, +#endif + &my_charset_utf8_bin, +#endif +}; + + +void test_value_single_string(const char *string, size_t len, + CHARSET_INFO *cs) +{ + int rc= FALSE; + DYNAMIC_COLUMN_VALUE val, res; + DYNAMIC_COLUMN str; + + /* init values */ + val.type= DYN_COL_STRING; + val.x.string.value.str= (char*)string; + val.x.string.value.length= len; + val.x.string.charset= cs; + dynamic_column_value_init(&res); + + /* create column */ + if (dynamic_column_create(&str, 1, &val)) + goto err; + dynstr_append(&str, "\1"); str.length--; //check for overflow + /* read column */ + if (dynamic_column_get(&str, 1, &res)) + goto err; + rc= ((res.type == DYN_COL_STRING) && + (res.x.string.value.length == len) && + (memcmp(res.x.string.value.str, string, len) == 0) && + (res.x.string.charset->number == cs->number)); +err: + ok(rc, "'%s' - '%s' %u %u-%s", string, + res.x.string.value.str, (uint)res.x.string.value.length, + (uint)res.x.string.charset->number, res.x.string.charset->name); + /* cleanup */ + val.x.string.value.str= NULL; // we did not allocated it + dynamic_column_column_free(&str); +} + +void test_value_single_date(uint year, uint month, uint day, const char *name) +{ + int rc= FALSE; + DYNAMIC_COLUMN_VALUE val, res; + DYNAMIC_COLUMN str; + /* init values */ + val.type= DYN_COL_DATE; + val.x.time_value.time_type= MYSQL_TIMESTAMP_DATE; + val.x.time_value.year= year; + val.x.time_value.month= month; + val.x.time_value.day= day; + dynamic_column_value_init(&res); + /* create column */ + if (dynamic_column_create(&str, 1, &val)) + goto err; + dynstr_append(&str, "\1"); str.length--; //check for overflow + /* read column */ + if (dynamic_column_get(&str, 1, &res)) + goto err; + rc= ((res.type == DYN_COL_DATE) && + (res.x.time_value.time_type == MYSQL_TIMESTAMP_DATE) && + (res.x.time_value.year == year) && + (res.x.time_value.month == month) && + (res.x.time_value.day == day)); +err: + ok(rc, "%s - %04u-%02u-%02u", name, year, month, day); + /* cleanup */ + dynamic_column_column_free(&str); +} + +void test_value_single_time(uint neg, uint hour, uint minute, uint second, + uint mic, const char *name) +{ + int rc= FALSE; + DYNAMIC_COLUMN_VALUE val, res; + DYNAMIC_COLUMN str; + /* init values */ + val.type= DYN_COL_TIME; + val.x.time_value.time_type= MYSQL_TIMESTAMP_TIME; + val.x.time_value.neg= neg; + val.x.time_value.hour= hour; + val.x.time_value.minute= minute; + val.x.time_value.second= second; + val.x.time_value.second_part= mic; + dynamic_column_value_init(&res); + /* create column */ + if (dynamic_column_create(&str, 1, &val)) + goto err; + dynstr_append(&str, "\1"); str.length--; //check for overflow + /* read column */ + if (dynamic_column_get(&str, 1, &res)) + goto err; + rc= ((res.type == DYN_COL_TIME) && + (res.x.time_value.time_type == MYSQL_TIMESTAMP_TIME) && + (res.x.time_value.neg == (int)neg) && + (res.x.time_value.hour == hour) && + (res.x.time_value.minute == minute) && + (res.x.time_value.second == second) && + (res.x.time_value.second_part == mic)); +err: + ok(rc, "%s - %c%02u:%02u:%02u.%06u", name, (neg ? '-' : '+'), + hour, minute, second, mic); + /* cleanup */ + dynamic_column_column_free(&str); +} + + +void test_value_single_datetime(uint neg, uint year, uint month, uint day, + uint hour, uint minute, uint second, + uint mic, const char *name) +{ + int rc= FALSE; + DYNAMIC_COLUMN_VALUE val, res; + DYNAMIC_COLUMN str; + /* init values */ + val.type= DYN_COL_DATETIME; + val.x.time_value.time_type= MYSQL_TIMESTAMP_DATETIME; + val.x.time_value.neg= neg; + val.x.time_value.year= year; + val.x.time_value.month= month; + val.x.time_value.day= day; + val.x.time_value.hour= hour; + val.x.time_value.minute= minute; + val.x.time_value.second= second; + val.x.time_value.second_part= mic; + dynamic_column_value_init(&res); + /* create column */ + if (dynamic_column_create(&str, 1, &val)) + goto err; + dynstr_append(&str, "\1"); str.length--; //check for overflow + /* read column */ + if (dynamic_column_get(&str, 1, &res)) + goto err; + rc= ((res.type == DYN_COL_DATETIME) && + (res.x.time_value.time_type == MYSQL_TIMESTAMP_DATETIME) && + (res.x.time_value.neg == (int)neg) && + (res.x.time_value.year == year) && + (res.x.time_value.month == month) && + (res.x.time_value.day == day) && + (res.x.time_value.hour == hour) && + (res.x.time_value.minute == minute) && + (res.x.time_value.second == second) && + (res.x.time_value.second_part == mic)); +err: + ok(rc, "%s - %c %04u-%02u-%02u %02u:%02u:%02u.%06u", name, (neg ? '-' : '+'), + year, month, day, hour, minute, second, mic); + /* cleanup */ + dynamic_column_column_free(&str); +} + + +void test_value_multi(ulonglong num0, + longlong num1, + double num2, + const char *num3, + const char *string4, size_t len4, CHARSET_INFO *cs4, + uint year5, uint month5, uint day5, + uint neg6, uint hour6, uint minute6, + uint second6, uint mic6, + uint neg7, uint year7, uint month7, uint day7, + uint hour7, uint minute7, uint second7, + uint mic7, + uint *column_numbers, + const char *name) +{ + char *end3= (((char*)num3) + strlen(num3)); + int rc= FALSE; + uint i; + DYNAMIC_COLUMN_VALUE val[9], res[9]; + DYNAMIC_COLUMN str; + /* init values */ + val[0].type= DYN_COL_UINT; + val[0].x.ulong_value= num0; + val[1].type= DYN_COL_INT; + val[1].x.long_value= num1; + val[2].type= DYN_COL_DOUBLE; + val[2].x.double_value= num2; + dynamic_column_prepare_decimal(val + 3); // special procedure for decimal!!! + if (string2decimal(num3, &val[3].x.decimal.value, &end3) != E_DEC_OK) + goto err; + val[4].type= DYN_COL_STRING; + val[4].x.string.value.str= (char*)string4; + val[4].x.string.value.length= len4; + val[4].x.string.charset= cs4; + val[5].type= DYN_COL_DATE; + val[5].x.time_value.time_type= MYSQL_TIMESTAMP_DATE; + val[5].x.time_value.year= year5; + val[5].x.time_value.month= month5; + val[5].x.time_value.day= day5; + val[6].type= DYN_COL_TIME; + val[6].x.time_value.time_type= MYSQL_TIMESTAMP_TIME; + val[6].x.time_value.neg= neg6; + val[6].x.time_value.hour= hour6; + val[6].x.time_value.minute= minute6; + val[6].x.time_value.second= second6; + val[6].x.time_value.second_part= mic6; + val[7].type= DYN_COL_DATETIME; + val[7].x.time_value.time_type= MYSQL_TIMESTAMP_DATETIME; + val[7].x.time_value.neg= neg7; + val[7].x.time_value.year= year7; + val[7].x.time_value.month= month7; + val[7].x.time_value.day= day7; + val[7].x.time_value.hour= hour7; + val[7].x.time_value.minute= minute7; + val[7].x.time_value.second= second7; + val[7].x.time_value.second_part= mic7; + val[8].type= DYN_COL_NULL; + for (i= 0; i < 9; i++) + dynamic_column_value_init(res + i); + /* create column */ + if (dynamic_column_create_many(&str, 9, column_numbers, val)) + goto err; + dynstr_append(&str, "\1"); str.length--; //check for overflow + /* read column */ + for (i= 0; i < 9; i++) + if (dynamic_column_get(&str, column_numbers[i], res + i)) + goto err; + rc= ((res[0].type == DYN_COL_UINT) && + (res[0].x.ulong_value == num0) && + (res[1].type == DYN_COL_INT) && + (res[1].x.long_value == num1) && + (res[2].type == DYN_COL_DOUBLE) && + (res[2].x.double_value == num2) && + (res[3].type == DYN_COL_DECIMAL) && + (decimal_cmp(&res[3].x.decimal.value, &val[3].x.decimal.value) == 0) && + (res[4].type == DYN_COL_STRING) && + (res[4].x.string.value.length == len4) && + (memcmp(res[4].x.string.value.str, string4, len4) == 0) && + (res[4].x.string.charset->number == cs4->number) && + (res[5].type == DYN_COL_DATE) && + (res[5].x.time_value.time_type == MYSQL_TIMESTAMP_DATE) && + (res[5].x.time_value.year == year5) && + (res[5].x.time_value.month == month5) && + (res[5].x.time_value.day == day5) && + (res[6].type == DYN_COL_TIME) && + (res[6].x.time_value.time_type == MYSQL_TIMESTAMP_TIME) && + (res[6].x.time_value.neg == (int)neg6) && + (res[6].x.time_value.hour == hour6) && + (res[6].x.time_value.minute == minute6) && + (res[6].x.time_value.second == second6) && + (res[6].x.time_value.second_part == mic6) && + (res[7].type == DYN_COL_DATETIME) && + (res[7].x.time_value.time_type == MYSQL_TIMESTAMP_DATETIME) && + (res[7].x.time_value.neg == (int)neg7) && + (res[7].x.time_value.year == year7) && + (res[7].x.time_value.month == month7) && + (res[7].x.time_value.day == day7) && + (res[7].x.time_value.hour == hour7) && + (res[7].x.time_value.minute == minute7) && + (res[7].x.time_value.second == second7) && + (res[7].x.time_value.second_part == mic7) && + (res[8].type == DYN_COL_NULL)); +err: + ok(rc, "%s", name); + /* cleanup */ + val[4].x.string.value.str= NULL; // we did not allocated it + dynamic_column_column_free(&str); +} + + +void test_value_multi_same_num() +{ + int rc= FALSE; + uint i; + DYNAMIC_COLUMN_VALUE val[5]; + uint column_numbers[]= {3,4,5,3,6}; // same column numbers + DYNAMIC_COLUMN str; + /* init values */ + for (i= 0; i < 5; i++) + val[i].type= DYN_COL_NULL; + /* create column */ + if (!dynamic_column_create_many(&str, 5, column_numbers, val)) + goto err; + rc= TRUE; +err: + ok(rc, "%s", "same column numbers check"); + /* cleanup */ + dynamic_column_column_free(&str); +} + + +void test_update_multi(uint *column_numbers, uint *column_values, + my_bool *null_values, int only_add, int all) +{ + int rc= FALSE; + int i, j; + DYNAMIC_COLUMN str; + DYNAMIC_COLUMN_VALUE val; + + val.type= DYN_COL_UINT; + val.x.ulong_value= column_values[0]; + if (dynamic_column_create(&str, column_numbers[0], &val)) + goto err; + for (i= 1; i < all; i++) + { + val.type= (null_values[i] ? DYN_COL_NULL : DYN_COL_UINT); + val.x.ulong_value= column_values[i]; + if (dynamic_column_update(&str, column_numbers[i], &val)) + goto err; + + /* check value(s) */ + for (j= i; j >= (i < only_add ? 0 : i); j--) + { + if (dynamic_column_get(&str, column_numbers[j], &val)) + goto err; + if (null_values[j]) + { + if (val.type != DYN_COL_NULL || + dynamic_column_exists(&str, column_numbers[j]) == ER_DYNCOL_YES) + goto err; + } + else + { + if (val.type != DYN_COL_UINT || + val.x.ulong_value != column_values[j] || + dynamic_column_exists(&str, column_numbers[j]) == ER_DYNCOL_NO) + goto err; + } + } + if (i < only_add) + { + DYNAMIC_ARRAY num; + if (dynamic_column_list(&str, &num)) + goto err; + /* cross check arrays */ + if ((int)num.elements != i + 1) + { + delete_dynamic(&num); + goto err; + } + for(j= 0; j < i + 1; j++) + { + int k; + for(k= 0; + k < i + 1 && column_numbers[j] != + *dynamic_element(&num, k, uint*); + k++); + if (k >= i + 1) + { + delete_dynamic(&num); + goto err; + } + for(k= 0; + k < i + 1 && column_numbers[k] != + *dynamic_element(&num, j, uint*); + k++); + if (k >= i + 1) + { + delete_dynamic(&num); + goto err; + } + } + delete_dynamic(&num); + } + } + + rc= TRUE; +err: + ok(rc, "%s", "add/delete/update"); + /* cleanup */ + dynamic_column_column_free(&str); +} + +void test_empty_string() +{ + DYNAMIC_COLUMN_VALUE val, res; + DYNAMIC_COLUMN str; + DYNAMIC_ARRAY array_of_uint; + int rc; + /* empty string */ + bzero(&str, sizeof(str)); + + rc= dynamic_column_get(&str, 1, &res); + ok( (rc == ER_DYNCOL_OK) && (res.type == DYN_COL_NULL), "%s", "empty get"); + + rc= dynamic_column_delete(&str, 1); + ok( (rc == ER_DYNCOL_OK), "%s", "empty delete"); + + rc= dynamic_column_exists(&str, 1); + ok( (rc == ER_DYNCOL_NO), "%s", "empty exists"); + + rc= dynamic_column_list(&str, &array_of_uint); + ok( (rc == ER_DYNCOL_OK) && (array_of_uint.elements == 0), + "%s", "empty list"); + + val.type= DYN_COL_UINT; + val.x.ulong_value= 1212; + rc= dynamic_column_update(&str, 1, &val); + if (rc == ER_DYNCOL_OK) + rc= dynamic_column_get(&str, 1, &res); + ok( (rc == ER_DYNCOL_OK) && + (res.type == DYN_COL_UINT) && (res.x.ulong_value == val.x.ulong_value), + "%s", "empty update"); +} + + +void test_update_many(uint *column_numbers, uint *column_values, + uint column_count, + uint *update_numbers, uint *update_values, + my_bool *update_nulls, uint update_count, + uint *result_numbers, uint *result_values, + uint result_count) +{ + int rc= FALSE; + uint i; + DYNAMIC_COLUMN str1; + DYNAMIC_COLUMN str2; + DYNAMIC_COLUMN_VALUE *val, *upd, *res; + + val= (DYNAMIC_COLUMN_VALUE *)malloc(sizeof(DYNAMIC_COLUMN_VALUE) * + column_count); + upd= (DYNAMIC_COLUMN_VALUE *)malloc(sizeof(DYNAMIC_COLUMN_VALUE) * + update_count); + res= (DYNAMIC_COLUMN_VALUE *)malloc(sizeof(DYNAMIC_COLUMN_VALUE) * + result_count); + + + for (i= 0; i < column_count; i++) + { + val[i].type= DYN_COL_UINT; + val[i].x.ulong_value= column_values[i]; + } + for (i= 0; i < update_count; i++) + { + if (update_nulls[i]) + upd[i].type= DYN_COL_NULL; + else + { + upd[i].type= DYN_COL_UINT; + upd[i].x.ulong_value= update_values[i]; + } + } + for (i= 0; i < result_count; i++) + { + res[i].type= DYN_COL_UINT; + res[i].x.ulong_value= result_values[i]; + } + if (dynamic_column_create_many(&str1, column_count, column_numbers, val)) + goto err; + if (dynamic_column_update_many(&str1, update_count, update_numbers, upd)) + goto err; + if (dynamic_column_create_many(&str2, result_count, result_numbers, res)) + goto err; + if (str1.length == str2.length && + memcmp(str1.str, str2.str, str1.length) ==0) + rc= TRUE; + +err: + ok(rc, "%s", "update_many"); + /* cleanup */ + dynamic_column_column_free(&str1); + dynamic_column_column_free(&str2); +} + +int main(int argc __attribute__((unused)), char **argv) +{ + uint i; + char *big_string= (char *)malloc(1024*1024); + + MY_INIT(argv[0]); + plan(60); + + if (!big_string) + exit(1); + for (i= 0; i < 1024*1024; i++) + big_string[i]= ('0' + (i % 10)); + test_value_single_null(); + test_value_single_uint(0, "0"); + test_value_single_uint(ULL(0xffffffffffffffff), "0xffffffffffffffff"); + test_value_single_uint(ULL(0xaaaaaaaaaaaaaaaa), "0xaaaaaaaaaaaaaaaa"); + test_value_single_uint(ULL(0x5555555555555555), "0x5555555555555555"); + test_value_single_uint(27652, "27652"); + test_value_single_sint(0, "0"); + test_value_single_sint(1, "1"); + test_value_single_sint(-1, "-1"); + test_value_single_sint(LL(0x7fffffffffffffff), + "0x7fffffffffffffff"); + test_value_single_sint(LL(0xaaaaaaaaaaaaaaaa), + "0xaaaaaaaaaaaaaaaa"); + test_value_single_sint(LL(0x5555555555555555), + "0x5555555555555555"); + test_value_single_sint(LL(0x8000000000000000), + "0x8000000000000000"); + test_value_single_double(0.0, "0.0"); + test_value_single_double(1.0, "1.0"); + test_value_single_double(-1.0, "-1.0"); + test_value_single_double(1.0e100, "1.0e100"); + test_value_single_double(1.0e-100, "1.0e-100"); + test_value_single_double(9999999999999999999999999999999999999.0, + "9999999999999999999999999999999999999.0"); + test_value_single_double(-9999999999999999999999999999999999999.0, + "-9999999999999999999999999999999999999.0"); + test_value_single_decimal("0"); + test_value_single_decimal("1"); + test_value_single_decimal("-1"); + test_value_single_decimal("9999999999999999999999999999999"); + test_value_single_decimal("-9999999999999999999999999999999"); + test_value_single_decimal("0.9999999999999999999999999999999"); + test_value_single_decimal("-0.9999999999999999999999999999999"); + test_value_single_string("", 0, charset_list[0]); + test_value_single_string("", 1, charset_list[0]); + test_value_single_string("1234567890", 11, charset_list[0]); + test_value_single_string("nulls\0\0\0\0\0", 10, charset_list[0]); + sprintf(big_string, "%x", 0x7a); + test_value_single_string(big_string, 0x7a, charset_list[0]); + sprintf(big_string, "%x", 0x80); + test_value_single_string(big_string, 0x80, charset_list[0]); + sprintf(big_string, "%x", 0x7ffa); + test_value_single_string(big_string, 0x7ffa, charset_list[0]); + sprintf(big_string, "%x", 0x8000); + test_value_single_string(big_string, 0x8000, charset_list[0]); + sprintf(big_string, "%x", 1024*1024); + test_value_single_string(big_string, 1024*1024, charset_list[0]); + test_value_single_date(0, 0, 0, "zero date"); + test_value_single_date(9999, 12, 31, "max date"); + test_value_single_date(2011, 3, 26, "some date"); + test_value_single_time(0, 0, 0, 0, 0, "zero time"); + test_value_single_time(1, 23, 59, 59, 999999, "min time"); + test_value_single_time(0, 23, 59, 59, 999999, "max time"); + test_value_single_time(0, 21, 36, 20, 28, "some time"); + test_value_single_datetime(0, 0, 0, 0, 0, 0, 0, 0, "zero datetime"); + test_value_single_datetime(1, 9999, 12, 31, 23, 59, 59, 999999, + "min datetime"); + test_value_single_datetime(0, 9999, 12, 31, 23, 59, 59, 999999, + "max datetime"); + test_value_single_datetime(0, 2011, 3, 26, 21, 53, 12, 3445, + "some datetime"); + { + uint column_numbers[]= {100,1,2,3,4,5,6,7,8}; + test_value_multi(0, 0, 0.0, "0", + "", 0, charset_list[0], + 0, 0, 0, + 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + column_numbers, + "zero data"); + } + { + uint column_numbers[]= {10,1,12,37,4,57,6,76,87}; + test_value_multi(ULL(0xffffffffffffffff), LL(0x7fffffffffffffff), + 99999999.999e120, "9999999999999999999999999999999", + big_string, 1024*1024, charset_list[0], + 9999, 12, 31, + 0, 23, 59, 59, 999999, + 0, 9999, 12, 31, 23, 59, 59, 999999, + column_numbers, + "much data"); + } + free(big_string); + { + uint column_numbers[]= {101,12,122,37,24,572,16,726,77}; + test_value_multi(37878, -3344, + 2873.3874, "92743.238984789898", + "string", 6, charset_list[0], + 2011, 3, 26, + 1, 23, 23, 20, 333, + 0, 2011, 3, 26, 23, 23, 53, 334, + column_numbers, + "zero data"); + } + test_value_multi_same_num(); + { + uint column_numbers[]= {1,2,3,4,5,6,7,2, 3, 4}; + uint column_values[]= {1,2,3,4,5,6,7,0,30,40}; + my_bool null_values[]= {0,0,0,0,0,0,0,1, 0, 0}; + + test_update_multi(column_numbers, column_values, null_values, 7, 10); + } + { + uint column_numbers[]= {4,3,2,1, 1,2,3,4}; + uint column_values[]= {4,3,2,1, 0,0,0,0}; + my_bool null_values[]= {0,0,0,0, 1,1,1,1}; + + test_update_multi(column_numbers, column_values, null_values, 4, 8); + } + { + uint column_numbers[]= {4,3,2,1, 4,3,2,1}; + uint column_values[]= {4,3,2,1, 0,0,0,0}; + my_bool null_values[]= {0,0,0,0, 1,1,1,1}; + + test_update_multi(column_numbers, column_values, null_values, 4, 8); + } + test_empty_string(); + { + uint column_numbers[]= {1, 2, 3}; + uint column_values[]= {1, 2, 3}; + uint update_numbers[]= {4, 3, 2, 1}; + uint update_values[]= {40,30, 0,10}; + my_bool update_nulls[]={0, 0, 1, 0}; + uint result_numbers[]= {1, 3, 4}; + uint result_values[]= {10,30,40}; + test_update_many(column_numbers, column_values, 3, + update_numbers, update_values, update_nulls, 4, + result_numbers, result_values, 3); + } + return exit_status(); +} diff --git a/unittest/mysys/my_malloc-t.c b/unittest/mysys/my_malloc-t.c index 00cac0d21b7..40d9492b039 100644 --- a/unittest/mysys/my_malloc-t.c +++ b/unittest/mysys/my_malloc-t.c @@ -17,10 +17,10 @@ #include <my_sys.h> #include "tap.h" -int main(void) +int main(int argc,char *argv[]) { void *p; - MY_INIT("my_malloc-t"); + MY_INIT(argv[0]); plan(4); @@ -38,6 +38,7 @@ int main(void) ok((my_free(p), 1), "Free NULL pointer."); + my_end(0); return exit_status(); } diff --git a/unittest/mysys/thr_template.c b/unittest/mysys/thr_template.c index ed32bfee5eb..7304eb50955 100644 --- a/unittest/mysys/thr_template.c +++ b/unittest/mysys/thr_template.c @@ -30,7 +30,7 @@ void do_tests(); void test_concurrently(const char *test, pthread_handler handler, int n, int m) { pthread_t t; - ulonglong now= my_getsystime(); + ulonglong now= my_interval_timer(); bad= 0; @@ -48,13 +48,13 @@ void test_concurrently(const char *test, pthread_handler handler, int n, int m) pthread_cond_wait(&cond, &mutex); pthread_mutex_unlock(&mutex); - now= my_getsystime()-now; - ok(!bad, "tested %s in %g secs (%d)", test, ((double)now)/1e7, bad); + now= my_interval_timer() - now; + ok(!bad, "tested %s in %g secs (%d)", test, ((double)now)/1e9, bad); } int main(int argc __attribute__((unused)), char **argv) { - MY_INIT("thd_template"); + MY_INIT(argv[0]); if (argv[1] && *argv[1]) DBUG_SET_INITIAL(argv[1]); @@ -83,7 +83,9 @@ int main(int argc __attribute__((unused)), char **argv) workaround until we know why it crashes randomly on some machine (BUG#22320). */ +#ifdef NOT_USED sleep(2); +#endif pthread_mutex_destroy(&mutex); pthread_cond_destroy(&cond); pthread_attr_destroy(&thr_attr); diff --git a/unittest/mysys/waiting_threads-t.c b/unittest/mysys/waiting_threads-t.c new file mode 100644 index 00000000000..35e86aca319 --- /dev/null +++ b/unittest/mysys/waiting_threads-t.c @@ -0,0 +1,291 @@ +/* Copyright (C) 2008 MySQL AB, 2008-2009 Sun Microsystems, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ + +#include "thr_template.c" +#include <waiting_threads.h> +#include <m_string.h> + +struct test_wt_thd { + WT_THD thd; + pthread_mutex_t lock; +} thds[THREADS]; + +uint i, cnt; +pthread_mutex_t lock; +pthread_cond_t thread_sync; + +ulong wt_timeout_short=100, wt_deadlock_search_depth_short=4; +ulong wt_timeout_long=10000, wt_deadlock_search_depth_long=15; + +#define reset(ARRAY) bzero(ARRAY, sizeof(ARRAY)) + +/* see explanation of the kill strategies in waiting_threads.h */ +enum { LATEST, RANDOM, YOUNGEST, LOCKS } kill_strategy; + +WT_RESOURCE_TYPE restype={ wt_resource_id_memcmp, 0}; + +#define rnd() ((uint)(my_rnd(&rand) * INT_MAX32)) + +/* + stress test: wait on a random number of random threads. + it always succeeds (unless crashes or hangs). +*/ +pthread_handler_t test_wt(void *arg) +{ + int m, n, i, id, res; + struct my_rnd_struct rand; + + my_thread_init(); + + pthread_mutex_lock(&mutex); + id= cnt++; + wt_thd_lazy_init(& thds[id].thd, + & wt_deadlock_search_depth_short, & wt_timeout_short, + & wt_deadlock_search_depth_long, & wt_timeout_long); + + /* now, wait for everybody to be ready to run */ + if (cnt >= THREADS) + pthread_cond_broadcast(&thread_sync); + else + while (cnt < THREADS) + pthread_cond_wait(&thread_sync, &mutex); + pthread_mutex_unlock(&mutex); + + my_rnd_init(&rand, (ulong)(intptr)&m, id); + if (kill_strategy == YOUNGEST) + thds[id].thd.weight= (ulong) ~ my_interval_timer(); + if (kill_strategy == LOCKS) + thds[id].thd.weight= 0; + + for (m= *(int *)arg; m ; m--) + { + WT_RESOURCE_ID resid; + int blockers[THREADS/10], j, k; + + resid.value= id; + resid.type= &restype; + + res= 0; + + /* prepare for waiting for a random number of random threads */ + for (j= n= (rnd() % THREADS)/10; !res && j >= 0; j--) + { +retry: + i= rnd() % (THREADS-1); /* pick a random thread */ + if (i >= id) i++; /* with a number from 0 to THREADS-1 excluding ours */ + + for (k=n; k >=j; k--) /* the one we didn't pick before */ + if (blockers[k] == i) + goto retry; + blockers[j]= i; + + if (kill_strategy == RANDOM) + thds[id].thd.weight= rnd(); + + pthread_mutex_lock(& thds[i].lock); + res= wt_thd_will_wait_for(& thds[id].thd, & thds[i].thd, &resid); + pthread_mutex_unlock(& thds[i].lock); + } + + if (!res) + { + pthread_mutex_lock(&lock); + res= wt_thd_cond_timedwait(& thds[id].thd, &lock); + pthread_mutex_unlock(&lock); + } + + if (res) + { + pthread_mutex_lock(& thds[id].lock); + pthread_mutex_lock(&lock); + wt_thd_release_all(& thds[id].thd); + pthread_mutex_unlock(&lock); + pthread_mutex_unlock(& thds[id].lock); + if (kill_strategy == LOCKS) + thds[id].thd.weight= 0; + if (kill_strategy == YOUNGEST) + thds[id].thd.weight= (ulong)~ my_interval_timer(); + } + else if (kill_strategy == LOCKS) + thds[id].thd.weight++; + } + + pthread_mutex_lock(&mutex); + /* wait for everybody to finish */ + if (!--cnt) + pthread_cond_broadcast(&thread_sync); + else + while (cnt) + pthread_cond_wait(&thread_sync, &mutex); + + pthread_mutex_lock(& thds[id].lock); + pthread_mutex_lock(&lock); + wt_thd_release_all(& thds[id].thd); + pthread_mutex_unlock(&lock); + pthread_mutex_unlock(& thds[id].lock); + wt_thd_destroy(& thds[id].thd); + + if (!--running_threads) /* now, signal when everybody is done with deinit */ + pthread_cond_signal(&cond); + pthread_mutex_unlock(&mutex); + DBUG_PRINT("wt", ("exiting")); + my_thread_end(); + return 0; +} + +void do_one_test() +{ + double sum, sum0; + DBUG_ENTER("do_one_test"); + + reset(wt_cycle_stats); + reset(wt_wait_stats); + wt_success_stats=0; + cnt=0; + test_concurrently("waiting_threads", test_wt, THREADS, CYCLES); + + sum=sum0=0; + for (cnt=0; cnt < WT_CYCLE_STATS; cnt++) + sum+= wt_cycle_stats[0][cnt] + wt_cycle_stats[1][cnt]; + for (cnt=0; cnt < WT_CYCLE_STATS; cnt++) + if (wt_cycle_stats[0][cnt] + wt_cycle_stats[1][cnt] > 0) + { + sum0+=wt_cycle_stats[0][cnt] + wt_cycle_stats[1][cnt]; + diag("deadlock cycles of length %2u: %4u %4u %8.2f %%", cnt, + wt_cycle_stats[0][cnt], wt_cycle_stats[1][cnt], 1e2*sum0/sum); + } + diag("depth exceeded: %u %u", + wt_cycle_stats[0][cnt], wt_cycle_stats[1][cnt]); + for (cnt=0; cnt < WT_WAIT_STATS; cnt++) + if (wt_wait_stats[cnt]>0) + diag("deadlock waits up to %7llu us: %5u", + wt_wait_table[cnt], wt_wait_stats[cnt]); + diag("timed out: %u", wt_wait_stats[cnt]); + diag("successes: %u", wt_success_stats); + + DBUG_VOID_RETURN; +} + +void do_tests() +{ + DBUG_ENTER("do_tests"); + if (skip_big_tests) + { + skip(1, "Big test skipped"); + return; + } + plan(14); + compile_time_assert(THREADS >= 4); + + DBUG_PRINT("wt", ("================= initialization ===================")); + + bad= my_atomic_initialize(); + ok(!bad, "my_atomic_initialize() returned %d", bad); + + pthread_cond_init(&thread_sync, 0); + pthread_mutex_init(&lock, 0); + wt_init(); + for (cnt=0; cnt < THREADS; cnt++) + pthread_mutex_init(& thds[cnt].lock, 0); + { + WT_RESOURCE_ID resid[4]; + for (i=0; i < array_elements(resid); i++) + { + wt_thd_lazy_init(& thds[i].thd, + & wt_deadlock_search_depth_short, & wt_timeout_short, + & wt_deadlock_search_depth_long, & wt_timeout_long); + resid[i].value= i+1; + resid[i].type= &restype; + } + + DBUG_PRINT("wt", ("================= manual test ===================")); + +#define ok_wait(X,Y, R) \ + ok(wt_thd_will_wait_for(& thds[X].thd, & thds[Y].thd, &resid[R]) == 0, \ + "thd[" #X "] will wait for thd[" #Y "]") +#define ok_deadlock(X,Y,R) \ + ok(wt_thd_will_wait_for(& thds[X].thd, & thds[Y].thd, &resid[R]) == WT_DEADLOCK, \ + "thd[" #X "] will wait for thd[" #Y "] - deadlock") + + ok_wait(0,1,0); + ok_wait(0,2,0); + ok_wait(0,3,0); + + pthread_mutex_lock(&lock); + bad= wt_thd_cond_timedwait(& thds[0].thd, &lock); + pthread_mutex_unlock(&lock); + ok(bad == WT_TIMEOUT, "timeout test returned %d", bad); + + ok_wait(0,1,0); + ok_wait(1,2,1); + ok_deadlock(2,0,2); + + pthread_mutex_lock(&lock); + ok(wt_thd_cond_timedwait(& thds[0].thd, &lock) == WT_TIMEOUT, "as always"); + ok(wt_thd_cond_timedwait(& thds[1].thd, &lock) == WT_TIMEOUT, "as always"); + wt_thd_release_all(& thds[0].thd); + wt_thd_release_all(& thds[1].thd); + wt_thd_release_all(& thds[2].thd); + wt_thd_release_all(& thds[3].thd); + + for (i=0; i < array_elements(resid); i++) + { + wt_thd_release_all(& thds[i].thd); + wt_thd_destroy(& thds[i].thd); + } + pthread_mutex_unlock(&lock); + } + + wt_deadlock_search_depth_short=6; + wt_timeout_short=1000; + wt_timeout_long= 100; + wt_deadlock_search_depth_long=16; + DBUG_PRINT("wt", ("================= stress test ===================")); + + diag("timeout_short=%lu us, deadlock_search_depth_short=%lu", + wt_timeout_short, wt_deadlock_search_depth_short); + diag("timeout_long=%lu us, deadlock_search_depth_long=%lu", + wt_timeout_long, wt_deadlock_search_depth_long); + +#ifndef _WIN32 +#define test_kill_strategy(X) \ + diag("kill strategy: " #X); \ + DBUG_EXECUTE("reset_file", \ + { rewind(DBUG_FILE); my_chsize(fileno(DBUG_FILE), 0, 0, MYF(MY_WME)); }); \ + DBUG_PRINT("info", ("kill strategy: " #X)); \ + kill_strategy=X; \ + do_one_test(); +#else +#define test_kill_strategy(X) \ + diag("kill strategy: " #X); \ + DBUG_PRINT("info", ("kill strategy: " #X)); \ + kill_strategy=X; \ + do_one_test(); +#endif + + test_kill_strategy(LATEST); + test_kill_strategy(RANDOM); + test_kill_strategy(YOUNGEST); + test_kill_strategy(LOCKS); + + DBUG_PRINT("wt", ("================= cleanup ===================")); + for (cnt=0; cnt < THREADS; cnt++) + pthread_mutex_destroy(& thds[cnt].lock); + wt_end(); + pthread_mutex_destroy(&lock); + pthread_cond_destroy(&thread_sync); + DBUG_VOID_RETURN; +} + diff --git a/unittest/mytap/CMakeLists.txt b/unittest/mytap/CMakeLists.txt index c4f213e338a..063c69eb925 100644 --- a/unittest/mytap/CMakeLists.txt +++ b/unittest/mytap/CMakeLists.txt @@ -1,4 +1,4 @@ -# Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 2007 MySQL AB, 2010 Oracle and/or its affiliates. All rights reserved. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -11,7 +11,7 @@ # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software -# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include) ADD_LIBRARY(mytap tap.c) diff --git a/unittest/mytap/t/basic-t.c b/unittest/mytap/t/basic-t.c index dcb13b20f11..9a909baba96 100644 --- a/unittest/mytap/t/basic-t.c +++ b/unittest/mytap/t/basic-t.c @@ -1,4 +1,5 @@ -/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. +/* + Copyright (c) 2006, 2010, Oracle and/or its affiliates This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by diff --git a/unittest/mytap/tap.c b/unittest/mytap/tap.c index f7a6d881421..ad08789a275 100644 --- a/unittest/mytap/tap.c +++ b/unittest/mytap/tap.c @@ -1,4 +1,5 @@ -/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. +/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. + Copyright (c) 2011, Monty Program Ab This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -27,6 +28,10 @@ #include <string.h> #include <signal.h> +static ulong start_timer(void); +static void end_timer(ulong start_time,char *buff); +static void nice_time(double sec,char *buff,my_bool part_second); + /* Visual Studio 2003 does not know vsnprintf but knows _vsnprintf. We don't put this #define elsewhere because we prefer my_vsnprintf @@ -126,7 +131,7 @@ emit_endl() static void handle_core_signal(int signo) { - BAIL_OUT("Signal %d thrown", signo); + BAIL_OUT("Signal %d thrown\n", signo); } void @@ -136,6 +141,8 @@ BAIL_OUT(char const *fmt, ...) va_start(ap, fmt); fprintf(tapout, "Bail out! "); vfprintf(tapout, fmt, ap); + diag("%d tests planned, %d failed, %d was last executed", + g_test.plan, g_test.failed, g_test.last); emit_endl(); va_end(ap); exit(255); @@ -159,6 +166,7 @@ typedef struct signal_entry { } signal_entry; static signal_entry install_signal[]= { + { SIGINT, handle_core_signal }, { SIGQUIT, handle_core_signal }, { SIGILL, handle_core_signal }, { SIGABRT, handle_core_signal }, @@ -182,6 +190,7 @@ static signal_entry install_signal[]= { }; int skip_big_tests= 1; +ulong start_time= 0; void plan(int count) @@ -189,6 +198,8 @@ plan(int count) char *config= getenv("MYTAP_CONFIG"); size_t i; + start_time= start_timer(); + if (config) skip_big_tests= strcmp(config, "big"); @@ -263,7 +274,7 @@ ok1(int const pass) } void -skip(int how_many, char const *fmt, ...) +skip(int how_many, char const * const fmt, ...) { char reason[80]; if (fmt && *fmt) @@ -286,6 +297,7 @@ skip(int how_many, char const *fmt, ...) } } + void todo_start(char const *message, ...) { @@ -301,7 +313,10 @@ todo_end() *g_test.todo = '\0'; } -int exit_status() { +int exit_status() +{ + char buff[60]; + /* If there were no plan, we write one last instead. */ @@ -320,10 +335,79 @@ int exit_status() { diag("Failed %d tests!", g_test.failed); return EXIT_FAILURE; } + if (start_time) + { + end_timer(start_time, buff); + printf("Test took %s\n", buff); + fflush(stdout); + } return EXIT_SUCCESS; } +#if defined(__WIN__) || defined(__NETWARE__) +#include <time.h> +#else +#include <sys/times.h> +#ifdef _SC_CLK_TCK // For mit-pthreads +#undef CLOCKS_PER_SEC +#define CLOCKS_PER_SEC (sysconf(_SC_CLK_TCK)) +#endif +#endif + +static ulong start_timer(void) +{ +#if defined(__WIN__) || defined(__NETWARE__) + return clock(); +#else + struct tms tms_tmp; + return times(&tms_tmp); +#endif +} + + +/** + Write as many as 52+1 bytes to buff, in the form of a legible + duration of time. + + len("4294967296 days, 23 hours, 59 minutes, 60.00 seconds") -> 52 +*/ + +static void nice_time(double sec,char *buff, my_bool part_second) +{ + ulong tmp; + if (sec >= 3600.0*24) + { + tmp=(ulong) (sec/(3600.0*24)); + sec-=3600.0*24*tmp; + buff+= sprintf(buff, "%ld %s", tmp, tmp > 1 ? " days " : " day "); + } + if (sec >= 3600.0) + { + tmp=(ulong) (sec/3600.0); + sec-=3600.0*tmp; + buff+= sprintf(buff, "%ld %s", tmp, tmp > 1 ? " hours " : " hour "); + } + if (sec >= 60.0) + { + tmp=(ulong) (sec/60.0); + sec-=60.0*tmp; + buff+= sprintf(buff, "%ld min ", tmp); + } + if (part_second) + sprintf(buff,"%.2f sec",sec); + else + sprintf(buff,"%d sec",(int) sec); +} + + +static void end_timer(ulong start_time,char *buff) +{ + nice_time((double) (start_timer() - start_time) / + CLOCKS_PER_SEC,buff,1); +} + + /** @mainpage Testing C and C++ using MyTAP diff --git a/unittest/mytap/tap.h b/unittest/mytap/tap.h index 60d39c42441..55f74f5fa02 100644 --- a/unittest/mytap/tap.h +++ b/unittest/mytap/tap.h @@ -1,4 +1,4 @@ -/* Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. +/* Copyright (c) 2006, 2010, Oracle and/or its affiliates This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -106,7 +106,7 @@ extern int skip_big_tests; @param count The planned number of tests to run. */ -void plan(int const count); +void plan(int count); /** @@ -125,7 +125,7 @@ void plan(int const count); use ok1() in this case. */ -void ok(int const pass, char const *fmt, ...) +void ok(int pass, char const *fmt, ...) __attribute__((format(printf,2,3))); diff --git a/unittest/strings/CMakeLists.txt b/unittest/strings/CMakeLists.txt new file mode 100644 index 00000000000..10791edfb61 --- /dev/null +++ b/unittest/strings/CMakeLists.txt @@ -0,0 +1,3 @@ + +MY_ADD_TESTS(strings LINK_LIBRARIES strings) + diff --git a/unittest/strings/strings-t.c b/unittest/strings/strings-t.c index ba1e625b358..7e61cb8722e 100644 --- a/unittest/strings/strings-t.c +++ b/unittest/strings/strings-t.c @@ -1,4 +1,4 @@ -/* Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved. +/* Copyright (c) 2010, Oracle and/or its affiliates This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -87,7 +87,9 @@ static CHARSET_INFO *charset_list[]= #endif #ifdef HAVE_CHARSET_utf8 &my_charset_utf8_general_ci, +#ifdef HAVE_HAVE_UCA_COLLATIONS &my_charset_utf8_unicode_ci, +#endif &my_charset_utf8_bin, #endif }; diff --git a/unittest/unit.pl b/unittest/unit.pl index 81941d9fdd8..fe45ece4233 100644 --- a/unittest/unit.pl +++ b/unittest/unit.pl @@ -79,7 +79,7 @@ sub _find_test_files (@) { my @dirs = @_; my @files; find sub { - $File::Find::prune = 1 if /^SCCS$/; + $File::Find::prune = 1 if /^(SCCS|\.libs)$/; push(@files, $File::Find::name) if -x _ && (/-t\z/ || /-t\.exe\z/); }, @dirs; return @files; @@ -127,8 +127,9 @@ sub run_cmd (@) { { $ENV{'HARNESS_VERBOSE'} = $opt_verbose; $ENV{'HARNESS_PERL_SWITCHES'} .= ' -e "exec @ARGV"'; + $ENV{'HARNESS_OPTIONS'}="j4"; + $Test::Harness::Timer = 1; runtests(@files); } } } - |