« back to all changes in this revision
Viewing changes to client/drizzletest.cc
- browse files at revision 2338
- compare with another revision
- compare with revision 2318.6.13
- download diff
- download tarball
- view history from revision 2338
- Committer: Mark Atwood
- Date: 2011-06-16 15:05:43 UTC
- mfrom: (2318.4.15 refactor10)
- Revision ID: me@mark.atwood.name-20110616150543-ydrgmzb685nzcjr9
merge lp:~olafvdspek/drizzle/refactor10
- files modified:
- client/drizzletest.cc
added
removed
client/drizzletest.cc
660
660
fprintf(stderr, "\n\n");
661
661
}
662
662
drizzle_result_free(&res);
663
664
return;
665
663
}
666
664
667
665
905
903
free(i.second);
906
904
}
907
905
var_hash.clear();
908
BOOST_FOREACH(vector<st_command*>::reference i, q_lines)
906
BOOST_FOREACH(st_command* i, q_lines)
909
907
delete i;
910
908
for (size_t i= 0; i < var_reg.size(); i++)
911
909
{
919
917
920
918
static void cleanup_and_exit(int exit_code)
921
919
{
922
free_used_memory();
923
internal::my_end();
920
if (0) // Olaf: Freeing resources is unnecessary when exiting
921
{
922
free_used_memory();
923
internal::my_end();
924
}
924
925
925
if (!silent) {
926
switch (exit_code) {
926
if (!silent)
927
{
928
switch (exit_code)
929
{
927
930
case 1:
928
931
printf("not ok\n");
929
932
break;
935
938
break;
936
939
default:
937
940
printf("unknown exit code: %d\n", exit_code);
938
assert(0);
941
assert(false);
939
942
}
940
943
}
941
944
exit(exit_code);
1100
1103
{
1101
1104
va_list args;
1102
1105
char buff[1024];
1103
size_t len;
1104
1105
1106
1106
1107
va_start(args, fmt);
1107
len= vsnprintf(buff, sizeof(buff)-1, fmt, args);
1108
size_t len= vsnprintf(buff, sizeof(buff)-1, fmt, args);
1108
1109
va_end(args);
1109
1110
1110
1111
ds_res.append(buff, len);
1111
1112
ds_res.append("\n");
1112
1113
return;
1114
1113
}
1115
1114
1116
1115
1126
1125
1127
1126
static void cat_file(string* ds, const char* filename)
1128
1127
{
1129
int fd;
1130
uint32_t len;
1131
char buff[512];
1132
1133
if ((fd= internal::my_open(filename, O_RDONLY, MYF(0))) < 0)
1128
int fd= internal::my_open(filename, O_RDONLY, MYF(0));
1129
if (fd < 0)
1134
1130
die("Failed to open file '%s'", filename);
1135
while((len= internal::my_read(fd, (unsigned char*)&buff,
1136
sizeof(buff), MYF(0))) > 0)
1131
uint32_t len;
1132
char buff[512];
1133
1134
while((len= internal::my_read(fd, (unsigned char*)&buff, sizeof(buff), MYF(0))) > 0)
1137
1135
{
1138
1136
char *p= buff, *start= buff;
1139
1137
while (p < buff+len)
1168
1166
1169
1167
*/
1170
1168
1171
static int run_command(const char * cmd, string * result)
1169
static int run_command(const char* cmd, string& result)
1172
1170
{
1173
assert(result!=NULL);
1171
FILE* res_file= popen(cmd, "r");
1172
if (not res_file)
1173
die("popen(\"%s\", \"r\") failed", cmd);
1174
1174
1175
char buf[512]= {0};
1175
FILE *res_file;
1176
int error;
1177
1178
if (!(res_file= popen(cmd, "r")))
1179
die("popen(\"%s\", \"r\") failed", cmd);
1180
1181
1176
while (fgets(buf, sizeof(buf), res_file))
1182
1177
{
1183
1178
/* Save the output of this command in the supplied string */
1184
result->append(buf);
1179
result.append(buf);
1185
1180
}
1186
1187
error= pclose(res_file);
1181
int error= pclose(res_file);
1188
1182
return WEXITSTATUS(error);
1189
1183
}
1190
1184
1201
1195
1202
1196
*/
1203
1197
1204
static int run_tool(const char *tool_path, string * result, ...)
1198
static int run_tool(const char *tool_path, string& result, ...)
1205
1199
{
1206
int ret;
1207
const char* arg;
1208
va_list args;
1209
1200
string ds_cmdline;
1210
1211
1212
1201
append_os_quoted(&ds_cmdline, tool_path, NULL);
1213
1202
ds_cmdline.append(" ");
1214
1203
1204
va_list args;
1215
1205
va_start(args, result);
1216
1217
while ((arg= va_arg(args, char *)))
1206
while (const char* arg= va_arg(args, char *))
1218
1207
{
1219
1208
/* Options should be os quoted */
1220
1209
if (strncmp(arg, "--", 2) == 0)
1226
1215
1227
1216
va_end(args);
1228
1217
1229
ret= run_command(ds_cmdline.c_str(), result);
1230
return(ret);
1218
return run_command(ds_cmdline.c_str(), result);
1231
1219
}
1232
1220
1233
1221
1252
1240
1253
1241
/* First try with unified diff */
1254
1242
if (run_tool("diff",
1255
&ds_tmp, /* Get output from diff in ds_tmp */
1243
ds_tmp, /* Get output from diff in ds_tmp */
1256
1244
"-u",
1257
1245
filename1,
1258
1246
filename2,
1262
1250
1263
1251
/* Fallback to context diff with "diff -c" */
1264
1252
if (run_tool("diff",
1265
&ds_tmp, /* Get output from diff in ds_tmp */
1253
ds_tmp, /* Get output from diff in ds_tmp */
1266
1254
"-c",
1267
1255
filename1,
1268
1256
filename2,
1273
1261
Fallback to dump both files to result file and inform
1274
1262
about installing "diff"
1275
1263
*/
1276
ds_tmp.clear();
1277
1278
ds_tmp.append(
1264
ds_tmp=
1279
1265
"\n"
1280
1266
"The two files differ but it was not possible to execute 'diff' in\n"
1281
1267
"order to show only the difference, tried both 'diff -u' or 'diff -c'.\n"
1282
"Instead the whole content of the two files was shown for you to diff manually. ;)\n\n"
1268
"Instead the whole content of the two files was shown for you to diff manually. ;)\n"
1269
"\n"
1283
1270
"To get a better report you should install 'diff' on your system, which you\n"
1284
1271
"for example can get from http://www.gnu.org/software/diffutils/diffutils.html\n"
1285
"\n");
1272
"\n";
1286
1273
1287
1274
ds_tmp.append(" --- ");
1288
1275
ds_tmp.append(filename1);
1299
1286
if (ds)
1300
1287
{
1301
1288
/* Add the diff to output */
1302
ds->append(ds_tmp.c_str(), ds_tmp.length());
1289
*ds += ds_tmp;
1303
1290
}
1304
1291
else
1305
1292
{
1309
1296
1310
1297
}
1311
1298
1312
1313
enum compare_files_result_enum {
1299
enum compare_files_result_enum
1300
{
1314
1301
RESULT_OK= 0,
1315
1302
RESULT_CONTENT_MISMATCH= 1,
1316
1303
RESULT_LENGTH_MISMATCH= 2
1333
1320
static int compare_files2(int fd, const char* filename2)
1334
1321
{
1335
1322
int error= RESULT_OK;
1336
int fd2;
1337
1323
uint32_t len, len2;
1338
1324
char buff[512], buff2[512];
1339
1325
const char *fname= filename2;
1340
1326
string tmpfile;
1341
1327
1342
if ((fd2= internal::my_open(fname, O_RDONLY, MYF(0))) < 0)
1328
int fd2= internal::my_open(fname, O_RDONLY, MYF(0));
1329
if (fd2 < 0)
1343
1330
{
1344
1331
internal::my_close(fd, MYF(0));
1345
1332
if (! opt_testdir.empty())
1431
1418
1432
1419
static int string_cmp(string* ds, const char *fname)
1433
1420
{
1434
int error;
1435
int fd;
1436
1421
char temp_file_path[FN_REFLEN];
1437
1422
1438
if ((fd= internal::create_temp_file(temp_file_path, TMPDIR,
1439
"tmp", MYF(MY_WME))) < 0)
1423
int fd= internal::create_temp_file(temp_file_path, TMPDIR, "tmp", MYF(MY_WME));
1424
if (fd < 0)
1440
1425
die("Failed to create temporary file for ds");
1441
1426
1442
1427
/* Write ds to temporary file and set file pos to beginning*/
1443
if (internal::my_write(fd, (unsigned char *) ds->c_str(), ds->length(),
1444
MYF(MY_FNABP | MY_WME)) ||
1428
if (internal::my_write(fd, (unsigned char *) ds->c_str(), ds->length(), MYF(MY_FNABP | MY_WME)) ||
1445
1429
lseek(fd, 0, SEEK_SET) == MY_FILEPOS_ERROR)
1446
1430
{
1447
1431
internal::my_close(fd, MYF(0));
1450
1434
die("Failed to write file '%s'", temp_file_path);
1451
1435
}
1452
1436
1453
error= compare_files2(fd, fname);
1437
int error= compare_files2(fd, fname);
1454
1438
1455
1439
internal::my_close(fd, MYF(0));
1456
1440
/* Remove the temporary file */
1457
1441
internal::my_delete(temp_file_path, MYF(0));
1458
1442
1459
return(error);
1443
return error;
1460
1444
}
1461
1445
1462
1446
1476
1460
{
1477
1461
const char* mess= "Result content mismatch\n";
1478
1462
1479
1480
assert(result_file_name.c_str());
1481
1482
1463
if (access(result_file_name.c_str(), F_OK) != 0)
1483
1464
die("The specified result file does not exist: '%s'", result_file_name.c_str());
1484
1465
1485
switch (string_cmp(ds, result_file_name.c_str())) {
1466
switch (string_cmp(ds, result_file_name.c_str()))
1467
{
1486
1468
case RESULT_OK:
1487
1469
break; /* ok */
1488
1470
case RESULT_LENGTH_MISMATCH:
1501
1483
if (access(reject_file, W_OK) == 0)
1502
1484
{
1503
1485
/* Result file directory is writable, save reject file there */
1504
internal::fn_format(reject_file, result_file_name.c_str(), NULL,
1505
".reject", MY_REPLACE_EXT);
1486
internal::fn_format(reject_file, result_file_name.c_str(), NULL, ".reject", MY_REPLACE_EXT);
1506
1487
}
1507
1488
else
1508
1489
{
1509
1490
/* Put reject file in opt_logdir */
1510
internal::fn_format(reject_file, result_file_name.c_str(), opt_logdir.c_str(),
1511
".reject", MY_REPLACE_DIR | MY_REPLACE_EXT);
1491
internal::fn_format(reject_file, result_file_name.c_str(), opt_logdir.c_str(), ".reject", MY_REPLACE_DIR | MY_REPLACE_EXT);
1512
1492
}
1513
1493
str_to_file(reject_file, ds->c_str(), ds->length());
1514
1494
1521
1501
default: /* impossible */
1522
1502
die("Unknown error code from dyn_string_cmp()");
1523
1503
}
1524
1525
return;
1526
1504
}
1527
1505
1528
1506
1543
1521
1544
1522
static void check_require(string* ds, const string &fname)
1545
1523
{
1546
1547
1548
1524
if (string_cmp(ds, fname.c_str()))
1549
1525
{
1550
1526
char reason[FN_REFLEN];
1551
1527
internal::fn_format(reason, fname.c_str(), "", "", MY_REPLACE_EXT | MY_REPLACE_DIR);
1552
1528
abort_not_supported_test("Test requires: '%s'", reason);
1553
1529
}
1554
return;
1555
1530
}
1556
1531
1557
1532
1857
1832
and assign that string to the $variable
1858
1833
*/
1859
1834
string result;
1860
uint32_t i;
1861
size_t *lengths;
1862
1863
lengths= drizzle_row_field_sizes(&res);
1864
for (i= 0; i < drizzle_result_column_count(&res); i++)
1835
size_t* lengths= drizzle_row_field_sizes(&res);
1836
for (uint32_t i= 0; i < drizzle_result_column_count(&res); i++)
1865
1837
{
1866
1838
if (row[i])
1867
1839
{
1905
1877
1906
1878
static void var_set_query_get_value(st_command* command, VAR *var)
1907
1879
{
1908
long row_no;
1909
1880
int col_no= -1;
1910
1881
drizzle_result_st res;
1911
1882
drizzle_return_t ret;
1928
1899
',');
1929
1900
1930
1901
/* Convert row number to int */
1931
row_no= atoi(ds_row.c_str());
1902
long row_no= atoi(ds_row.c_str());
1932
1903
1933
1904
istringstream buff(ds_row);
1934
1905
if ((buff >> row_no).fail())
1936
1907
1937
1908
/* Remove any surrounding "'s from the query - if there is any */
1938
1909
// (Don't get me started on this)
1939
char * unstripped_query= strdup(ds_query.c_str());
1910
char* unstripped_query= strdup(ds_query.c_str());
1940
1911
if (strip_surrounding(unstripped_query, '"', '"'))
1941
1912
die("Mismatched \"'s around query '%s'", ds_query.c_str());
1942
ds_query.clear();
1943
ds_query.append(unstripped_query);
1913
ds_query= unstripped_query;
1944
1914
1945
1915
/* Run the query */
1946
if (drizzle_query(con, &res, ds_query.c_str(), ds_query.length(),
1947
&ret) == NULL ||
1916
if (drizzle_query(con, &res, ds_query.c_str(), ds_query.length(), &ret) == NULL ||
1948
1917
ret != DRIZZLE_RETURN_OK)
1949
1918
{
1950
1919
if (ret == DRIZZLE_RETURN_ERROR_CODE)
1951
1920
{
1952
die("Error running query '%s': %d %s", ds_query.c_str(),
1953
drizzle_result_error_code(&res), drizzle_result_error(&res));
1921
die("Error running query '%s': %d %s", ds_query.c_str(), drizzle_result_error_code(&res), drizzle_result_error(&res));
1954
1922
drizzle_result_free(&res);
1955
1923
}
1956
1924
else
1957
1925
{
1958
die("Error running query '%s': %d %s", ds_query.c_str(), ret,
1959
drizzle_con_error(con));
1926
die("Error running query '%s': %d %s", ds_query.c_str(), ret, drizzle_con_error(con));
1960
1927
}
1961
1928
}
1962
1929
if (drizzle_result_column_count(&res) == 0 ||
1965
1932
1966
1933
{
1967
1934
/* Find column number from the given column name */
1968
uint32_t i;
1969
1935
uint32_t num_fields= drizzle_result_column_count(&res);
1970
drizzle_column_st *column;
1971
1972
for (i= 0; i < num_fields; i++)
1936
for (uint32_t i= 0; i < num_fields; i++)
1973
1937
{
1974
column= drizzle_column_next(&res);
1938
drizzle_column_st* column= drizzle_column_next(&res);
1975
1939
if (strcmp(drizzle_column_name(column), ds_col.c_str()) == 0 &&
1976
1940
strlen(drizzle_column_name(column)) == ds_col.length())
1977
1941
{
1989
1953
1990
1954
{
1991
1955
/* Get the value */
1992
drizzle_row_t row;
1993
1956
long rows= 0;
1994
1957
const char* value= "No such row";
1995
1958
1996
while ((row= drizzle_row_next(&res)))
1959
while (drizzle_row_t row= drizzle_row_next(&res))
1997
1960
{
1998
1961
if (++rows == row_no)
1999
1962
{
2155
2118
}
2156
2119
open_file(ds_filename.c_str());
2157
2120
}
2158
2159
return;
2160
2121
}
2161
2122
2162
2123
2401
2362
2402
2363
static void do_remove_file(st_command* command)
2403
2364
{
2404
int error;
2405
2365
string ds_filename;
2406
2366
const struct command_arg rm_args[] = {
2407
2367
{ "filename", ARG_STRING, true, &ds_filename, "File to delete" }
2412
2372
rm_args, sizeof(rm_args)/sizeof(struct command_arg),
2413
2373
' ');
2414
2374
2415
error= internal::my_delete(ds_filename.c_str(), MYF(0)) != 0;
2375
int error= internal::my_delete(ds_filename.c_str(), MYF(0)) != 0;
2416
2376
handle_command_error(command, error);
2417
2377
}
2418
2378
2431
2391
2432
2392
static void do_copy_file(st_command* command)
2433
2393
{
2434
int error;
2435
2394
string ds_from_file;
2436
2395
string ds_to_file;
2437
2396
const struct command_arg copy_file_args[] = {
2445
2404
sizeof(copy_file_args)/sizeof(struct command_arg),
2446
2405
' ');
2447
2406
2448
error= (internal::my_copy(ds_from_file.c_str(), ds_to_file.c_str(),
2407
int error= (internal::my_copy(ds_from_file.c_str(), ds_to_file.c_str(),
2449
2408
MYF(MY_DONT_OVERWRITE_FILE)) != 0);
2450
2409
handle_command_error(command, error);
2451
2410
}
2500
2459
2501
2460
static void do_file_exist(st_command* command)
2502
2461
{
2503
int error;
2504
2462
string ds_filename;
2505
2463
const struct command_arg file_exist_args[] = {
2506
2464
{ "filename", ARG_STRING, true, &ds_filename, "File to check if it exist" }
2512
2470
sizeof(file_exist_args)/sizeof(struct command_arg),
2513
2471
' ');
2514
2472
2515
error= (access(ds_filename.c_str(), F_OK) != 0);
2473
int error= access(ds_filename.c_str(), F_OK) != 0;
2516
2474
handle_command_error(command, error);
2517
2475
}
2518
2476
2530
2488
static void do_mkdir(st_command* command)
2531
2489
{
2532
2490
string ds_dirname;
2533
int error;
2534
2491
const struct command_arg mkdir_args[] = {
2535
2492
{"dirname", ARG_STRING, true, &ds_dirname, "Directory to create"}
2536
2493
};
2540
2497
mkdir_args, sizeof(mkdir_args)/sizeof(struct command_arg),
2541
2498
' ');
2542
2499
2543
error= mkdir(ds_dirname.c_str(), (0777 & internal::my_umask_dir)) != 0;
2500
int error= mkdir(ds_dirname.c_str(), (0777 & internal::my_umask_dir)) != 0;
2544
2501
handle_command_error(command, error);
2545
2502
}
2546
2503
2556
2513
2557
2514
static void do_rmdir(st_command* command)
2558
2515
{
2559
int error;
2560
2516
string ds_dirname;
2561
2517
const struct command_arg rmdir_args[] = {
2562
2518
{"dirname", ARG_STRING, true, &ds_dirname, "Directory to remove"}
2567
2523
rmdir_args, sizeof(rmdir_args)/sizeof(struct command_arg),
2568
2524
' ');
2569
2525
2570
error= rmdir(ds_dirname.c_str()) != 0;
2526
int error= rmdir(ds_dirname.c_str()) != 0;
2571
2527
handle_command_error(command, error);
2572
2528
}
2573
2529
2599
2555
static void read_until_delimiter(string *ds,
2600
2556
string *ds_delimiter)
2601
2557
{
2602
char c;
2603
2604
2558
if (ds_delimiter->length() > MAX_DELIMITER_LENGTH)
2605
2559
die("Max delimiter length(%d) exceeded", MAX_DELIMITER_LENGTH);
2606
2560
2607
2561
/* Read from file until delimiter is found */
2608
2562
while (1)
2609
2563
{
2610
c= my_getc(cur_file->file);
2564
char c= my_getc(cur_file->file);
2611
2565
2612
2566
if (c == '\n')
2613
2567
{
2635
2589
2636
2590
ds->push_back(c);
2637
2591
}
2638
return;
2639
2592
}
2640
2593
2641
2594
2667
2620
}
2668
2621
2669
2622
read_until_delimiter(&ds_content, &ds_delimiter);
2670
str_to_file2(ds_filename.c_str(), ds_content.c_str(),
2671
ds_content.length(), append);
2672
return;
2623
str_to_file2(ds_filename.c_str(), ds_content.c_str(), ds_content.length(), append);
2673
2624
}
2674
2625
2675
2626
2764
2715
' ');
2765
2716
2766
2717
cat_file(&ds_res, ds_filename.c_str());
2767
2768
return;
2769
2718
}
2770
2719
2771
2720
2783
2732
2784
2733
static void do_diff_files(st_command* command)
2785
2734
{
2786
int error= 0;
2787
2735
string ds_filename;
2788
2736
string ds_filename2;
2789
2737
const struct command_arg diff_file_args[] = {
2798
2746
sizeof(diff_file_args)/sizeof(struct command_arg),
2799
2747
' ');
2800
2748
2801
if ((error= compare_files(ds_filename.c_str(), ds_filename2.c_str())))
2749
int error= compare_files(ds_filename.c_str(), ds_filename2.c_str());
2750
if (error)
2802
2751
{
2803
2752
/* Compare of the two files failed, append them to output
2804
2753
so the failure can be analyzed
2812
2761
2813
2762
static st_connection * find_connection_by_name(const char *name)
2814
2763
{
2815
st_connection *con;
2816
for (con= g_connections; con < next_con; con++)
2764
for (st_connection* con= g_connections; con < next_con; con++)
2817
2765
{
2818
if (!strcmp(con->name, name))
2819
{
2766
if (not strcmp(con->name, name))
2820
2767
return con;
2821
}
2822
2768
}
2823
return 0; /* Connection not found */
2769
return NULL;
2824
2770
}
2825
2771
2826
2772
3036
2982
break;
3037
2983
usleep(SLAVE_POLL_INTERVAL);
3038
2984
}
3039
return;
3040
2985
}
3041
2986
3042
2987
static void do_sync_with_master2(long offset)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1