Skip to content

M
mariadb
Commit 7c927251 authored by unknown's avatar unknown
Browse files
Options

mysql_test_run_new.c: 

  Included header fnmatch.h on Unix
  Changed C++ comments to C comments
  Corrected indentation of code written on Windows
  Split up lines to fit into 80 columns
  Initiated some variables to avoid warnings
  Added __attribute__((unused)) to unused function parameters
  Replace tab characters with space
  Put space after 'for', 'while' etc
  Added value to 'return' from non void function removef()
  On Unix strlwr() was incorrectly declared and a no op,
  replaced it with a macro that does nothing
  Split several statements on the same line
  Other minor changes to conform to coding standard


mysql-test/mysql_test_run_new.c:
  Included header fnmatch.h on Unix
  Changed C++ comments to C comments
  Corrected indentation of code written on Windows
  Split up lines to fit into 80 columns
  Initiated some variables to avoid warnings
  Added __attribute__((unused)) to unused function parameters
  Replace tab characters with space
  Put space after 'for', 'while' etc
  Added value to 'return' from non void function removef()
  On Unix strlwr() was incorrectly declared and a no op,
  replaced it with a macro that does nothing
  Split several statements on the same line
  Other minor changes to conform to coding standard
parent 9bd7def3
Hide whitespace changes
Inline Side-by-side
Showing with 745 additions and 711 deletions
mysql-test/my_manage.c
View file @ 7c927251
......@@ -30,6 +30,7 @@
#ifndef __WIN__
#include <sys/wait.h>
#include <unistd.h>
#include <fnmatch.h>
#else
#include <direct.h>
#include <stdlib.h>
......@@ -52,36 +53,37 @@ extern char **environ;
/******************************************************************************
macros
macros
******************************************************************************/
/******************************************************************************
global variables
global variables
******************************************************************************/
/******************************************************************************
functions
functions
******************************************************************************/
/******************************************************************************
init_args()
Init an argument list.
init_args()
Init an argument list.
******************************************************************************/
void init_args(arg_list_t *al)
{
ASSERT(al != NULL);
al->argc = 0;
al->size = ARG_BUF;
al->argv = malloc(al->size * sizeof(char *));
al->argc= 0;
al->size= ARG_BUF;
al->argv= malloc(al->size * sizeof(char *));
ASSERT(al->argv != NULL);
return;
......@@ -89,11 +91,12 @@ void init_args(arg_list_t *al)
/******************************************************************************
add_arg()
Add an argument to a list.
add_arg()
Add an argument to a list.
******************************************************************************/
void add_arg(arg_list_t *al, const char *format, ...)
{
va_list ap;
......@@ -101,11 +104,11 @@ void add_arg(arg_list_t *al, const char *format, ...)
ASSERT(al != NULL);
// increase size
/* increase size */
if (al->argc >= (int)al->size)
{
al->size += ARG_BUF;
al->argv = realloc(al->argv, al->size * sizeof(char *));
al->size+= ARG_BUF;
al->argv= realloc(al->argv, al->size * sizeof(char *));
ASSERT(al->argv != NULL);
}
......@@ -115,7 +118,7 @@ void add_arg(arg_list_t *al, const char *format, ...)
vsprintf(temp, format, ap);
va_end(ap);
al->argv[al->argc] = malloc(strlen(temp)+1);
al->argv[al->argc]= malloc(strlen(temp)+1);
ASSERT(al->argv[al->argc] != NULL);
strcpy(al->argv[al->argc], temp);
......@@ -123,7 +126,7 @@ void add_arg(arg_list_t *al, const char *format, ...)
}
else
{
al->argv[al->argc] = NULL;
al->argv[al->argc]= NULL;
}
return;
......@@ -131,102 +134,108 @@ void add_arg(arg_list_t *al, const char *format, ...)
/******************************************************************************
free_args()
Free an argument list.
free_args()
Free an argument list.
******************************************************************************/
void free_args(arg_list_t *al)
{
int i;
ASSERT(al != NULL);
for(i = 0; i < al->argc; i++)
for (i= 0; i < al->argc; i++)
{
ASSERT(al->argv[i] != NULL);
free(al->argv[i]);
al->argv[i] = NULL;
al->argv[i]= NULL;
}
free(al->argv);
al->argc = 0;
al->argv = NULL;
al->argc= 0;
al->argv= NULL;
return;
}
/******************************************************************************
sleep_until_file_deleted()
Sleep until the given file is no longer found.
sleep_until_file_deleted()
Sleep until the given file is no longer found.
******************************************************************************/
#ifndef __WIN__
int sleep_until_file_deleted(char *pid_file)
#else
int sleep_until_file_deleted(HANDLE pid_file)
#endif
{
int err;
int err= 0; /* Initiate to supress warning */
#ifndef __WIN__
struct stat buf;
int i;
for(i = 0; (i < TRY_MAX) && (err = !stat(pid_file, &buf)); i++) sleep(1);
if (err != 0) err = errno;
struct stat buf;
int i;
for (i= 0; (i < TRY_MAX) && (err= !stat(pid_file, &buf)); i++) sleep(1);
if (err != 0) err= errno;
#else
err= (WaitForSingleObject(pid_file, TRY_MAX*1000) == WAIT_TIMEOUT);
#endif
return err;
return err;
}
/******************************************************************************
sleep_until_file_exists()
sleep_until_file_exists()
Sleep until the given file exists.
Sleep until the given file exists.
******************************************************************************/
#ifndef __WIN__
int sleep_until_file_exists(char *pid_file)
#else
int sleep_until_file_exists(HANDLE pid_file)
#endif
{
int err;
int err= 0; /* Initiate to supress warning */
#ifndef __WIN__
struct stat buf;
int i;
for(i = 0; (i < TRY_MAX) && (err = stat(pid_file, &buf)); i++) sleep(1);
if (err != 0) err = errno;
struct stat buf;
int i;
for (i= 0; (i < TRY_MAX) && (err= stat(pid_file, &buf)); i++) sleep(1);
if (err != 0) err= errno;
#else
err= (WaitForSingleObject(pid_file, TRY_MAX*1000) == WAIT_TIMEOUT);
#endif
return err;
return err;
}
/******************************************************************************
wait_for_server_start()
Wait for the server on the given port to start.
wait_for_server_start()
Wait for the server on the given port to start.
******************************************************************************/
int wait_for_server_start(char *bin_dir, char *mysqladmin_file, char *user, char *password, int port,char *tmp_dir)
int wait_for_server_start(char *bin_dir __attribute__((unused)),
char *mysqladmin_file,
char *user, char *password, int port,char *tmp_dir)
{
arg_list_t al;
int err, i;
int err= 0, i;
char trash[PATH_MAX];
// mysqladmin file
/* mysqladmin file */
snprintf(trash, PATH_MAX, "%s/trash.out",tmp_dir);
// args
/* args */
init_args(&al);
add_arg(&al, "%s", mysqladmin_file);
add_arg(&al, "--no-defaults");
......@@ -235,7 +244,7 @@ int wait_for_server_start(char *bin_dir, char *mysqladmin_file, char *user, char
add_arg(&al, "--password=%s", password);
add_arg(&al, "--silent");
//#ifdef NOT_USED
/* #ifdef NOT_USED */
#ifndef __NETWARE__
add_arg(&al, "-O");
add_arg(&al, "connect_timeout=10");
......@@ -245,20 +254,22 @@ int wait_for_server_start(char *bin_dir, char *mysqladmin_file, char *user, char
add_arg(&al, "--host=localhost");
#ifndef __NETWARE__
add_arg(&al, "--protocol=tcp");
#endif
#endif
add_arg(&al, "ping");
// NetWare does not support the connect timeout in the TCP/IP stack
// -- we will try the ping multiple times
/*
NetWare does not support the connect timeout in the TCP/IP stack
-- we will try the ping multiple times
*/
#ifndef __WIN__
for(i = 0; (i < TRY_MAX)
&& (err = spawn(mysqladmin_file, &al, TRUE, NULL,
trash, NULL, NULL)); i++) sleep(1);
for (i= 0; (i < TRY_MAX)
&& (err= spawn(mysqladmin_file, &al, TRUE, NULL,
trash, NULL, NULL)); i++) sleep(1);
#else
err = spawn(mysqladmin_file, &al, TRUE, NULL,trash, NULL, NULL);
err= spawn(mysqladmin_file, &al, TRUE, NULL,trash, NULL, NULL);
#endif
// free args
/* free args */
free_args(&al);
return err;
......@@ -266,38 +277,39 @@ int wait_for_server_start(char *bin_dir, char *mysqladmin_file, char *user, char
/******************************************************************************
spawn()
Spawn the given path with the given arguments.
spawn()
Spawn the given path with the given arguments.
******************************************************************************/
#ifdef __NETWARE__
int spawn(char *path, arg_list_t *al, int join, char *input,
char *output, char *error, char *pid_file)
{
pid_t pid;
int result = 0;
wiring_t wiring = { FD_UNUSED, FD_UNUSED, FD_UNUSED };
unsigned long flags = PROC_CURRENT_SPACE | PROC_INHERIT_CWD;
pid_t pid;
int result= 0;
wiring_t wiring= { FD_UNUSED, FD_UNUSED, FD_UNUSED };
unsigned long flags= PROC_CURRENT_SPACE | PROC_INHERIT_CWD;
// open wiring
/* open wiring */
if (input)
wiring.infd = open(input, O_RDONLY);
wiring.infd= open(input, O_RDONLY);
if (output)
wiring.outfd = open(output, O_WRONLY | O_CREAT | O_TRUNC);
wiring.outfd= open(output, O_WRONLY | O_CREAT | O_TRUNC);
if (error)
wiring.errfd = open(error, O_WRONLY | O_CREAT | O_TRUNC);
wiring.errfd= open(error, O_WRONLY | O_CREAT | O_TRUNC);
// procve requires a NULL
/* procve requires a NULL */
add_arg(al, NULL);
// go
pid = procve(path, flags, NULL, &wiring, NULL, NULL, 0,
NULL, (const char **)al->argv);
/* go */
pid= procve(path, flags, NULL, &wiring, NULL, NULL, 0,
NULL, (const char **)al->argv);
// close wiring
/* close wiring */
if (wiring.infd != -1)
close(wiring.infd);
......@@ -307,7 +319,7 @@ int spawn(char *path, arg_list_t *al, int join, char *input,
if (wiring.errfd != -1)
close(wiring.errfd);
return result;
return result;
}
#elif __WIN__
......@@ -322,18 +334,16 @@ int spawn(char *path, arg_list_t *al, int join, char *input,
char win_args[1024]= "";
char command_line[1024]= "";
/*
Skip the first parameter
*/
for(i = 1; i < al->argc; i++)
/* Skip the first parameter */
for (i= 1; i < al->argc; i++)
{
ASSERT(al->argv[i] != NULL);
strcat(win_args,al->argv[i]);
strcat(win_args," ");
}
}
memset(&startup_info,0,sizeof(STARTUPINFO));
startup_info.cb = sizeof(STARTUPINFO);
startup_info.cb= sizeof(STARTUPINFO);
if (input)
freopen(input, "rb", stdin);
......@@ -361,7 +371,8 @@ int spawn(char *path, arg_list_t *al, int join, char *input,
{
if (join)
{
if (WaitForSingleObject(process_information.hProcess, mysqld_timeout) == WAIT_TIMEOUT)
if (WaitForSingleObject(process_information.hProcess, mysqld_timeout)
== WAIT_TIMEOUT)
{
exit_code= -1;
}
......@@ -393,76 +404,60 @@ int spawn(char *path, arg_list_t *al, int join, char *input,
}
#else
int spawn(char *path, arg_list_t *al, int join, char *input,
char *output, char *error, char *pid_file)
char *output, char *error, char *pid_file __attribute__((unused)))
{
pid_t pid;
int res_exec = 0;
int result = 0;
pid = fork();
int res_exec= 0;
int result= 0;
pid= fork();
if (pid == -1)
{
fprintf(stderr, "fork was't created\n");
/*
We can't create the fork...exit with error
*/
return EXIT_FAILURE;
/* We can't create the fork...exit with error */
return EXIT_FAILURE;
}
if (pid > 0)
{
/*
The parent process is waiting for child process if join is not zero
*/
/* The parent process is waiting for child process if join is not zero */
if (join)
{
waitpid(pid, &result, 0);
if (WIFEXITED(result) != 0)
{
result = WEXITSTATUS(result);
}
else
{
result = EXIT_FAILURE;
}
}
waitpid(pid, &result, 0);
if (WIFEXITED(result) != 0)
{
result= WEXITSTATUS(result);
}
else
{
result= EXIT_FAILURE;
}
}
}
else
{
/*
Child process
*/
add_arg(al, NULL);
/* Child process */
add_arg(al, NULL);
/*
Reassign streams
*/
/* Reassign streams */
if (input)
freopen(input, "r", stdin);
freopen(input, "r", stdin);
if (output)
freopen(output, "w", stdout);
if (error)
freopen(error, "w", stderr);
/* Spawn the process */
if ((res_exec = execve(path, al->argv, environ)) < 0)
{
if ((res_exec= execve(path, al->argv, environ)) < 0)
exit(EXIT_FAILURE);
}
/*
Restore streams
*/
/* Restore streams */
if (input)
freopen("/dev/tty", "r", stdin);
freopen("/dev/tty", "r", stdin);
if (output)
freopen("/dev/tty", "w", stdout);
......@@ -472,32 +467,34 @@ int spawn(char *path, arg_list_t *al, int join, char *input,
exit(0);
}
return result;
}
#endif
/******************************************************************************
stop_server()
Stop the server with the given port and pid file.
stop_server()
Stop the server with the given port and pid file.
******************************************************************************/
int stop_server(char *bin_dir __attribute__((unused)), char *mysqladmin_file,
char *user, char *password, int port,
#ifndef __WIN__
int stop_server(char *bin_dir, char *mysqladmin_file, char *user, char *password, int port,
char *pid_file,char *tmp_dir)
char *pid_file,
#else
int stop_server(char *bin_dir, char *mysqladmin_file, char *user, char *password, int port,
HANDLE pid_file,char *tmp_dir)
HANDLE pid_file,
#endif
char *tmp_dir)
{
arg_list_t al;
int err = 0;
int err= 0;
char trash[PATH_MAX];
snprintf(trash, PATH_MAX, "%s/trash.out",tmp_dir);
// args
/* args */
init_args(&al);
add_arg(&al, "%s", mysqladmin_file);
add_arg(&al, "--no-defaults");
......@@ -508,33 +505,33 @@ int stop_server(char *bin_dir, char *mysqladmin_file, char *user, char *password
add_arg(&al, "shutdown_timeout=20");
#ifndef __NETWARE__
add_arg(&al, "--protocol=tcp");
#endif
#endif
add_arg(&al, "shutdown");
// spawn
if ((err = spawn(mysqladmin_file, &al, TRUE, NULL,
trash, NULL, NULL)) == 0)
/* spawn */
if ((err= spawn(mysqladmin_file, &al, TRUE, NULL,
trash, NULL, NULL)) == 0)
{
sleep_until_file_deleted(pid_file);
}
else
{
#ifndef __WIN__
pid_t pid = get_server_pid(pid_file);
// shutdown failed - kill server
pid_t pid= get_server_pid(pid_file);
/* shutdown failed - kill server */
kill_server(pid);
sleep(TRY_MAX);
// remove pid file if possible
err = remove(pid_file);
/* remove pid file if possible */
err= remove(pid_file);
#else
TerminateProcess(pid_file,err);
#endif
}
// free args
/* free args */
free_args(&al);
return err;
......@@ -542,57 +539,59 @@ int stop_server(char *bin_dir, char *mysqladmin_file, char *user, char *password
/******************************************************************************
get_server_pid()
Get the VM id with the given pid file.
get_server_pid()
Get the VM id with the given pid file.
******************************************************************************/
#ifndef __WIN__
pid_t get_server_pid(char *pid_file)
{
char buf[PATH_MAX];
int fd, err;
char *p;
pid_t id = 0;
// discover id
fd = open(pid_file, O_RDONLY);
err = read(fd, buf, PATH_MAX);
close(fd);
if (err > 0)
{
// terminate string
if ((p = strchr(buf, '\n')) != NULL)
{
*p = '\0';
// check for a '\r'
if ((p = strchr(buf, '\r')) != NULL)
{
*p = '\0';
}
}
else
{
buf[err] = '\0';
}
id = strtol(buf, NULL, 0);
}
pid_t id= 0;
/* discover id */
fd= open(pid_file, O_RDONLY);
err= read(fd, buf, PATH_MAX);
close(fd);
if (err > 0)
{
/* terminate string */
if ((p= strchr(buf, '\n')) != NULL)
{
*p= '\0';
/* check for a '\r' */
if ((p= strchr(buf, '\r')) != NULL)
{
*p= '\0';
}
}
else
{
buf[err]= '\0';
}
id= strtol(buf, NULL, 0);
}
return id;
}
/******************************************************************************
kill_server()
Force a kill of the server with the given pid.
kill_server()
Force a kill of the server with the given pid.
******************************************************************************/
void kill_server(pid_t pid)
{
if (pid > 0)
......@@ -603,51 +602,52 @@ void kill_server(pid_t pid)
#else /* __NETWARE__ */
/* destroy vm */
NXVmDestroy(pid);
#endif
#endif
}
}
#endif
/******************************************************************************
del_tree()
Delete the directory and subdirectories.
del_tree()
Delete the directory and subdirectories.
******************************************************************************/
void del_tree(char *dir)
{
#ifndef __WIN__
DIR *parent = opendir(dir);
DIR *parent= opendir(dir);
struct dirent *entry;
char temp[PATH_MAX];
if (parent == NULL)
{
return;
}
while((entry = readdir(parent)) != NULL)
while ((entry= readdir(parent)) != NULL)
{
// create long name
/* create long name */
snprintf(temp, PATH_MAX, "%s/%s", dir, entry->d_name);
if (entry->d_name[0] == '.')
{
// Skip
/* Skip */
}
else
else
if (S_ISDIR(entry->d_type))
{
// delete subdirectory
/* delete subdirectory */
del_tree(temp);
}
else
{
// remove file
/* remove file */
remove(temp);
}
}
// remove directory
/* remove directory */
rmdir(dir);
#else
struct _finddata_t parent;
......@@ -664,50 +664,51 @@ void del_tree(char *dir)
do
{
// create long name
snprintf(temp, PATH_MAX, "%s/%s", dir, parent.name);
/* create long name */
snprintf(temp, PATH_MAX, "%s/%s", dir, parent.name);
if (parent.name[0] == '.')
{
// Skip
/* Skip */
}
else
else
if (parent.attrib & _A_SUBDIR)
{
// delete subdirectory
/* delete subdirectory */
del_tree(temp);
}
else
{
// remove file
/* remove file */
remove(temp);
}
} while (_findnext(handle,&parent) == 0);
_findclose(handle);
// remove directory
/* remove directory */
_rmdir(dir);
#endif
}
/******************************************************************************
removef()
removef()
******************************************************************************/
int removef(const char *format, ...)
{
#ifdef __NETWARE__
#ifdef __NETWARE__
va_list ap;
char path[PATH_MAX];
va_start(ap, format);
vsnprintf(path, PATH_MAX, format, ap);
va_end(ap);
return remove(path);
#eldef __WIN__
{
va_list ap;
......@@ -716,25 +717,23 @@ int removef(const char *format, ...)
intptr_t handle;
char temp[PATH_MAX];
char *p;
va_start(ap, format);
vsnprintf(path, PATH_MAX, format, ap);
va_end(ap);
p = path + strlen(path);
p= path + strlen(path);
while (*p != '\\' && *p != '/' && p > path) p--;
if ((handle=_findfirst(path,&parent)) == -1L)
{
/*
if there is not files....it's ok.
*/
/* if there is not files....it's ok */
return 0;
}
*p = '\0';
*p= '\0';
do
{
......@@ -754,89 +753,80 @@ int removef(const char *format, ...)
va_list ap;
char path[PATH_MAX];
char *p;
/*
Get path with mask
*/
/* Get path with mask */
va_start(ap, format);
vsnprintf(path, PATH_MAX, format, ap);
va_end(ap);
p = path + strlen(path);
p= path + strlen(path);
while (*p != '\\' && *p != '/' && p > path) p--;
*p = '\0';
*p= '\0';
p++;
parent = opendir(path);
parent= opendir(path);
if (parent == NULL)
{
return;
return 1; /* Error, directory missing */
}
while((entry = readdir(parent)) != NULL)
while ((entry= readdir(parent)) != NULL)
{
/*
entry is not directory and entry matches with mask
*/
/* entry is not directory and entry matches with mask */
if (!S_ISDIR(entry->d_type) && !fnmatch(p, entry->d_name,0))
{
// create long name
/* create long name */
snprintf(temp, PATH_MAX, "%s/%s", path, entry->d_name);
// Delete only files
/* Delete only files */
remove(temp);
}
}
#endif
return 0;
return 0;
}
/******************************************************************************
get_basedir()
get_basedir()
******************************************************************************/
void get_basedir(char *argv0, char *basedir)
{
char temp[PATH_MAX];
char *p;
int position;
ASSERT(argv0 != NULL);
ASSERT(basedir != NULL);
strcpy(temp, strlwr(argv0));
while((p = strchr(temp, '\\')) != NULL) *p = '/';
if ((position = strinstr(temp, "/bin/")) != 0)
while ((p= strchr(temp, '\\')) != NULL) *p= '/';
if ((position= strinstr(temp, "/bin/")) != 0)
{
p = temp + position;
*p = '\0';
p= temp + position;
*p= '\0';
strcpy(basedir, temp);
}
}
#if !defined(__NETWARE__) && !defined(__WIN__)
char *strlwr(const char *s)
{
return s;
}
#endif
uint strinstr(reg1 const char *str,reg4 const char *search)
{
reg2 my_string i,j;
my_string start = (my_string) str;
my_string start= (my_string) str;
skipp:
while (*str != '\0')
{
if (*str++ == *search)
{
i=(my_string) str; j= (my_string) search+1;
i=(my_string) str;
j= (my_string) search+1;
while (*j)
if (*i++ != *j++) goto skipp;
if (*i++ != *j++) goto skipp;
return ((uint) (str - start));
}
}
......@@ -845,13 +835,14 @@ uint strinstr(reg1 const char *str,reg4 const char *search)
/******************************************************************************
remove_empty_file()
remove_empty_file()
******************************************************************************/
void remove_empty_file(const char *file_name)
{
struct stat file;
if (!stat(file_name,&file))
{
if (!file.st_size)
......
mysql-test/my_manage.h
View file @ 7c927251
......@@ -21,8 +21,8 @@
/******************************************************************************
includes
includes
******************************************************************************/
#include <stdlib.h>
......@@ -36,7 +36,7 @@
#ifndef __WIN__
#define strnicmp strncasecmp
char *strlwr(const char *s);
#define strlwr(STRARG) (STRARG)
#else
int my_vsnprintf_(char *to, size_t n, const char* value, ...);
#endif
......@@ -44,12 +44,12 @@ int my_vsnprintf_(char *to, size_t n, const char* value, ...);
/******************************************************************************
macros
macros
******************************************************************************/
#define ARG_BUF 10
#define TRY_MAX 5
#define ARG_BUF 10
#define TRY_MAX 5
#ifdef __WIN__
#define PATH_MAX _MAX_PATH
......@@ -71,8 +71,8 @@ bool skip_first_param;
/******************************************************************************
structures
structures
******************************************************************************/
typedef struct
......@@ -90,14 +90,14 @@ typedef int pid_t;
#endif
/******************************************************************************
global variables
global variables
******************************************************************************/
/******************************************************************************
prototypes
prototypes
******************************************************************************/
void init_args(arg_list_t *);
......
mysql-test/mysql_test_run_new.c
View file @ 7c927251
......@@ -21,7 +21,7 @@
#include <errno.h>
#ifndef __WIN__
#include <dirent.h>
#endif
#endif
#include <string.h>
#ifdef __NETWARE__
#include <screen.h>
......@@ -46,51 +46,52 @@
/******************************************************************************
macros
******************************************************************************/
#define HEADER "TEST RESULT \n"
#define DASH "-------------------------------------------------------\n"
#define NW_TEST_SUFFIX ".nw-test"
#define NW_RESULT_SUFFIX ".nw-result"
#define TEST_SUFFIX ".test"
#define RESULT_SUFFIX ".result"
#define REJECT_SUFFIX ".reject"
#define OUT_SUFFIX ".out"
#define ERR_SUFFIX ".err"
#define NW_TEST_SUFFIX ".nw-test"
#define NW_RESULT_SUFFIX ".nw-result"
#define TEST_SUFFIX ".test"
#define RESULT_SUFFIX ".result"
#define REJECT_SUFFIX ".reject"
#define OUT_SUFFIX ".out"
#define ERR_SUFFIX ".err"
const char *TEST_PASS = "[ pass ]";
const char *TEST_SKIP = "[ skip ]";
const char *TEST_FAIL = "[ fail ]";
const char *TEST_BAD = "[ bad ]";
const char *TEST_IGNORE = "[ignore]";
const char *TEST_PASS= "[ pass ]";
const char *TEST_SKIP= "[ skip ]";
const char *TEST_FAIL= "[ fail ]";
const char *TEST_BAD= "[ bad ]";
const char *TEST_IGNORE= "[ignore]";
/******************************************************************************
global variables
******************************************************************************/
#ifdef __NETWARE__
static char base_dir[PATH_MAX] = "sys:/mysql";
static char base_dir[PATH_MAX]= "sys:/mysql";
#else
static char base_dir[PATH_MAX] = "..";
static char base_dir[PATH_MAX]= "..";
#endif
static char db[PATH_MAX] = "test";
static char user[PATH_MAX] = "root";
static char password[PATH_MAX] = "";
static char db[PATH_MAX]= "test";
static char user[PATH_MAX]= "root";
static char password[PATH_MAX]= "";
int master_port = 9306;
int slave_port = 9307;
int master_port= 9306;
int slave_port= 9307;
#if !defined(__NETWARE__) && !defined(__WIN__)
static char master_socket[PATH_MAX] = "./var/tmp/master.sock";
static char slave_socket[PATH_MAX] = "./var/tmp/slave.sock";
static char master_socket[PATH_MAX]= "./var/tmp/master.sock";
static char slave_socket[PATH_MAX]= "./var/tmp/slave.sock";
#endif
// comma delimited list of tests to skip or empty string
/* comma delimited list of tests to skip or empty string */
#ifndef __WIN__
static char skip_test[PATH_MAX] = " lowercase_table3 , system_mysql_db_fix ";
static char skip_test[PATH_MAX]= " lowercase_table3 , system_mysql_db_fix ";
#else
/*
The most ignore testes contain the calls of system command
......@@ -109,9 +110,20 @@ static char skip_test[PATH_MAX] = " lowercase_table3 , system_mysql_db_fix ";
mysqldump contains a command system
rpl000001 makes non-exit loop...temporary skiped
*/
static char skip_test[PATH_MAX] = " lowercase_table3 , system_mysql_db_fix , sp , rpl_EE_error , rpl_loaddatalocal , ndb_autodiscover , rpl_rotate_logs , repair , rpl_trunc_binlog , mysqldump , rpl000001 ";
static char skip_test[PATH_MAX]=
" lowercase_table3 ,"
" system_mysql_db_fix ,"
" sp ,"
" rpl_EE_error ,"
" rpl_loaddatalocal ,"
" ndb_autodiscover ,"
" rpl_rotate_logs ,"
" repair ,"
" rpl_trunc_binlog ,"
" mysqldump ,"
" rpl000001 ";
#endif
static char ignore_test[PATH_MAX] = "";
static char ignore_test[PATH_MAX]= "";
static char bin_dir[PATH_MAX];
static char mysql_test_dir[PATH_MAX];
......@@ -129,54 +141,54 @@ static char mysqltest_file[PATH_MAX];
#ifndef __WIN__
static char master_pid[PATH_MAX];
static char slave_pid[PATH_MAX];
static char sh_file[PATH_MAX] = "/bin/sh";
static char sh_file[PATH_MAX]= "/bin/sh";
#else
static HANDLE master_pid;
static HANDLE slave_pid;
#endif
static char master_opt[PATH_MAX] = "";
static char slave_opt[PATH_MAX] = "";
static char master_opt[PATH_MAX]= "";
static char slave_opt[PATH_MAX]= "";
static char slave_master_info[PATH_MAX] = "";
static char slave_master_info[PATH_MAX]= "";
static char master_init_script[PATH_MAX] = "";
static char slave_init_script[PATH_MAX] = "";
static char master_init_script[PATH_MAX]= "";
static char slave_init_script[PATH_MAX]= "";
// OpenSSL
/* OpenSSL */
static char ca_cert[PATH_MAX];
static char server_cert[PATH_MAX];
static char server_key[PATH_MAX];
static char client_cert[PATH_MAX];
static char client_key[PATH_MAX];
int total_skip = 0;
int total_pass = 0;
int total_fail = 0;
int total_test = 0;
int total_skip= 0;
int total_pass= 0;
int total_fail= 0;
int total_test= 0;
int total_ignore = 0;
int total_ignore= 0;
int use_openssl = FALSE;
int master_running = FALSE;
int slave_running = FALSE;
int skip_slave = TRUE;
int single_test = TRUE;
int use_openssl= FALSE;
int master_running= FALSE;
int slave_running= FALSE;
int skip_slave= TRUE;
int single_test= TRUE;
int restarts = 0;
int restarts= 0;
FILE *log_fd = NULL;
FILE *log_fd= NULL;
/******************************************************************************
functions
******************************************************************************/
/******************************************************************************
prototypes
******************************************************************************/
void report_stats();
......@@ -205,10 +217,11 @@ void run_init_script(const char *script_name);
/******************************************************************************
report_stats()
Report the gathered statistics.
******************************************************************************/
void report_stats()
{
if (total_fail == 0)
......@@ -217,24 +230,26 @@ void report_stats()
}
else
{
double percent = ((double)total_pass / total_test) * 100;
double percent= ((double)total_pass / total_test) * 100;
mlog("\nFailed %u/%u test(s), %.02f%% successful.\n",
total_fail, total_test, percent);
mlog("\nThe .out and .err files in %s may give you some\n", result_dir);
mlog("hint of what when wrong.\n");
mlog("\nIf you want to report this error, please first read the documentation\n");
mlog("at: http://www.mysql.com/doc/M/y/MySQL_test_suite.html\n");
total_fail, total_test, percent);
mlog("\nThe .out and .err files in %s may give you some\n", result_dir);
mlog("hint of what when wrong.\n");
mlog("\nIf you want to report this error, please first read "
"the documentation\n");
mlog("at: http://www.mysql.com/doc/M/y/MySQL_test_suite.html\n");
}
}
/******************************************************************************
install_db()
Install the a database.
******************************************************************************/
void install_db(char *datadir)
{
arg_list_t al;
......@@ -243,16 +258,16 @@ void install_db(char *datadir)
char output[PATH_MAX];
char error[PATH_MAX];
// input file
#ifdef __NETWARE__
/* input file */
#ifdef __NETWARE__
snprintf(input, PATH_MAX, "%s/bin/init_db.sql", base_dir);
#else
snprintf(input, PATH_MAX, "%s/mysql-test/init_db.sql", base_dir);
#endif
#endif
snprintf(output, PATH_MAX, "%s/install.out", datadir);
snprintf(error, PATH_MAX, "%s/install.err", datadir);
// args
/* args */
init_args(&al);
add_arg(&al, mysqld_file);
add_arg(&al, "--no-defaults");
......@@ -265,39 +280,40 @@ void install_db(char *datadir)
#ifndef __NETWARE__
add_arg(&al, "--character-sets-dir=%s", char_dir);
add_arg(&al, "--language=%s", lang_dir);
#endif
#endif
// spawn
if ((err = spawn(mysqld_file, &al, TRUE, input, output, error, NULL)) != 0)
/* spawn */
if ((err= spawn(mysqld_file, &al, TRUE, input, output, error, NULL)) != 0)
{
die("Unable to create database.");
}
// free args
/* free args */
free_args(&al);
}
/******************************************************************************
mysql_install_db()
Install the test databases.
******************************************************************************/
void mysql_install_db()
{
char temp[PATH_MAX];
// var directory
/* var directory */
snprintf(temp, PATH_MAX, "%s/var", mysql_test_dir);
// clean up old direcotry
/* clean up old direcotry */
del_tree(temp);
// create var directory
/* create var directory */
#ifndef __WIN__
mkdir(temp, S_IRWXU);
// create subdirectories
/* create subdirectories */
mlog("Creating test-suite folders...\n");
snprintf(temp, PATH_MAX, "%s/var/run", mysql_test_dir);
mkdir(temp, S_IRWXU);
......@@ -317,7 +333,7 @@ void mysql_install_db()
mkdir(temp, S_IRWXU);
#else
mkdir(temp);
// create subdirectories
/* create subdirectories */
mlog("Creating test-suite folders...\n");
snprintf(temp, PATH_MAX, "%s/var/run", mysql_test_dir);
mkdir(temp);
......@@ -337,7 +353,7 @@ void mysql_install_db()
mkdir(temp);
#endif
// install databases
/* install databases */
mlog("Creating test databases for master... \n");
install_db(master_dir);
mlog("Creating test databases for slave... \n");
......@@ -347,49 +363,50 @@ void mysql_install_db()
/******************************************************************************
start_master()
Start the master server.
******************************************************************************/
void start_master()
{
arg_list_t al;
int err;
char master_out[PATH_MAX];
char master_err[PATH_MAX];
// char temp[PATH_MAX];
/* char temp[PATH_MAX]; */
char temp2[PATH_MAX];
// remove old berkeley db log files that can confuse the server
/* remove old berkeley db log files that can confuse the server */
removef("%s/log.*", master_dir);
// remove stale binary logs
/* remove stale binary logs */
removef("%s/var/log/*-bin.*", mysql_test_dir);
// remove stale binary logs
/* remove stale binary logs */
removef("%s/var/log/*.index", mysql_test_dir);
// remove master.info file
/* remove master.info file */
removef("%s/master.info", master_dir);
// remove relay files
/* remove relay files */
removef("%s/var/log/*relay*", mysql_test_dir);
// remove relay-log.info file
/* remove relay-log.info file */
removef("%s/relay-log.info", master_dir);
// init script
/* init script */
if (master_init_script[0] != 0)
{
#ifdef __NETWARE__
// TODO: use the scripts
/* TODO: use the scripts */
if (strinstr(master_init_script, "repair_part2-master.sh") != 0)
{
FILE *fp;
// create an empty index file
/* create an empty index file */
snprintf(temp, PATH_MAX, "%s/test/t1.MYI", master_dir);
fp = fopen(temp, "wb+");
fp= fopen(temp, "wb+");
fputs("1", fp);
......@@ -397,10 +414,10 @@ void start_master()
}
#elif !defined(__WIN__)
run_init_script(master_init_script);
#endif
#endif
}
// redirection files
/* redirection files */
snprintf(master_out, PATH_MAX, "%s/var/run/master%u.out",
mysql_test_dir, restarts);
snprintf(master_err, PATH_MAX, "%s/var/run/master%u.err",
......@@ -416,7 +433,7 @@ void start_master()
snprintf(temp2,PATH_MAX,"%s/var/log",mysql_test_dir);
mkdir(temp2);
#endif
// args
/* args */
init_args(&al);
add_arg(&al, "%s", mysqld_file);
add_arg(&al, "--no-defaults");
......@@ -426,7 +443,7 @@ void start_master()
add_arg(&al, "--port=%u", master_port);
#if !defined(__NETWARE__) && !defined(__WIN__)
add_arg(&al, "--socket=%s",master_socket);
#endif
#endif
add_arg(&al, "--local-infile");
add_arg(&al, "--core");
add_arg(&al, "--datadir=%s", master_dir);
......@@ -436,7 +453,7 @@ void start_master()
add_arg(&al, "--character-sets-dir=%s", char_dir);
add_arg(&al, "--tmpdir=%s", mysql_tmp_dir);
add_arg(&al, "--language=%s", lang_dir);
#ifdef DEBUG //only for debug builds
#ifdef DEBUG /* only for debug builds */
add_arg(&al, "--debug");
#endif
......@@ -447,11 +464,11 @@ void start_master()
add_arg(&al, "--ssl-key=%s", server_key);
}
// $MASTER_40_ARGS
/* $MASTER_40_ARGS */
add_arg(&al, "--rpl-recovery-rank=1");
add_arg(&al, "--init-rpl-role=master");
// $SMALL_SERVER
/* $SMALL_SERVER */
add_arg(&al, "-O");
add_arg(&al, "key_buffer_size=1M");
add_arg(&al, "-O");
......@@ -459,44 +476,46 @@ void start_master()
add_arg(&al, "-O");
add_arg(&al, "max_heap_table_size=1M");
// $EXTRA_MASTER_OPT
/* $EXTRA_MASTER_OPT */
if (master_opt[0] != 0)
{
char *p;
p = (char *)str_tok(master_opt, " \t");
p= (char *)str_tok(master_opt, " \t");
if (!strstr(master_opt, "timezone"))
{
while (p)
{
add_arg(&al, "%s", p);
p = (char *)str_tok(NULL, " \t");
p= (char *)str_tok(NULL, " \t");
}
}
}
// remove the pid file if it exists
/* remove the pid file if it exists */
#ifndef __WIN__
remove(master_pid);
#endif
// spawn
/* spawn */
#ifdef __WIN__
if ((err= spawn(mysqld_file, &al, FALSE, NULL, master_out, master_err, &master_pid)) == 0)
if ((err= spawn(mysqld_file, &al, FALSE, NULL,
master_out, master_err, &master_pid)) == 0)
#else
if ((err= spawn(mysqld_file, &al, FALSE, NULL, master_out, master_err, master_pid)) == 0)
#endif
if ((err= spawn(mysqld_file, &al, FALSE, NULL,
master_out, master_err, master_pid)) == 0)
#endif
{
sleep_until_file_exists(master_pid);
if ((err = wait_for_server_start(bin_dir, mysqladmin_file, user, password, master_port,
mysql_tmp_dir)) == 0)
if ((err= wait_for_server_start(bin_dir, mysqladmin_file, user, password,
master_port, mysql_tmp_dir)) == 0)
{
master_running = TRUE;
master_running= TRUE;
}
else
{
log_error("The master server went down early.");
log_error("The master server went down early.");
}
}
else
......@@ -504,17 +523,18 @@ void start_master()
log_error("Unable to start master server.");
}
// free_args
/* free_args */
free_args(&al);
}
/******************************************************************************
start_slave()
Start the slave server.
******************************************************************************/
void start_slave()
{
arg_list_t al;
......@@ -522,43 +542,43 @@ void start_slave()
char slave_out[PATH_MAX];
char slave_err[PATH_MAX];
// skip?
/* skip? */
if (skip_slave) return;
// remove stale binary logs
/* remove stale binary logs */
removef("%s/*-bin.*", slave_dir);
// remove stale binary logs
/* remove stale binary logs */
removef("%s/*.index", slave_dir);
// remove master.info file
/* remove master.info file */
removef("%s/master.info", slave_dir);
// remove relay files
/* remove relay files */
removef("%s/var/log/*relay*", mysql_test_dir);
// remove relay-log.info file
/* remove relay-log.info file */
removef("%s/relay-log.info", slave_dir);
// init script
/* init script */
if (slave_init_script[0] != 0)
{
#ifdef __NETWARE__
// TODO: use the scripts
/* TODO: use the scripts */
if (strinstr(slave_init_script, "rpl000016-slave.sh") != 0)
{
// create empty master.info file
/* create empty master.info file */
snprintf(temp, PATH_MAX, "%s/master.info", slave_dir);
close(open(temp, O_WRONLY | O_CREAT,S_IRWXU|S_IRWXG|S_IRWXO));
}
else if (strinstr(slave_init_script, "rpl000017-slave.sh") != 0)
{
FILE *fp;
// create a master.info file
/* create a master.info file */
snprintf(temp, PATH_MAX, "%s/master.info", slave_dir);
fp = fopen(temp, "wb+");
fp= fopen(temp, "wb+");
fputs("master-bin.000001\n", fp);
fputs("4\n", fp);
fputs("127.0.0.1\n", fp);
......@@ -572,22 +592,22 @@ void start_slave()
}
else if (strinstr(slave_init_script, "rpl_rotate_logs-slave.sh") != 0)
{
// create empty master.info file
/* create empty master.info file */
snprintf(temp, PATH_MAX, "%s/master.info", slave_dir);
close(open(temp, O_WRONLY | O_CREAT,S_IRWXU|S_IRWXG|S_IRWXO));
}
#elif !defined(__WIN__)
#elif !defined(__WIN__)
run_init_script(slave_init_script);
#endif
#endif
}
// redirection files
/* redirection files */
snprintf(slave_out, PATH_MAX, "%s/var/run/slave%u.out",
mysql_test_dir, restarts);
snprintf(slave_err, PATH_MAX, "%s/var/run/slave%u.err",
mysql_test_dir, restarts);
// args
/* args */
init_args(&al);
add_arg(&al, "%s", mysqld_file);
add_arg(&al, "--no-defaults");
......@@ -597,7 +617,7 @@ void start_slave()
add_arg(&al, "--port=%u", slave_port);
#if !defined(__NETWARE__) && !defined(__WIN__)
add_arg(&al, "--socket=%s",slave_socket);
#endif
#endif
add_arg(&al, "--datadir=%s", slave_dir);
#ifndef __WIN__
add_arg(&al, "--pid-file=%s", slave_pid);
......@@ -613,7 +633,7 @@ void start_slave()
add_arg(&al, "--skip-innodb");
add_arg(&al, "--skip-slave-start");
add_arg(&al, "--slave-load-tmpdir=../../var/tmp");
add_arg(&al, "--report-user=%s", user);
add_arg(&al, "--report-host=127.0.0.1");
add_arg(&al, "--report-port=%u", slave_port);
......@@ -621,7 +641,7 @@ void start_slave()
add_arg(&al, "--master-retry-count=10");
add_arg(&al, "-O");
add_arg(&al, "slave_net_timeout=10");
#ifdef DEBUG //only for debug builds
#ifdef DEBUG /* only for debug builds */
add_arg(&al, "--debug");
#endif
......@@ -632,18 +652,17 @@ void start_slave()
add_arg(&al, "--ssl-key=%s", server_key);
}
// slave master info
/* slave master info */
if (slave_master_info[0] != 0)
{
char *p;
p = (char *)str_tok(slave_master_info, " \t");
p= (char *)str_tok(slave_master_info, " \t");
while(p)
while (p)
{
add_arg(&al, "%s", p);
p = (char *)str_tok(NULL, " \t");
p= (char *)str_tok(NULL, " \t");
}
}
else
......@@ -656,8 +675,8 @@ void start_slave()
add_arg(&al, "--server-id=2");
add_arg(&al, "--rpl-recovery-rank=2");
}
// small server
/* small server */
add_arg(&al, "-O");
add_arg(&al, "key_buffer_size=1M");
add_arg(&al, "-O");
......@@ -666,38 +685,39 @@ void start_slave()
add_arg(&al, "max_heap_table_size=1M");
// opt args
/* opt args */
if (slave_opt[0] != 0)
{
char *p;
p = (char *)str_tok(slave_opt, " \t");
p= (char *)str_tok(slave_opt, " \t");
while(p)
while (p)
{
add_arg(&al, "%s", p);
p = (char *)str_tok(NULL, " \t");
p= (char *)str_tok(NULL, " \t");
}
}
// remove the pid file if it exists
/* remove the pid file if it exists */
#ifndef __WIN__
remove(slave_pid);
#endif
// spawn
#ifdef __WIN__
if ((err = spawn(mysqld_file, &al, FALSE, NULL, slave_out, slave_err, &slave_pid)) == 0)
/* spawn */
#ifdef __WIN__
if ((err= spawn(mysqld_file, &al, FALSE, NULL,
slave_out, slave_err, &slave_pid)) == 0)
#else
if ((err = spawn(mysqld_file, &al, FALSE, NULL, slave_out, slave_err, slave_pid)) == 0)
#endif
if ((err= spawn(mysqld_file, &al, FALSE, NULL,
slave_out, slave_err, slave_pid)) == 0)
#endif
{
sleep_until_file_exists(slave_pid);
if ((err = wait_for_server_start(bin_dir, mysqladmin_file, user, password, slave_port,
mysql_tmp_dir)) == 0)
if ((err= wait_for_server_start(bin_dir, mysqladmin_file, user, password,
slave_port, mysql_tmp_dir)) == 0)
{
slave_running = TRUE;
slave_running= TRUE;
}
else
{
......@@ -708,29 +728,30 @@ void start_slave()
{
log_error("Unable to start slave server.");
}
// free args
/* free args */
free_args(&al);
}
/******************************************************************************
mysql_start()
Start the mysql servers.
******************************************************************************/
void mysql_start()
{
// log_info("Starting the MySQL server(s): %u", ++restarts);
/* log_info("Starting the MySQL server(s): %u", ++restarts); */
start_master();
start_slave();
// activate the test screen
#ifdef __NETWARE__
/* activate the test screen */
#ifdef __NETWARE__
ActivateScreen(getscreenhandle());
#endif
#endif
}
/******************************************************************************
......@@ -740,18 +761,19 @@ void mysql_start()
Stop the slave server.
******************************************************************************/
void stop_slave()
{
int err;
// running?
/* running? */
if (!slave_running) return;
// stop
if ((err = stop_server(bin_dir, mysqladmin_file, user, password, slave_port, slave_pid,
mysql_tmp_dir)) == 0)
/* stop */
if ((err= stop_server(bin_dir, mysqladmin_file, user, password,
slave_port, slave_pid, mysql_tmp_dir)) == 0)
{
slave_running = FALSE;
slave_running= FALSE;
}
else
{
......@@ -766,17 +788,18 @@ void stop_slave()
Stop the master server.
******************************************************************************/
void stop_master()
{
int err;
// running?
/* running? */
if (!master_running) return;
if ((err = stop_server(bin_dir, mysqladmin_file, user, password, master_port, master_pid,
mysql_tmp_dir)) == 0)
if ((err= stop_server(bin_dir, mysqladmin_file, user, password,
master_port, master_pid, mysql_tmp_dir)) == 0)
{
master_running = FALSE;
master_running= FALSE;
}
else
{
......@@ -791,6 +814,7 @@ void stop_master()
Stop the mysql servers.
******************************************************************************/
void mysql_stop()
{
......@@ -798,10 +822,10 @@ void mysql_stop()
stop_slave();
// activate the test screen
#ifdef __NETWARE__
/* activate the test screen */
#ifdef __NETWARE__
ActivateScreen(getscreenhandle());
#endif
#endif
}
/******************************************************************************
......@@ -811,9 +835,10 @@ void mysql_stop()
Restart the mysql servers.
******************************************************************************/
void mysql_restart()
{
// log_info("Restarting the MySQL server(s): %u", ++restarts);
/* log_info("Restarting the MySQL server(s): %u", ++restarts); */
mysql_stop();
......@@ -829,55 +854,52 @@ void mysql_restart()
Read the option file.
******************************************************************************/
int read_option(char *opt_file, char *opt)
{
int fd, err;
char *p;
char buf[PATH_MAX];
// copy current option
/* copy current option */
strncpy(buf, opt, PATH_MAX);
// open options file
fd = open(opt_file, O_RDONLY);
err = read(fd, opt, PATH_MAX);
/* open options file */
fd= open(opt_file, O_RDONLY);
err= read(fd, opt, PATH_MAX);
close(fd);
if (err > 0)
{
// terminate string
if ((p = strchr(opt, '\n')) != NULL)
/* terminate string */
if ((p= strchr(opt, '\n')) != NULL)
{
*p = 0;
// check for a '\r'
if ((p = strchr(opt, '\r')) != NULL)
*p= 0;
/* check for a '\r' */
if ((p= strchr(opt, '\r')) != NULL)
{
*p = 0;
*p= 0;
}
}
else
{
opt[err] = 0;
opt[err]= 0;
}
// check for $MYSQL_TEST_DIR
if ((p = strstr(opt, "$MYSQL_TEST_DIR")) != NULL)
/* check for $MYSQL_TEST_DIR */
if ((p= strstr(opt, "$MYSQL_TEST_DIR")) != NULL)
{
char temp[PATH_MAX];
*p = 0;
*p= 0;
strcpy(temp, p + strlen("$MYSQL_TEST_DIR"));
strcat(opt, mysql_test_dir);
strcat(opt, temp);
}
// Check for double backslash and replace it with single bakslash
if ((p = strstr(opt, "\\\\")) != NULL)
/* Check for double backslash and replace it with single bakslash */
if ((p= strstr(opt, "\\\\")) != NULL)
{
/* bmove is guranteed to work byte by byte */
bmove(p, p+1, strlen(p+1));
......@@ -885,54 +907,55 @@ int read_option(char *opt_file, char *opt)
}
else
{
// clear option
*opt = 0;
/* clear option */
*opt= 0;
}
// compare current option with previous
/* compare current option with previous */
return strcmp(opt, buf);
}
/******************************************************************************
run_test()
Run the given test case.
******************************************************************************/
void run_test(char *test)
{
char temp[PATH_MAX];
const char *rstr;
int skip = FALSE, ignore=FALSE;
int restart = FALSE;
int flag = FALSE;
int skip= FALSE, ignore=FALSE;
int restart= FALSE;
int flag= FALSE;
struct stat info;
// skip tests in the skip list
/* skip tests in the skip list */
snprintf(temp, PATH_MAX, " %s ", test);
skip = (strinstr(skip_test, temp) != 0);
skip= (strinstr(skip_test, temp) != 0);
if (skip == FALSE)
ignore = (strinstr(ignore_test, temp) != 0);
ignore= (strinstr(ignore_test, temp) != 0);
snprintf(master_init_script, PATH_MAX, "%s/%s-master.sh", test_dir, test);
snprintf(slave_init_script, PATH_MAX, "%s/%s-slave.sh", test_dir, test);
#ifdef __WIN__
#ifdef __WIN__
if (! stat(master_init_script, &info))
skip = TRUE;
skip= TRUE;
if (!stat(slave_init_script, &info))
skip = TRUE;
skip= TRUE;
#endif
if (ignore)
{
// show test
/* show test */
mlog("%-46s ", test);
// ignore
rstr = TEST_IGNORE;
/* ignore */
rstr= TEST_IGNORE;
++total_ignore;
}
else if (!skip) // skip test?
}
else if (!skip) /* skip test? */
{
char test_file[PATH_MAX];
char master_opt_file[PATH_MAX];
......@@ -945,29 +968,29 @@ void run_test(char *test)
int err;
arg_list_t al;
#ifdef __WIN__
/*
Clean test database
*/
/* Clean test database */
removef("%s/test/*.*", master_dir);
removef("%s/test/*.*", slave_dir);
removef("%s/mysqltest/*.*", master_dir);
removef("%s/mysqltest/*.*", slave_dir);
#endif
// skip slave?
flag = skip_slave;
skip_slave = (strncmp(test, "rpl", 3) != 0);
if (flag != skip_slave) restart = TRUE;
// create files
/* skip slave? */
flag= skip_slave;
skip_slave= (strncmp(test, "rpl", 3) != 0);
if (flag != skip_slave) restart= TRUE;
/* create files */
snprintf(master_opt_file, PATH_MAX, "%s/%s-master.opt", test_dir, test);
snprintf(slave_opt_file, PATH_MAX, "%s/%s-slave.opt", test_dir, test);
snprintf(slave_master_info_file, PATH_MAX, "%s/%s.slave-mi", test_dir, test);
snprintf(reject_file, PATH_MAX, "%s/%s%s", result_dir, test, REJECT_SUFFIX);
snprintf(slave_master_info_file, PATH_MAX, "%s/%s.slave-mi",
test_dir, test);
snprintf(reject_file, PATH_MAX, "%s/%s%s",
result_dir, test, REJECT_SUFFIX);
snprintf(out_file, PATH_MAX, "%s/%s%s", result_dir, test, OUT_SUFFIX);
snprintf(err_file, PATH_MAX, "%s/%s%s", result_dir, test, ERR_SUFFIX);
// netware specific files
/* netware specific files */
snprintf(test_file, PATH_MAX, "%s/%s%s", test_dir, test, NW_TEST_SUFFIX);
if (stat(test_file, &info))
{
......@@ -979,45 +1002,46 @@ void run_test(char *test)
}
}
snprintf(result_file, PATH_MAX, "%s/%s%s", result_dir, test, NW_RESULT_SUFFIX);
snprintf(result_file, PATH_MAX, "%s/%s%s",
result_dir, test, NW_RESULT_SUFFIX);
if (stat(result_file, &info))
{
snprintf(result_file, PATH_MAX, "%s/%s%s", result_dir, test, RESULT_SUFFIX);
snprintf(result_file, PATH_MAX, "%s/%s%s",
result_dir, test, RESULT_SUFFIX);
}
// init scripts
/* init scripts */
if (stat(master_init_script, &info))
master_init_script[0] = 0;
master_init_script[0]= 0;
else
restart = TRUE;
restart= TRUE;
if (stat(slave_init_script, &info))
slave_init_script[0] = 0;
slave_init_script[0]= 0;
else
restart = TRUE;
// read options
if (read_option(master_opt_file, master_opt)) restart = TRUE;
if (read_option(slave_opt_file, slave_opt)) restart = TRUE;
if (read_option(slave_master_info_file, slave_master_info)) restart = TRUE;
// cleanup previous run
restart= TRUE;
/* read options */
if (read_option(master_opt_file, master_opt)) restart= TRUE;
if (read_option(slave_opt_file, slave_opt)) restart= TRUE;
if (read_option(slave_master_info_file, slave_master_info)) restart= TRUE;
/* cleanup previous run */
remove(reject_file);
remove(out_file);
remove(err_file);
// start or restart?
/* start or restart? */
if (!master_running) mysql_start();
else if (restart) mysql_restart();
// let the system stabalize
/* let the system stabalize */
sleep(1);
// show test
/* show test */
mlog("%-46s ", test);
// args
/* args */
init_args(&al);
add_arg(&al, "%s", mysqltest_file);
add_arg(&al, "--no-defaults");
......@@ -1025,7 +1049,7 @@ void run_test(char *test)
#if !defined(__NETWARE__) && !defined(__WIN__)
add_arg(&al, "--socket=%s", master_socket);
add_arg(&al, "--tmpdir=%s", mysql_tmp_dir);
#endif
#endif
add_arg(&al, "--database=%s", db);
add_arg(&al, "--user=%s", user);
add_arg(&al, "--password=%s", password);
......@@ -1043,70 +1067,71 @@ void run_test(char *test)
add_arg(&al, "--ssl-key=%s", client_key);
}
// spawn
err = spawn(mysqltest_file, &al, TRUE, test_file, out_file, err_file, NULL);
// free args
/* spawn */
err= spawn(mysqltest_file, &al, TRUE, test_file, out_file, err_file, NULL);
/* free args */
free_args(&al);
remove_empty_file(out_file);
remove_empty_file(err_file);
remove_empty_file(out_file);
remove_empty_file(err_file);
if (err == 0)
{
// pass
rstr = TEST_PASS;
/* pass */
rstr= TEST_PASS;
++total_pass;
// increment total
/* increment total */
++total_test;
}
else if (err == 2)
{
// skip
rstr = TEST_SKIP;
/* skip */
rstr= TEST_SKIP;
++total_skip;
}
else if (err == 1)
{
// fail
rstr = TEST_FAIL;
/* fail */
rstr= TEST_FAIL;
++total_fail;
// increment total
/* increment total */
++total_test;
}
else
{
rstr = TEST_BAD;
rstr= TEST_BAD;
}
}
else // early skips
else /* early skips */
{
// show test
/* show test */
mlog("%-46s ", test);
// skip
rstr = TEST_SKIP;
/* skip */
rstr= TEST_SKIP;
++total_skip;
}
// result
/* result */
mlog("%-14s\n", rstr);
}
/******************************************************************************
vlog()
Log the message.
******************************************************************************/
void vlog(const char *format, va_list ap)
{
vfprintf(stdout, format, ap);
fflush(stdout);
if (log_fd)
{
vfprintf(log_fd, format, ap);
......@@ -1117,10 +1142,11 @@ void vlog(const char *format, va_list ap)
/******************************************************************************
log()
Log the message.
******************************************************************************/
void mlog(const char *format, ...)
{
va_list ap;
......@@ -1128,21 +1154,22 @@ void mlog(const char *format, ...)
va_start(ap, format);
vlog(format, ap);
va_end(ap);
}
/******************************************************************************
log_info()
Log the given information.
******************************************************************************/
void log_info(const char *format, ...)
{
va_list ap;
va_start(ap, format);
mlog("-- INFO : ");
......@@ -1155,14 +1182,15 @@ void log_info(const char *format, ...)
/******************************************************************************
log_error()
Log the given error.
******************************************************************************/
void log_error(const char *format, ...)
{
va_list ap;
va_start(ap, format);
mlog("-- ERROR: ");
......@@ -1175,14 +1203,15 @@ void log_error(const char *format, ...)
/******************************************************************************
log_errno()
Log the given error and errno.
******************************************************************************/
void log_errno(const char *format, ...)
{
va_list ap;
va_start(ap, format);
mlog("-- ERROR: (%003u) ", errno);
......@@ -1195,10 +1224,11 @@ void log_errno(const char *format, ...)
/******************************************************************************
die()
Exit the application.
******************************************************************************/
void die(const char *msg)
{
log_error(msg);
......@@ -1211,48 +1241,49 @@ void die(const char *msg)
/******************************************************************************
setup()
Setup the mysql test enviornment.
******************************************************************************/
void setup(char *file)
void setup(char *file __attribute__((unused)))
{
char temp[PATH_MAX];
char file_path[PATH_MAX*2];
char *p;
int position;
// set the timezone for the timestamp test
/* set the timezone for the timestamp test */
#ifdef __WIN__
_putenv( "TZ=GMT-3" );
#else
setenv("TZ", "GMT-3", TRUE);
#endif
// find base dir
#ifdef __NETWARE__
/* find base dir */
#ifdef __NETWARE__
strcpy(temp, strlwr(file));
while((p = strchr(temp, '\\')) != NULL) *p = '/';
#else
while ((p= strchr(temp, '\\')) != NULL) *p= '/';
#else
getcwd(temp, PATH_MAX);
position = strlen(temp);
temp[position] = '/';
temp[position+1] = 0;
position= strlen(temp);
temp[position]= '/';
temp[position+1]= 0;
#ifdef __WIN__
while((p = strchr(temp, '\\')) != NULL) *p = '/';
while ((p= strchr(temp, '\\')) != NULL) *p= '/';
#endif
#endif
#endif
if ((position = strinstr(temp, "/mysql-test/")) != 0)
if ((position= strinstr(temp, "/mysql-test/")) != 0)
{
p = temp + position - 1;
*p = 0;
p= temp + position - 1;
*p= 0;
strcpy(base_dir, temp);
}
}
log_info("Currect directory: %s",base_dir);
#ifdef __NETWARE__
// setup paths
/* setup paths */
snprintf(bin_dir, PATH_MAX, "%s/bin", base_dir);
snprintf(mysql_test_dir, PATH_MAX, "%s/mysql-test", base_dir);
snprintf(test_dir, PATH_MAX, "%s/t", mysql_test_dir);
......@@ -1264,24 +1295,24 @@ void setup(char *file)
snprintf(char_dir, PATH_MAX, "%s/share/charsets", base_dir);
#ifdef HAVE_OPENSSL
use_openssl = TRUE;
#endif // HAVE_OPENSSL
use_openssl= TRUE;
#endif /* HAVE_OPENSSL */
// OpenSSL paths
/* OpenSSL paths */
snprintf(ca_cert, PATH_MAX, "%s/SSL/cacert.pem", base_dir);
snprintf(server_cert, PATH_MAX, "%s/SSL/server-cert.pem", base_dir);
snprintf(server_key, PATH_MAX, "%s/SSL/server-key.pem", base_dir);
snprintf(client_cert, PATH_MAX, "%s/SSL/client-cert.pem", base_dir);
snprintf(client_key, PATH_MAX, "%s/SSL/client-key.pem", base_dir);
// setup files
/* setup files */
snprintf(mysqld_file, PATH_MAX, "%s/mysqld", bin_dir);
snprintf(mysqltest_file, PATH_MAX, "%s/mysqltest", bin_dir);
snprintf(mysqladmin_file, PATH_MAX, "%s/mysqladmin", bin_dir);
snprintf(master_pid, PATH_MAX, "%s/var/run/master.pid", mysql_test_dir);
snprintf(slave_pid, PATH_MAX, "%s/var/run/slave.pid", mysql_test_dir);
#elif __WIN__
// setup paths
/* setup paths */
#ifdef _DEBUG
snprintf(bin_dir, PATH_MAX, "%s/client_debug", base_dir);
#else
......@@ -1297,22 +1328,22 @@ void setup(char *file)
snprintf(char_dir, PATH_MAX, "%s/share/charsets", base_dir);
#ifdef HAVE_OPENSSL
use_openssl = TRUE;
#endif // HAVE_OPENSSL
use_openssl= TRUE;
#endif /* HAVE_OPENSSL */
// OpenSSL paths
/* OpenSSL paths */
snprintf(ca_cert, PATH_MAX, "%s/SSL/cacert.pem", base_dir);
snprintf(server_cert, PATH_MAX, "%s/SSL/server-cert.pem", base_dir);
snprintf(server_key, PATH_MAX, "%s/SSL/server-key.pem", base_dir);
snprintf(client_cert, PATH_MAX, "%s/SSL/client-cert.pem", base_dir);
snprintf(client_key, PATH_MAX, "%s/SSL/client-key.pem", base_dir);
// setup files
/* setup files */
snprintf(mysqld_file, PATH_MAX, "%s/mysqld.exe", bin_dir);
snprintf(mysqltest_file, PATH_MAX, "%s/mysqltest.exe", bin_dir);
snprintf(mysqladmin_file, PATH_MAX, "%s/mysqladmin.exe", bin_dir);
#else
// setup paths
#else
/* setup paths */
snprintf(bin_dir, PATH_MAX, "%s/client", base_dir);
snprintf(mysql_test_dir, PATH_MAX, "%s/mysql-test", base_dir);
snprintf(test_dir, PATH_MAX, "%s/t", mysql_test_dir);
......@@ -1324,60 +1355,72 @@ void setup(char *file)
snprintf(char_dir, PATH_MAX, "%s/sql/share/charsets", base_dir);
#ifdef HAVE_OPENSSL
use_openssl = TRUE;
#endif // HAVE_OPENSSL
use_openssl= TRUE;
#endif /* HAVE_OPENSSL */
// OpenSSL paths
/* OpenSSL paths */
snprintf(ca_cert, PATH_MAX, "%s/SSL/cacert.pem", base_dir);
snprintf(server_cert, PATH_MAX, "%s/SSL/server-cert.pem", base_dir);
snprintf(server_key, PATH_MAX, "%s/SSL/server-key.pem", base_dir);
snprintf(client_cert, PATH_MAX, "%s/SSL/client-cert.pem", base_dir);
snprintf(client_key, PATH_MAX, "%s/SSL/client-key.pem", base_dir);
// setup files
/* setup files */
snprintf(mysqld_file, PATH_MAX, "%s/sql/mysqld", base_dir);
snprintf(mysqltest_file, PATH_MAX, "%s/mysqltest", bin_dir);
snprintf(mysqladmin_file, PATH_MAX, "%s/mysqladmin", bin_dir);
snprintf(master_pid, PATH_MAX, "%s/var/run/master.pid", mysql_test_dir);
snprintf(slave_pid, PATH_MAX, "%s/var/run/slave.pid", mysql_test_dir);
snprintf(master_socket,PATH_MAX, "%s/var/tmp/master.sock", mysql_test_dir);
snprintf(slave_socket,PATH_MAX, "%s/var/tmp/slave.sock", mysql_test_dir);
#endif
// create log file
/* create log file */
snprintf(temp, PATH_MAX, "%s/mysql-test-run.log", mysql_test_dir);
if ((log_fd = fopen(temp, "w+")) == NULL)
if ((log_fd= fopen(temp, "w+")) == NULL)
{
log_errno("Unable to create log file.");
}
// prepare skip test list
while((p = strchr(skip_test, ',')) != NULL) *p = ' ';
/* prepare skip test list */
while ((p= strchr(skip_test, ',')) != NULL) *p= ' ';
strcpy(temp, strlwr(skip_test));
snprintf(skip_test, PATH_MAX, " %s ", temp);
// environment
#ifdef __NETWARE__
/* environment */
#ifdef __NETWARE__
setenv("MYSQL_TEST_DIR", mysql_test_dir, 1);
snprintf(file_path, PATH_MAX*2, "%s/client/mysqldump --no-defaults -u root --port=%u", bin_dir, master_port);
snprintf(file_path, PATH_MAX*2,
"%s/client/mysqldump --no-defaults -u root --port=%u",
bin_dir, master_port);
setenv("MYSQL_DUMP", file_path, 1);
snprintf(file_path, PATH_MAX*2, "%s/client/mysqlbinlog --no-defaults --local-load=%s", bin_dir, mysql_tmp_dir);
snprintf(file_path, PATH_MAX*2,
"%s/client/mysqlbinlog --no-defaults --local-load=%s",
bin_dir, mysql_tmp_dir);
setenv("MYSQL_BINLOG", file_path, 1);
#elif __WIN__
snprintf(file_path,MAX_PATH,"MYSQL_TEST_DIR=%s",mysql_test_dir);
_putenv(file_path);
snprintf(file_path, PATH_MAX*2, "MYSQL_DUMP=%s/mysqldump.exe --no-defaults -u root --port=%u", bin_dir, master_port);
snprintf(file_path, PATH_MAX*2,
"MYSQL_DUMP=%s/mysqldump.exe --no-defaults -u root --port=%u",
bin_dir, master_port);
_putenv(file_path);
snprintf(file_path, PATH_MAX*2, "MYSQL_BINLOG=%s/mysqlbinlog.exe --no-defaults --local-load=%s", bin_dir, mysql_tmp_dir);
snprintf(file_path, PATH_MAX*2,
"MYSQL_BINLOG=%s/mysqlbinlog.exe --no-defaults --local-load=%s",
bin_dir, mysql_tmp_dir);
_putenv(file_path);
#else
setenv("MYSQL_TEST_DIR", mysql_test_dir, 1);
snprintf(file_path, PATH_MAX*2, "%s/mysqldump --no-defaults -u root --port=%u --socket=%s", bin_dir, master_port, master_socket);
snprintf(file_path, PATH_MAX*2,
"%s/mysqldump --no-defaults -u root --port=%u --socket=%s",
bin_dir, master_port, master_socket);
setenv("MYSQL_DUMP", file_path, 1);
snprintf(file_path, PATH_MAX*2, "%s/mysqlbinlog --no-defaults --local-load=%s", bin_dir, mysql_tmp_dir);
snprintf(file_path, PATH_MAX*2,
"%s/mysqlbinlog --no-defaults --local-load=%s",
bin_dir, mysql_tmp_dir);
setenv("MYSQL_BINLOG", file_path, 1);
#endif
#endif
#ifndef __WIN__
setenv("MASTER_MYPORT", "9306", 1);
......@@ -1394,21 +1437,23 @@ void setup(char *file)
/******************************************************************************
main()
******************************************************************************/
int main(int argc, char **argv)
{
int is_ignore_list = 0;
// setup
int is_ignore_list= 0;
/* setup */
setup(argv[0]);
/* The --ignore option is comma saperated list of test cases to skip and
should be very first command line option to the test suite.
The usage is now:
mysql_test_run --ignore=test1,test2 test3 test4
where test1 and test2 are test cases to ignore
and test3 and test4 are test cases to run.
/*
The --ignore option is comma saperated list of test cases to skip and
should be very first command line option to the test suite.
The usage is now:
mysql_test_run --ignore=test1,test2 test3 test4
where test1 and test2 are test cases to ignore
and test3 and test4 are test cases to run.
*/
if (argc >= 2 && !strnicmp(argv[1], "--ignore=", sizeof("--ignore=")-1))
{
......@@ -1425,22 +1470,22 @@ int main(int argc, char **argv)
}
}
free(temp);
is_ignore_list = 1;
is_ignore_list= 1;
}
// header
/* header */
#ifndef __WIN__
mlog("MySQL Server %s, for %s (%s)\n\n", VERSION, SYSTEM_TYPE, MACHINE_TYPE);
#else
mlog("MySQL Server ---, for %s (%s)\n\n", SYSTEM_TYPE, MACHINE_TYPE);
#endif
mlog("Initializing Tests...\n");
// install test databases
/* install test databases */
mysql_install_db();
mlog("Starting Tests...\n");
mlog("\n");
mlog(HEADER);
mlog(DASH);
......@@ -1449,46 +1494,46 @@ int main(int argc, char **argv)
{
int i;
// single test
single_test = TRUE;
/* single test */
single_test= TRUE;
for (i = 1 + is_ignore_list; i < argc; i++)
for (i= 1 + is_ignore_list; i < argc; i++)
{
// run given test
/* run given test */
run_test(argv[i]);
}
}
else
{
// run all tests
/* run all tests */
#ifndef __WIN__
struct dirent **namelist;
int i,n;
char test[NAME_MAX];
char *p;
int position;
n = scandir(test_dir, &namelist, 0, alphasort);
n= scandir(test_dir, &namelist, 0, alphasort);
if (n < 0)
die("Unable to open tests directory.");
else
else
{
for (i = 0; i < n; i++)
for (i= 0; i < n; i++)
{
strcpy(test, strlwr(namelist[i]->d_name));
// find the test suffix
if ((position = strinstr(test, TEST_SUFFIX)) != 0)
strcpy(test, strlwr(namelist[i]->d_name));
/* find the test suffix */
if ((position= strinstr(test, TEST_SUFFIX)) != 0)
{
p = test + position - 1;
// null terminate at the suffix
*p = 0;
// run test
p= test + position - 1;
/* null terminate at the suffix */
*p= 0;
/* run test */
run_test(test);
}
free(namelist[n]);
}
}
free(namelist);
}
}
#else
struct _finddata_t dir;
intptr_t handle;
......@@ -1496,52 +1541,52 @@ int main(int argc, char **argv)
char mask[PATH_MAX];
char *p;
int position;
char **names = 0;
char **testes = 0;
char **names= 0;
char **testes= 0;
int name_index;
int index;
// single test
single_test = FALSE;
/* single test */
single_test= FALSE;
snprintf(mask,MAX_PATH,"%s/*.test",test_dir);
if ((handle=_findfirst(mask,&dir)) == -1L)
{
die("Unable to open tests directory.");
}
names = malloc(MAX_COUNT_TESTES*4);
testes = names;
name_index = 0;
names= malloc(MAX_COUNT_TESTES*4);
testes= names;
name_index= 0;
do
{
if (!(dir.attrib & _A_SUBDIR))
if (!(dir.attrib & _A_SUBDIR))
{
strcpy(test, strlwr(dir.name));
// find the test suffix
if ((position = strinstr(test, TEST_SUFFIX)) != 0)
/* find the test suffix */
if ((position= strinstr(test, TEST_SUFFIX)) != 0)
{
p = test + position - 1;
// null terminate at the suffix
*p = 0;
p= test + position - 1;
/* null terminate at the suffix */
*p= 0;
// insert test
*names = malloc(PATH_MAX);
/* insert test */
*names= malloc(PATH_MAX);
strcpy(*names,test);
names++;
name_index++;
}
}
}
}while (_findnext(handle,&dir) == 0);
_findclose(handle);
qsort( (void *)testes, name_index, sizeof( char * ), compare );
for (index = 0; index <= name_index; index++)
for (index= 0; index <= name_index; index++)
{
run_test(testes[index]);
free(testes[index]);
......@@ -1551,7 +1596,7 @@ int main(int argc, char **argv)
#endif
}
// stop server
/* stop server */
mysql_stop();
mlog(DASH);
......@@ -1559,14 +1604,14 @@ int main(int argc, char **argv)
mlog("Ending Tests...\n");
// report stats
/* report stats */
report_stats();
// close log
/* close log */
if (log_fd) fclose(log_fd);
// keep results up
#ifdef __NETWARE__
/* keep results up */
#ifdef __NETWARE__
pressanykey();
#endif
return 0;
......@@ -1577,12 +1622,12 @@ int main(int argc, char **argv)
Synopsis:
This function breaks the string into a sequence of tokens. The difference
between this function and strtok is that it respects the quoted string i.e.
it skips any delimiter character within the quoted part of the string.
it skips any delimiter character within the quoted part of the string.
It return tokens by eliminating quote character. It modifies the input string
passed. It will work with whitespace delimeter but may not work properly with
other delimeter. If the delimeter will contain any quote character, then
function will not tokenize and will return null string.
e.g. if input string is
e.g. if input string is
--init-slave="set global max_connections=500" --skip-external-locking
then the output will two string i.e.
--init-slave=set global max_connections=500
......@@ -1595,7 +1640,6 @@ Output:
return the null terminated token of NULL.
*/
char *str_tok(char *string, const char *delim)
{
char *token; /* current token received from strtok */
......@@ -1607,40 +1651,38 @@ char *str_tok(char *string, const char *delim)
char *ptr_token=NULL;
/* pointer to the quote character in the token from strtok */
char *ptr_quote=NULL;
/* See if the delimeter contains any quote character */
if (strchr(delim,'\'') || strchr(delim,'\"'))
return NULL;
/* repeate till we are getting some token from strtok */
while ((token = (char*)strtok(string, delim) ) != NULL)
while ((token= (char*)strtok(string, delim) ) != NULL)
{
/*
make the input string NULL so that next time onward strtok can
be called with NULL input string.
*/
string = NULL;
/*
We don't need to remove any quote character for Windows version
*/
string= NULL;
/* We don't need to remove any quote character for Windows version */
#ifndef __WIN__
/* check if the current token contain double quote character*/
if ((ptr_quote = (char*)strchr(token,'\"')) != NULL)
if ((ptr_quote= (char*)strchr(token,'\"')) != NULL)
{
/*
get the matching the matching double quote in the remaining
input string
*/
qt_token = (char*)strtok(NULL,"\"");
qt_token= (char*)strtok(NULL,"\"");
}
/* check if the current token contain single quote character*/
else if ((ptr_quote = (char*)strchr(token,'\'')) != NULL)
else if ((ptr_quote= (char*)strchr(token,'\'')) != NULL)
{
/*
get the matching the matching single quote in the remaining
input string
*/
qt_token = (char*)strtok(NULL,"\'");
qt_token= (char*)strtok(NULL,"\'");
}
#endif
/*
......@@ -1663,7 +1705,7 @@ char *str_tok(char *string, const char *delim)
and hence quote will be removed
*/
*ptr_quote= 0;
/* check if ptr_token has been initialized or not */
if (ptr_token == NULL)
{
......@@ -1678,18 +1720,18 @@ char *str_tok(char *string, const char *delim)
copy the current token and entire string between matching pair
of quote
*/
if (qt_token == NULL)
{
sprintf(ptr_token+strlen(ptr_token),"%s%s", token, ptr_quote+1);
}
else
{
sprintf(ptr_token+strlen(ptr_token),"%s%s %s", token, ptr_quote+1,
qt_token );
}
if (qt_token == NULL)
{
sprintf(ptr_token+strlen(ptr_token),"%s%s", token, ptr_quote+1);
}
else
{
sprintf(ptr_token+strlen(ptr_token),"%s%s %s", token, ptr_quote+1,
qt_token );
}
}
}
/* return the concatenated token */
return ptr_token;
}
......@@ -1706,23 +1748,24 @@ Arguments:
Output:
nothing
*/
void run_init_script(const char *script_name)
{
arg_list_t al;
int err;
// args
/* args */
init_args(&al);
add_arg(&al, sh_file);
add_arg(&al, script_name);
// spawn
if ((err = spawn(sh_file, &al, TRUE, NULL, NULL, NULL, NULL)) != 0)
/* spawn */
if ((err= spawn(sh_file, &al, TRUE, NULL, NULL, NULL, NULL)) != 0)
{
die("Unable to run script.");
}
// free args
/* free args */
free_args(&al);
}
#endif
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7