2006-05-09 19:35:46 +04:00
/*
2007-01-19 23:30:05 +03:00
* testutils . c : basic test utils
2006-05-09 19:35:46 +04:00
*
2013-02-12 02:12:16 +04:00
* Copyright ( C ) 2005 - 2013 Red Hat , Inc .
2006-05-09 19:35:46 +04:00
*
2012-07-27 13:39:53 +04:00
* This library is free software ; you can redistribute it and / or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
* This library 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
* Lesser General Public License for more details .
*
* You should have received a copy of the GNU Lesser General Public
2012-09-21 02:30:55 +04:00
* License along with this library . If not , see
2012-07-27 13:39:53 +04:00
* < http : //www.gnu.org/licenses/>.
2006-05-09 19:35:46 +04:00
*
* Karel Zak < kzak @ redhat . com >
*/
2008-01-29 21:15:54 +03:00
# include <config.h>
2007-12-07 13:08:06 +03:00
2006-05-09 19:35:46 +04:00
# include <stdio.h>
# include <stdlib.h>
# include <sys/time.h>
2006-08-24 19:05:19 +04:00
# include <sys/types.h>
# include <sys/stat.h>
2013-02-12 02:12:16 +04:00
# include <sys/wait.h>
# include <regex.h>
2006-08-24 19:05:19 +04:00
# include <unistd.h>
2008-04-18 19:05:29 +04:00
# include <string.h>
2006-08-25 01:46:28 +04:00
# include <fcntl.h>
# include <limits.h>
2006-05-09 19:35:46 +04:00
# include "testutils.h"
2008-04-30 16:30:55 +04:00
# include "internal.h"
2012-12-12 22:06:53 +04:00
# include "viralloc.h"
2012-12-13 21:44:57 +04:00
# include "virutil.h"
2012-12-13 19:49:48 +04:00
# include "virthread.h"
2012-12-13 22:21:53 +04:00
# include "virerror.h"
2012-12-04 16:04:07 +04:00
# include "virbuffer.h"
2012-12-12 21:59:27 +04:00
# include "virlog.h"
2012-12-12 20:27:01 +04:00
# include "vircommand.h"
2012-01-25 19:17:46 +04:00
# include "virrandom.h"
2012-05-25 06:34:16 +04:00
# include "dirname.h"
2012-09-24 21:10:37 +04:00
# include "virprocess.h"
2013-04-03 14:36:23 +04:00
# include "virstring.h"
2008-05-29 19:21:45 +04:00
# if TEST_OOM_TRACE
2010-03-09 21:22:22 +03:00
# include <execinfo.h>
2008-05-29 19:21:45 +04:00
# endif
2006-05-09 19:35:46 +04:00
2007-06-15 19:24:20 +04:00
# ifdef HAVE_PATHS_H
2010-03-09 21:22:22 +03:00
# include <paths.h>
2007-06-15 19:24:20 +04:00
# endif
2012-05-09 18:18:56 +04:00
# define VIR_FROM_THIS VIR_FROM_NONE
2006-05-09 19:35:46 +04:00
# define GETTIMEOFDAY(T) gettimeofday(T, NULL)
2007-01-19 23:30:05 +03:00
# define DIFF_MSEC(T, U) \
2011-01-31 14:42:57 +03:00
( ( ( ( int ) ( ( T ) - > tv_sec - ( U ) - > tv_sec ) ) * 1000000.0 + \
2007-01-19 23:30:05 +03:00
( ( int ) ( ( T ) - > tv_usec - ( U ) - > tv_usec ) ) ) / 1000.0 )
2006-05-09 19:35:46 +04:00
2011-07-19 22:32:58 +04:00
# include "virfile.h"
2010-11-09 23:48:48 +03:00
2009-10-16 19:37:36 +04:00
static unsigned int testDebug = - 1 ;
2009-11-30 22:01:31 +03:00
static unsigned int testVerbose = - 1 ;
2013-08-03 01:43:07 +04:00
static unsigned int testExpensive = - 1 ;
2009-09-10 14:07:20 +04:00
2008-05-29 19:21:45 +04:00
static unsigned int testOOM = 0 ;
2013-07-18 18:02:19 +04:00
static size_t testCounter = 0 ;
static size_t testStart = 0 ;
static size_t testEnd = 0 ;
2008-05-29 19:21:45 +04:00
2011-04-29 20:21:20 +04:00
char * progname ;
char * abs_srcdir ;
2006-05-09 19:35:46 +04:00
double
virtTestCountAverage ( double * items , int nitems )
{
2007-01-19 23:30:05 +03:00
long double sum = 0 ;
Convert 'int i' to 'size_t i' in tests/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 18:09:33 +04:00
size_t i ;
2006-05-09 19:35:46 +04:00
2007-01-19 23:30:05 +03:00
for ( i = 1 ; i < nitems ; i + + )
sum + = items [ i ] ;
2006-05-09 19:35:46 +04:00
2007-01-19 23:30:05 +03:00
return ( double ) ( sum / nitems ) ;
2006-05-09 19:35:46 +04:00
}
2012-03-29 13:41:37 +04:00
2009-11-30 22:01:31 +03:00
void virtTestResult ( const char * name , int ret , const char * msg , . . . )
{
va_list vargs ;
va_start ( vargs , msg ) ;
2011-07-09 13:50:38 +04:00
if ( testCounter = = 0 & & ! virTestGetVerbose ( ) )
fprintf ( stderr , " " ) ;
2009-11-30 22:01:31 +03:00
testCounter + + ;
if ( virTestGetVerbose ( ) ) {
2013-07-18 18:02:19 +04:00
fprintf ( stderr , " %3zu) %-60s " , testCounter , name ) ;
2009-11-30 22:01:31 +03:00
if ( ret = = 0 )
fprintf ( stderr , " OK \n " ) ;
else {
fprintf ( stderr , " FAILED \n " ) ;
if ( msg ) {
2012-03-29 13:41:37 +04:00
char * str ;
2013-07-04 14:20:21 +04:00
if ( virVasprintfQuiet ( & str , msg , vargs ) = = 0 ) {
2012-03-29 13:41:37 +04:00
fprintf ( stderr , " %s " , str ) ;
VIR_FREE ( str ) ;
}
2009-11-30 22:01:31 +03:00
}
}
} else {
if ( testCounter ! = 1 & &
! ( ( testCounter - 1 ) % 40 ) ) {
2013-07-18 18:02:19 +04:00
fprintf ( stderr , " %-3zu \n " , ( testCounter - 1 ) ) ;
2009-11-30 22:01:31 +03:00
fprintf ( stderr , " " ) ;
}
if ( ret = = 0 )
fprintf ( stderr , " . " ) ;
else
fprintf ( stderr , " ! " ) ;
}
va_end ( vargs ) ;
}
2007-01-19 23:30:05 +03:00
/*
2006-05-22 18:38:33 +04:00
* Runs test and count average time ( if the nloops is grater than 1 )
2007-01-19 23:30:05 +03:00
*
* returns : - 1 = error , 0 = success
2006-05-09 19:35:46 +04:00
*/
int
2007-07-19 01:08:22 +04:00
virtTestRun ( const char * title , int nloops , int ( * body ) ( const void * data ) , const void * data )
2006-05-09 19:35:46 +04:00
{
Convert 'int i' to 'size_t i' in tests/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 18:09:33 +04:00
int ret = 0 ;
size_t i ;
2007-01-19 23:30:05 +03:00
double * ts = NULL ;
2008-04-18 19:05:29 +04:00
2011-07-09 13:50:38 +04:00
if ( testCounter = = 0 & & ! virTestGetVerbose ( ) )
fprintf ( stderr , " " ) ;
2008-05-29 19:21:45 +04:00
testCounter + + ;
2008-04-18 19:05:29 +04:00
2013-07-18 18:02:19 +04:00
/* Skip tests if out of range */
if ( ( testStart ! = 0 ) & &
( testCounter < testStart | |
testCounter > testEnd ) )
return 0 ;
2008-05-29 19:21:45 +04:00
if ( testOOM < 2 ) {
2009-11-30 22:01:31 +03:00
if ( virTestGetVerbose ( ) )
2013-07-18 18:02:19 +04:00
fprintf ( stderr , " %2zu) %-65s ... " , testCounter , title ) ;
2008-05-29 19:21:45 +04:00
}
2007-01-19 23:30:05 +03:00
2012-02-03 03:16:43 +04:00
if ( nloops > 1 & & ( VIR_ALLOC_N ( ts , nloops ) < 0 ) )
2007-01-19 23:30:05 +03:00
return - 1 ;
for ( i = 0 ; i < nloops ; i + + ) {
struct timeval before , after ;
if ( ts )
GETTIMEOFDAY ( & before ) ;
2010-11-23 19:01:03 +03:00
2010-09-08 20:12:42 +04:00
virResetLastError ( ) ;
2010-11-23 19:01:03 +03:00
ret = body ( data ) ;
2010-09-08 20:12:42 +04:00
virErrorPtr err = virGetLastError ( ) ;
2010-11-23 19:01:03 +03:00
if ( err ) {
if ( virTestGetVerbose ( ) | | virTestGetDebug ( ) )
virDispatchError ( NULL ) ;
}
if ( ret ! = 0 ) {
break ;
}
if ( ts ) {
2007-01-19 23:30:05 +03:00
GETTIMEOFDAY ( & after ) ;
ts [ i ] = DIFF_MSEC ( & after , & before ) ;
}
}
2008-05-29 19:21:45 +04:00
if ( testOOM < 2 ) {
2009-11-30 22:01:31 +03:00
if ( virTestGetVerbose ( ) ) {
if ( ret = = 0 & & ts )
fprintf ( stderr , " OK [%.5f ms] \n " ,
virtTestCountAverage ( ts , nloops ) ) ;
else if ( ret = = 0 )
fprintf ( stderr , " OK \n " ) ;
2011-10-12 12:08:33 +04:00
else if ( ret = = EXIT_AM_SKIP )
fprintf ( stderr , " SKIP \n " ) ;
2009-11-30 22:01:31 +03:00
else
fprintf ( stderr , " FAILED \n " ) ;
} else {
if ( testCounter ! = 1 & &
! ( ( testCounter - 1 ) % 40 ) ) {
2013-07-18 18:02:19 +04:00
fprintf ( stderr , " %-3zu \n " , ( testCounter - 1 ) ) ;
2009-11-30 22:01:31 +03:00
fprintf ( stderr , " " ) ;
}
if ( ret = = 0 )
fprintf ( stderr , " . " ) ;
2011-10-12 12:08:33 +04:00
else if ( ret = = EXIT_AM_SKIP )
fprintf ( stderr , " _ " ) ;
2009-11-30 22:01:31 +03:00
else
fprintf ( stderr , " ! " ) ;
}
2008-05-29 19:21:45 +04:00
}
2007-01-19 23:30:05 +03:00
2012-02-03 03:16:43 +04:00
VIR_FREE ( ts ) ;
2007-01-19 23:30:05 +03:00
return ret ;
2006-05-09 19:35:46 +04:00
}
2006-08-24 19:05:19 +04:00
2011-04-25 02:25:10 +04:00
/* Allocate BUF to the size of FILE. Read FILE into buffer BUF.
Upon any failure , diagnose it and return - 1 , but don ' t bother trying
to preserve errno . Otherwise , return the number of bytes copied into BUF . */
int
virtTestLoadFile ( const char * file , char * * buf )
{
2009-02-02 23:35:14 +03:00
FILE * fp = fopen ( file , " r " ) ;
2006-08-24 19:05:19 +04:00
struct stat st ;
2011-04-25 02:25:10 +04:00
char * tmp ;
int len , tmplen , buflen ;
2007-01-19 23:30:05 +03:00
2009-02-02 23:35:14 +03:00
if ( ! fp ) {
2012-10-17 13:23:12 +04:00
fprintf ( stderr , " %s: failed to open: %s \n " , file , strerror ( errno ) ) ;
2006-08-24 19:05:19 +04:00
return - 1 ;
2009-02-02 23:35:14 +03:00
}
2006-08-24 19:05:19 +04:00
if ( fstat ( fileno ( fp ) , & st ) < 0 ) {
2012-10-17 13:23:12 +04:00
fprintf ( stderr , " %s: failed to fstat: %s \n " , file , strerror ( errno ) ) ;
2010-11-17 05:13:29 +03:00
VIR_FORCE_FCLOSE ( fp ) ;
2006-08-24 19:05:19 +04:00
return - 1 ;
}
2011-04-25 02:25:10 +04:00
tmplen = buflen = st . st_size + 1 ;
if ( VIR_ALLOC_N ( * buf , buflen ) < 0 ) {
2012-10-17 13:23:12 +04:00
fprintf ( stderr , " %s: larger than available memory (> %d) \n " , file , buflen ) ;
2010-11-17 05:13:29 +03:00
VIR_FORCE_FCLOSE ( fp ) ;
2006-08-24 19:05:19 +04:00
return - 1 ;
}
2011-04-25 02:25:10 +04:00
tmp = * buf ;
2011-01-31 14:42:57 +03:00
( * buf ) [ 0 ] = ' \0 ' ;
2007-01-19 23:30:05 +03:00
if ( st . st_size ) {
2011-01-31 14:42:57 +03:00
/* read the file line by line */
while ( fgets ( tmp , tmplen , fp ) ! = NULL ) {
len = strlen ( tmp ) ;
2011-04-25 02:25:10 +04:00
/* stop on an empty line */
if ( len = = 0 )
break ;
2011-01-31 14:42:57 +03:00
/* remove trailing backslash-newline pair */
if ( len > = 2 & & tmp [ len - 2 ] = = ' \\ ' & & tmp [ len - 1 ] = = ' \n ' ) {
len - = 2 ;
tmp [ len ] = ' \0 ' ;
}
/* advance the temporary buffer pointer */
tmp + = len ;
tmplen - = len ;
}
if ( ferror ( fp ) ) {
2012-10-17 13:23:12 +04:00
fprintf ( stderr , " %s: read failed: %s \n " , file , strerror ( errno ) ) ;
2010-11-17 05:13:29 +03:00
VIR_FORCE_FCLOSE ( fp ) ;
2012-02-03 03:16:43 +04:00
VIR_FREE ( * buf ) ;
2007-01-19 23:30:05 +03:00
return - 1 ;
}
2006-08-24 19:05:19 +04:00
}
2010-11-17 05:13:29 +03:00
VIR_FORCE_FCLOSE ( fp ) ;
2011-01-31 14:42:57 +03:00
return strlen ( * buf ) ;
2006-08-24 19:05:19 +04:00
}
2008-06-26 13:37:51 +04:00
# ifndef WIN32
2006-08-25 01:46:28 +04:00
static
void virtTestCaptureProgramExecChild ( const char * const argv [ ] ,
2007-01-19 23:30:05 +03:00
int pipefd ) {
Convert 'int i' to 'size_t i' in tests/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 18:09:33 +04:00
size_t i ;
2007-01-19 23:30:05 +03:00
int open_max ;
int stdinfd = - 1 ;
const char * const env [ ] = {
" LANG=C " ,
2010-03-09 21:22:22 +03:00
# if WITH_DRIVER_MODULES
2008-11-21 15:16:08 +03:00
" LIBVIRT_DRIVER_DIR= " TEST_DRIVER_DIR ,
2010-03-09 21:22:22 +03:00
# endif
2007-01-19 23:30:05 +03:00
NULL
} ;
2008-12-17 21:04:55 +03:00
if ( ( stdinfd = open ( " /dev/null " , O_RDONLY ) ) < 0 )
2007-01-19 23:30:05 +03:00
goto cleanup ;
2012-10-17 13:23:12 +04:00
open_max = sysconf ( _SC_OPEN_MAX ) ;
2013-07-11 15:22:20 +04:00
if ( open_max < 0 )
goto cleanup ;
2007-01-19 23:30:05 +03:00
for ( i = 0 ; i < open_max ; i + + ) {
if ( i ! = stdinfd & &
2010-11-09 23:48:48 +03:00
i ! = pipefd ) {
Convert 'int i' to 'size_t i' in tests/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 18:09:33 +04:00
int tmpfd ;
tmpfd = i ;
2010-11-09 23:48:48 +03:00
VIR_FORCE_CLOSE ( tmpfd ) ;
}
2007-01-19 23:30:05 +03:00
}
if ( dup2 ( stdinfd , STDIN_FILENO ) ! = STDIN_FILENO )
goto cleanup ;
if ( dup2 ( pipefd , STDOUT_FILENO ) ! = STDOUT_FILENO )
goto cleanup ;
2009-07-06 18:03:31 +04:00
if ( dup2 ( pipefd , STDERR_FILENO ) ! = STDERR_FILENO )
2007-01-19 23:30:05 +03:00
goto cleanup ;
/* SUS is crazy here, hence the cast */
execve ( argv [ 0 ] , ( char * const * ) argv , ( char * const * ) env ) ;
2006-08-25 01:46:28 +04:00
cleanup :
2010-11-09 23:48:48 +03:00
VIR_FORCE_CLOSE ( stdinfd ) ;
2006-08-25 01:46:28 +04:00
}
2011-04-25 02:25:10 +04:00
int
virtTestCaptureProgramOutput ( const char * const argv [ ] , char * * buf , int maxlen )
{
2007-01-19 23:30:05 +03:00
int pipefd [ 2 ] ;
2011-04-25 02:25:10 +04:00
int len ;
2007-01-19 23:30:05 +03:00
if ( pipe ( pipefd ) < 0 )
return - 1 ;
build: use correct type for pid and similar types
No thanks to 64-bit windows, with 64-bit pid_t, we have to avoid
constructs like 'int pid'. Our API in libvirt-qemu cannot be
changed without breaking ABI; but then again, libvirt-qemu can
only be used on systems that support UNIX sockets, which rules
out Windows (even if qemu could be compiled there) - so for all
points on the call chain that interact with this API decision,
we require a different variable name to make it clear that we
audited the use for safety.
Adding a syntax-check rule only solves half the battle; anywhere
that uses printf on a pid_t still needs to be converted, but that
will be a separate patch.
* cfg.mk (sc_correct_id_types): New syntax check.
* src/libvirt-qemu.c (virDomainQemuAttach): Document why we didn't
use pid_t for pid, and validate for overflow.
* include/libvirt/libvirt-qemu.h (virDomainQemuAttach): Tweak name
for syntax check.
* src/vmware/vmware_conf.c (vmwareExtractPid): Likewise.
* src/driver.h (virDrvDomainQemuAttach): Likewise.
* tools/virsh.c (cmdQemuAttach): Likewise.
* src/remote/qemu_protocol.x (qemu_domain_attach_args): Likewise.
* src/qemu_protocol-structs (qemu_domain_attach_args): Likewise.
* src/util/cgroup.c (virCgroupPidCode, virCgroupKillInternal):
Likewise.
* src/qemu/qemu_command.c(qemuParseProcFileStrings): Likewise.
(qemuParseCommandLinePid): Use pid_t for pid.
* daemon/libvirtd.c (daemonForkIntoBackground): Likewise.
* src/conf/domain_conf.h (_virDomainObj): Likewise.
* src/probes.d (rpc_socket_new): Likewise.
* src/qemu/qemu_command.h (qemuParseCommandLinePid): Likewise.
* src/qemu/qemu_driver.c (qemudGetProcessInfo, qemuDomainAttach):
Likewise.
* src/qemu/qemu_process.c (qemuProcessAttach): Likewise.
* src/qemu/qemu_process.h (qemuProcessAttach): Likewise.
* src/uml/uml_driver.c (umlGetProcessInfo): Likewise.
* src/util/virnetdev.h (virNetDevSetNamespace): Likewise.
* src/util/virnetdev.c (virNetDevSetNamespace): Likewise.
* tests/testutils.c (virtTestCaptureProgramOutput): Likewise.
* src/conf/storage_conf.h (_virStoragePerms): Use mode_t, uid_t,
and gid_t rather than int.
* src/security/security_dac.c (virSecurityDACSetOwnership): Likewise.
* src/conf/storage_conf.c (virStorageDefParsePerms): Avoid
compiler warning.
2012-02-11 03:08:11 +04:00
pid_t pid = fork ( ) ;
2007-01-19 23:30:05 +03:00
switch ( pid ) {
2006-08-25 01:46:28 +04:00
case 0 :
2010-11-09 23:48:48 +03:00
VIR_FORCE_CLOSE ( pipefd [ 0 ] ) ;
2007-01-19 23:30:05 +03:00
virtTestCaptureProgramExecChild ( argv , pipefd [ 1 ] ) ;
2010-11-09 23:48:48 +03:00
VIR_FORCE_CLOSE ( pipefd [ 1 ] ) ;
2013-02-23 02:42:39 +04:00
_exit ( EXIT_FAILURE ) ;
2007-01-19 23:30:05 +03:00
2006-08-25 01:46:28 +04:00
case - 1 :
return - 1 ;
2007-01-19 23:30:05 +03:00
2006-08-25 01:46:28 +04:00
default :
2011-04-25 02:25:10 +04:00
VIR_FORCE_CLOSE ( pipefd [ 1 ] ) ;
len = virFileReadLimFD ( pipefd [ 0 ] , maxlen , buf ) ;
VIR_FORCE_CLOSE ( pipefd [ 0 ] ) ;
2012-09-24 20:59:31 +04:00
if ( virProcessWait ( pid , NULL ) < 0 )
2011-10-21 21:09:23 +04:00
return - 1 ;
2006-08-25 01:46:28 +04:00
2011-04-25 02:25:10 +04:00
return len ;
2007-01-19 23:30:05 +03:00
}
2006-08-25 01:46:28 +04:00
}
2010-03-17 02:36:07 +03:00
# else /* !WIN32 */
2011-04-25 02:25:10 +04:00
int
virtTestCaptureProgramOutput ( const char * const argv [ ] ATTRIBUTE_UNUSED ,
char * * buf ATTRIBUTE_UNUSED ,
int maxlen ATTRIBUTE_UNUSED )
{
2010-03-17 02:36:07 +03:00
return - 1 ;
}
2008-06-26 13:37:51 +04:00
# endif /* !WIN32 */
2008-04-18 19:05:29 +04:00
/**
* @ param stream : output stream write to differences to
* @ param expect : expected output text
* @ param actual : actual output text
*
* Display expected and actual output text , trimmed to
* first and last characters at which differences occur
*/
int virtTestDifference ( FILE * stream ,
const char * expect ,
const char * actual )
{
const char * expectStart = expect ;
const char * expectEnd = expect + ( strlen ( expect ) - 1 ) ;
const char * actualStart = actual ;
const char * actualEnd = actual + ( strlen ( actual ) - 1 ) ;
2009-11-30 22:01:31 +03:00
if ( ! virTestGetDebug ( ) )
2008-05-29 19:21:45 +04:00
return 0 ;
2009-11-30 22:01:31 +03:00
if ( virTestGetDebug ( ) < 2 ) {
2008-04-30 16:30:55 +04:00
/* Skip to first character where they differ */
while ( * expectStart & & * actualStart & &
* actualStart = = * expectStart ) {
actualStart + + ;
expectStart + + ;
}
2008-04-18 19:05:29 +04:00
2008-04-30 16:30:55 +04:00
/* Work backwards to last character where they differ */
while ( actualEnd > actualStart & &
expectEnd > expectStart & &
* actualEnd = = * expectEnd ) {
actualEnd - - ;
expectEnd - - ;
}
2008-04-18 19:05:29 +04:00
}
/* Show the trimmed differences */
2011-09-17 17:57:26 +04:00
fprintf ( stream , " \n Offset %d \n Expect [ " , ( int ) ( expectStart - expect ) ) ;
2008-04-18 19:05:29 +04:00
if ( ( expectEnd - expectStart + 1 ) & &
fwrite ( expectStart , ( expectEnd - expectStart + 1 ) , 1 , stream ) ! = 1 )
return - 1 ;
fprintf ( stream , " ] \n " ) ;
fprintf ( stream , " Actual [ " ) ;
if ( ( actualEnd - actualStart + 1 ) & &
fwrite ( actualStart , ( actualEnd - actualStart + 1 ) , 1 , stream ) ! = 1 )
return - 1 ;
fprintf ( stream , " ] \n " ) ;
/* Pad to line up with test name ... in virTestRun */
fprintf ( stream , " ... " ) ;
return 0 ;
}
2008-05-29 19:21:45 +04:00
2010-12-06 20:03:22 +03:00
/**
* @ param stream : output stream write to differences to
* @ param expect : expected output text
* @ param actual : actual output text
*
* Display expected and actual output text , trimmed to
* first and last characters at which differences occur
*/
int virtTestDifferenceBin ( FILE * stream ,
const char * expect ,
const char * actual ,
size_t length )
{
size_t start = 0 , end = length ;
ssize_t i ;
if ( ! virTestGetDebug ( ) )
return 0 ;
if ( virTestGetDebug ( ) < 2 ) {
/* Skip to first character where they differ */
2013-05-21 11:53:48 +04:00
for ( i = 0 ; i < length ; i + + ) {
2010-12-06 20:03:22 +03:00
if ( expect [ i ] ! = actual [ i ] ) {
start = i ;
break ;
}
}
/* Work backwards to last character where they differ */
2013-05-21 11:53:48 +04:00
for ( i = ( length - 1 ) ; i > = 0 ; i - - ) {
2010-12-06 20:03:22 +03:00
if ( expect [ i ] ! = actual [ i ] ) {
end = i ;
break ;
}
}
}
2011-06-24 18:01:10 +04:00
/* Round to nearest boundary of 4, except that last word can be short */
2010-12-06 20:03:22 +03:00
start - = ( start % 4 ) ;
end + = 4 - ( end % 4 ) ;
if ( end > = length )
end = length - 1 ;
/* Show the trimmed differences */
fprintf ( stream , " \n Expect [ Region %d-%d " , ( int ) start , ( int ) end ) ;
2013-05-21 11:53:48 +04:00
for ( i = start ; i < end ; i + + ) {
2010-12-06 20:03:22 +03:00
if ( ( i % 4 ) = = 0 )
fprintf ( stream , " \n " ) ;
fprintf ( stream , " 0x%02x, " , ( ( int ) expect [ i ] ) & 0xff ) ;
}
fprintf ( stream , " ] \n " ) ;
fprintf ( stream , " Actual [ Region %d-%d " , ( int ) start , ( int ) end ) ;
2013-05-21 11:53:48 +04:00
for ( i = start ; i < end ; i + + ) {
2010-12-06 20:03:22 +03:00
if ( ( i % 4 ) = = 0 )
fprintf ( stream , " \n " ) ;
fprintf ( stream , " 0x%02x, " , ( ( int ) actual [ i ] ) & 0xff ) ;
}
fprintf ( stream , " ] \n " ) ;
/* Pad to line up with test name ... in virTestRun */
fprintf ( stream , " ... " ) ;
return 0 ;
}
2008-05-29 19:21:45 +04:00
static void
virtTestErrorFuncQuiet ( void * data ATTRIBUTE_UNUSED ,
virErrorPtr err ATTRIBUTE_UNUSED )
{ }
2013-09-17 17:20:24 +04:00
/* register an error handler in tests when using connections */
void
virtTestQuiesceLibvirtErrors ( bool always )
{
if ( always | | ! virTestGetVerbose ( ) )
virSetErrorFunc ( NULL , virtTestErrorFuncQuiet ) ;
}
2008-05-29 19:21:45 +04:00
tests: silence qemuargv2xmltest noise
Before this patch, the testsuite was noisy:
TEST: qemuargv2xmltest
........................................ 40
................20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument '-unknown', adding to the qemu namespace
20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument 'parameter', adding to the qemu namespace
. 57 OK
PASS: qemuargv2xmltest
It's not a real failure (which is why the test was completing
successfully), so much as an intentional warning to the user that use
of the qemu namespace has the potential for undefined effects that
leaked through the default logging behavior. After this patch series,
all tests can access any logged data, and this particular test can
explicitly check for the presence or absence of the warning, such that
the test output becomes:
TEST: qemuargv2xmltest
........................................ 40
................. 57 OK
PASS: qemuargv2xmltest
* tests/testutils.h (virtTestLogContentAndReset): New prototype.
* tests/testutils.c (struct virtTestLogData): New struct.
(virtTestLogOutput, virtTestLogClose, virtTestLogContentAndReset):
New functions.
(virtTestMain): Always capture log data emitted during tests.
* tests/qemuargv2xmltest.c (testCompareXMLToArgvHelper, mymain):
Use flag to mark which tests expect noisy stderr.
(testCompareXMLToArgvFiles): Add parameter to test whether stderr
was appropriately silent.
2010-09-10 20:25:49 +04:00
struct virtTestLogData {
virBuffer buf ;
} ;
static struct virtTestLogData testLog = { VIR_BUFFER_INITIALIZER } ;
2012-09-20 22:24:00 +04:00
static void
2012-09-27 17:44:22 +04:00
virtTestLogOutput ( virLogSource source ATTRIBUTE_UNUSED ,
2012-09-27 16:58:58 +04:00
virLogPriority priority ATTRIBUTE_UNUSED ,
2012-09-27 17:28:44 +04:00
const char * filename ATTRIBUTE_UNUSED ,
int lineno ATTRIBUTE_UNUSED ,
tests: silence qemuargv2xmltest noise
Before this patch, the testsuite was noisy:
TEST: qemuargv2xmltest
........................................ 40
................20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument '-unknown', adding to the qemu namespace
20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument 'parameter', adding to the qemu namespace
. 57 OK
PASS: qemuargv2xmltest
It's not a real failure (which is why the test was completing
successfully), so much as an intentional warning to the user that use
of the qemu namespace has the potential for undefined effects that
leaked through the default logging behavior. After this patch series,
all tests can access any logged data, and this particular test can
explicitly check for the presence or absence of the warning, such that
the test output becomes:
TEST: qemuargv2xmltest
........................................ 40
................. 57 OK
PASS: qemuargv2xmltest
* tests/testutils.h (virtTestLogContentAndReset): New prototype.
* tests/testutils.c (struct virtTestLogData): New struct.
(virtTestLogOutput, virtTestLogClose, virtTestLogContentAndReset):
New functions.
(virtTestMain): Always capture log data emitted during tests.
* tests/qemuargv2xmltest.c (testCompareXMLToArgvHelper, mymain):
Use flag to mark which tests expect noisy stderr.
(testCompareXMLToArgvFiles): Add parameter to test whether stderr
was appropriately silent.
2010-09-10 20:25:49 +04:00
const char * funcname ATTRIBUTE_UNUSED ,
2011-09-28 17:20:07 +04:00
const char * timestamp ,
2012-10-17 22:17:15 +04:00
virLogMetadataPtr metadata ATTRIBUTE_UNUSED ,
2012-05-09 18:18:56 +04:00
unsigned int flags ,
2012-09-27 15:45:33 +04:00
const char * rawstr ATTRIBUTE_UNUSED ,
2011-09-28 17:20:07 +04:00
const char * str ,
void * data )
tests: silence qemuargv2xmltest noise
Before this patch, the testsuite was noisy:
TEST: qemuargv2xmltest
........................................ 40
................20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument '-unknown', adding to the qemu namespace
20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument 'parameter', adding to the qemu namespace
. 57 OK
PASS: qemuargv2xmltest
It's not a real failure (which is why the test was completing
successfully), so much as an intentional warning to the user that use
of the qemu namespace has the potential for undefined effects that
leaked through the default logging behavior. After this patch series,
all tests can access any logged data, and this particular test can
explicitly check for the presence or absence of the warning, such that
the test output becomes:
TEST: qemuargv2xmltest
........................................ 40
................. 57 OK
PASS: qemuargv2xmltest
* tests/testutils.h (virtTestLogContentAndReset): New prototype.
* tests/testutils.c (struct virtTestLogData): New struct.
(virtTestLogOutput, virtTestLogClose, virtTestLogContentAndReset):
New functions.
(virtTestMain): Always capture log data emitted during tests.
* tests/qemuargv2xmltest.c (testCompareXMLToArgvHelper, mymain):
Use flag to mark which tests expect noisy stderr.
(testCompareXMLToArgvFiles): Add parameter to test whether stderr
was appropriately silent.
2010-09-10 20:25:49 +04:00
{
struct virtTestLogData * log = data ;
2012-09-20 22:24:00 +04:00
virCheckFlags ( VIR_LOG_STACK_TRACE , ) ;
2011-09-28 17:20:07 +04:00
virBufferAsprintf ( & log - > buf , " %s: %s " , timestamp , str ) ;
tests: silence qemuargv2xmltest noise
Before this patch, the testsuite was noisy:
TEST: qemuargv2xmltest
........................................ 40
................20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument '-unknown', adding to the qemu namespace
20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument 'parameter', adding to the qemu namespace
. 57 OK
PASS: qemuargv2xmltest
It's not a real failure (which is why the test was completing
successfully), so much as an intentional warning to the user that use
of the qemu namespace has the potential for undefined effects that
leaked through the default logging behavior. After this patch series,
all tests can access any logged data, and this particular test can
explicitly check for the presence or absence of the warning, such that
the test output becomes:
TEST: qemuargv2xmltest
........................................ 40
................. 57 OK
PASS: qemuargv2xmltest
* tests/testutils.h (virtTestLogContentAndReset): New prototype.
* tests/testutils.c (struct virtTestLogData): New struct.
(virtTestLogOutput, virtTestLogClose, virtTestLogContentAndReset):
New functions.
(virtTestMain): Always capture log data emitted during tests.
* tests/qemuargv2xmltest.c (testCompareXMLToArgvHelper, mymain):
Use flag to mark which tests expect noisy stderr.
(testCompareXMLToArgvFiles): Add parameter to test whether stderr
was appropriately silent.
2010-09-10 20:25:49 +04:00
}
static void
virtTestLogClose ( void * data )
{
struct virtTestLogData * log = data ;
virBufferFreeAndReset ( & log - > buf ) ;
}
/* Return a malloc'd string (possibly with strlen of 0) of all data
* logged since the last call to this function , or NULL on failure . */
char *
virtTestLogContentAndReset ( void )
{
char * ret ;
if ( virBufferError ( & testLog . buf ) )
return NULL ;
ret = virBufferContentAndReset ( & testLog . buf ) ;
2013-05-03 16:52:21 +04:00
if ( ! ret )
ignore_value ( VIR_STRDUP ( ret , " " ) ) ;
return ret ;
tests: silence qemuargv2xmltest noise
Before this patch, the testsuite was noisy:
TEST: qemuargv2xmltest
........................................ 40
................20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument '-unknown', adding to the qemu namespace
20:41:28.046: warning : qemuParseCommandLine:6565 : unknown QEMU argument 'parameter', adding to the qemu namespace
. 57 OK
PASS: qemuargv2xmltest
It's not a real failure (which is why the test was completing
successfully), so much as an intentional warning to the user that use
of the qemu namespace has the potential for undefined effects that
leaked through the default logging behavior. After this patch series,
all tests can access any logged data, and this particular test can
explicitly check for the presence or absence of the warning, such that
the test output becomes:
TEST: qemuargv2xmltest
........................................ 40
................. 57 OK
PASS: qemuargv2xmltest
* tests/testutils.h (virtTestLogContentAndReset): New prototype.
* tests/testutils.c (struct virtTestLogData): New struct.
(virtTestLogOutput, virtTestLogClose, virtTestLogContentAndReset):
New functions.
(virtTestMain): Always capture log data emitted during tests.
* tests/qemuargv2xmltest.c (testCompareXMLToArgvHelper, mymain):
Use flag to mark which tests expect noisy stderr.
(testCompareXMLToArgvFiles): Add parameter to test whether stderr
was appropriately silent.
2010-09-10 20:25:49 +04:00
}
2008-05-29 23:41:40 +04:00
# if TEST_OOM_TRACE
2008-05-29 19:21:45 +04:00
static void
2008-05-29 22:47:00 +04:00
virtTestErrorHook ( int n , void * data ATTRIBUTE_UNUSED )
2008-05-29 19:21:45 +04:00
{
void * trace [ 30 ] ;
int ntrace = ARRAY_CARDINALITY ( trace ) ;
Convert 'int i' to 'size_t i' in tests/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 18:09:33 +04:00
size_t i ;
2008-05-29 19:21:45 +04:00
char * * symbols = NULL ;
ntrace = backtrace ( trace , ntrace ) ;
symbols = backtrace_symbols ( trace , ntrace ) ;
if ( symbols ) {
2008-05-29 22:47:00 +04:00
fprintf ( stderr , " Failing allocation %d at: \n " , n ) ;
2013-05-21 11:53:48 +04:00
for ( i = 0 ; i < ntrace ; i + + ) {
2008-05-29 19:21:45 +04:00
if ( symbols [ i ] )
fprintf ( stderr , " TRACE: %s \n " , symbols [ i ] ) ;
}
2012-02-03 03:16:43 +04:00
VIR_FREE ( symbols ) ;
2008-05-29 19:21:45 +04:00
}
}
2008-05-29 23:41:40 +04:00
# endif
2008-05-29 19:21:45 +04:00
2009-11-30 22:01:31 +03:00
static unsigned int
virTestGetFlag ( const char * name ) {
char * flagStr ;
unsigned int flag ;
2009-10-16 19:37:36 +04:00
2009-11-30 22:01:31 +03:00
if ( ( flagStr = getenv ( name ) ) = = NULL )
2009-10-16 19:37:36 +04:00
return 0 ;
2009-11-30 22:01:31 +03:00
if ( virStrToLong_ui ( flagStr , NULL , 10 , & flag ) < 0 )
2009-10-16 19:37:36 +04:00
return 0 ;
2009-11-30 22:01:31 +03:00
return flag ;
}
unsigned int
2010-07-16 20:30:00 +04:00
virTestGetDebug ( void ) {
2009-11-30 22:01:31 +03:00
if ( testDebug = = - 1 )
testDebug = virTestGetFlag ( " VIR_TEST_DEBUG " ) ;
2009-10-16 19:37:36 +04:00
return testDebug ;
}
2008-05-29 19:21:45 +04:00
2009-11-30 22:01:31 +03:00
unsigned int
2010-07-16 20:30:00 +04:00
virTestGetVerbose ( void ) {
2009-11-30 22:01:31 +03:00
if ( testVerbose = = - 1 )
testVerbose = virTestGetFlag ( " VIR_TEST_VERBOSE " ) ;
return testVerbose | | virTestGetDebug ( ) ;
}
2013-08-03 01:43:07 +04:00
unsigned int
virTestGetExpensive ( void ) {
if ( testExpensive = = - 1 )
testExpensive = virTestGetFlag ( " VIR_TEST_EXPENSIVE " ) ;
return testExpensive ;
}
2008-05-29 19:21:45 +04:00
int virtTestMain ( int argc ,
char * * argv ,
2011-04-29 20:21:20 +04:00
int ( * func ) ( void ) )
2008-05-29 19:21:45 +04:00
{
int ret ;
2011-04-29 21:14:23 +04:00
bool abs_srcdir_cleanup = false ;
2013-07-18 18:02:19 +04:00
char * testRange = NULL ;
2009-01-29 00:53:48 +03:00
# if TEST_OOM
2008-05-29 19:21:45 +04:00
int approxAlloc = 0 ;
int n ;
2008-07-09 14:27:17 +04:00
char * oomStr = NULL ;
2008-05-29 19:21:45 +04:00
int oomCount ;
2008-07-07 14:10:29 +04:00
int mp = 0 ;
pid_t * workers ;
int worker = 0 ;
2008-07-09 14:27:17 +04:00
# endif
2011-04-29 20:21:20 +04:00
abs_srcdir = getenv ( " abs_srcdir " ) ;
2011-04-29 21:14:23 +04:00
if ( ! abs_srcdir ) {
abs_srcdir = getcwd ( NULL , 0 ) ;
abs_srcdir_cleanup = true ;
}
2011-04-29 20:21:20 +04:00
if ( ! abs_srcdir )
2013-02-23 02:42:39 +04:00
return EXIT_AM_HARDFAIL ;
2011-04-29 20:21:20 +04:00
2012-05-25 06:34:16 +04:00
progname = last_component ( argv [ 0 ] ) ;
if ( STRPREFIX ( progname , " lt- " ) )
progname + = 3 ;
2011-04-29 20:21:20 +04:00
if ( argc > 1 ) {
fprintf ( stderr , " Usage: %s \n " , argv [ 0 ] ) ;
2012-05-08 21:46:45 +04:00
fputs ( " effective environment variables: \n "
" VIR_TEST_VERBOSE set to show names of individual tests \n "
" VIR_TEST_DEBUG set to show information for debugging failures \n " ,
stderr ) ;
2011-04-29 20:21:20 +04:00
return EXIT_FAILURE ;
}
fprintf ( stderr , " TEST: %s \n " , progname ) ;
2009-11-30 22:01:31 +03:00
2009-01-29 00:53:48 +03:00
if ( virThreadInitialize ( ) < 0 | |
2012-08-04 03:15:00 +04:00
virErrorInitialize ( ) < 0 )
2013-02-23 02:42:39 +04:00
return EXIT_FAILURE ;
2009-01-29 00:53:48 +03:00
2010-10-13 12:41:47 +04:00
virLogSetFromEnv ( ) ;
2010-12-06 20:03:35 +03:00
if ( ! getenv ( " LIBVIRT_DEBUG " ) & & ! virLogGetNbOutputs ( ) ) {
if ( virLogDefineOutput ( virtTestLogOutput , virtTestLogClose , & testLog ,
2012-09-27 17:04:21 +04:00
VIR_LOG_DEBUG , VIR_LOG_TO_STDERR , NULL , 0 ) < 0 )
2013-02-23 02:42:39 +04:00
return EXIT_FAILURE ;
2010-12-06 20:03:35 +03:00
}
2008-05-29 19:21:45 +04:00
2013-07-18 18:02:19 +04:00
if ( ( testRange = getenv ( " VIR_TEST_RANGE " ) ) ! = NULL ) {
char * end = NULL ;
2013-07-19 16:07:41 +04:00
unsigned int iv ;
if ( virStrToLong_ui ( testRange , & end , 10 , & iv ) < 0 ) {
2013-07-18 18:02:19 +04:00
fprintf ( stderr , " Cannot parse range %s \n " , testRange ) ;
return EXIT_FAILURE ;
}
2013-07-19 16:07:41 +04:00
testStart = testEnd = iv ;
2013-07-18 18:02:19 +04:00
if ( end & & * end ) {
if ( * end ! = ' - ' ) {
fprintf ( stderr , " Cannot parse range %s \n " , testRange ) ;
return EXIT_FAILURE ;
}
end + + ;
2013-07-19 16:07:41 +04:00
if ( virStrToLong_ui ( end , NULL , 10 , & iv ) < 0 ) {
2013-07-18 18:02:19 +04:00
fprintf ( stderr , " Cannot parse range %s \n " , testRange ) ;
return EXIT_FAILURE ;
}
2013-07-19 16:07:41 +04:00
testEnd = iv ;
2013-07-18 18:02:19 +04:00
if ( testEnd < testStart ) {
fprintf ( stderr , " Test range end %zu must be >= %zu \n " , testEnd , testStart ) ;
return EXIT_FAILURE ;
}
}
}
2008-07-09 14:27:17 +04:00
# if TEST_OOM
2008-05-29 19:21:45 +04:00
if ( ( oomStr = getenv ( " VIR_TEST_OOM " ) ) ! = NULL ) {
if ( virStrToLong_i ( oomStr , NULL , 10 , & oomCount ) < 0 )
oomCount = 0 ;
if ( oomCount < 0 )
oomCount = 0 ;
if ( oomCount )
testOOM = 1 ;
}
2008-07-07 14:10:29 +04:00
if ( getenv ( " VIR_TEST_MP " ) ! = NULL ) {
mp = sysconf ( _SC_NPROCESSORS_ONLN ) ;
fprintf ( stderr , " Using %d worker processes \n " , mp ) ;
2009-01-29 00:53:48 +03:00
if ( VIR_ALLOC_N ( workers , mp ) < 0 ) {
ret = EXIT_FAILURE ;
goto cleanup ;
}
2008-07-07 14:10:29 +04:00
}
2009-09-02 18:09:04 +04:00
/* Run once to prime any static allocations & ensure it passes */
2011-04-29 20:21:20 +04:00
ret = ( func ) ( ) ;
2008-05-29 19:21:45 +04:00
if ( ret ! = EXIT_SUCCESS )
2009-01-29 00:53:48 +03:00
goto cleanup ;
2008-05-29 19:21:45 +04:00
2010-03-09 21:22:22 +03:00
# if TEST_OOM_TRACE
2009-11-30 22:01:31 +03:00
if ( virTestGetDebug ( ) )
2008-05-29 19:21:45 +04:00
virAllocTestHook ( virtTestErrorHook , NULL ) ;
2010-03-09 21:22:22 +03:00
# endif
2008-05-29 19:21:45 +04:00
if ( testOOM ) {
/* Makes next test runs quiet... */
testOOM + + ;
2013-09-17 17:20:24 +04:00
virtTestQuiesceLibvirtErrors ( true ) ;
2008-05-29 19:21:45 +04:00
2009-09-02 18:09:04 +04:00
virAllocTestInit ( ) ;
/* Run again to count allocs, and ensure it passes :-) */
2011-04-29 20:21:20 +04:00
ret = ( func ) ( ) ;
2009-09-02 18:09:04 +04:00
if ( ret ! = EXIT_SUCCESS )
goto cleanup ;
2008-05-29 19:21:45 +04:00
approxAlloc = virAllocTestCount ( ) ;
testCounter + + ;
2009-11-30 22:01:31 +03:00
if ( virTestGetDebug ( ) )
2013-09-24 19:56:53 +04:00
fprintf ( stderr , " %zu) OOM... \n " , testCounter ) ;
2008-05-29 19:21:45 +04:00
else
2013-09-24 19:56:53 +04:00
fprintf ( stderr , " %zu) OOM of %d allocs " , testCounter , approxAlloc ) ;
2008-05-29 19:21:45 +04:00
2008-07-07 14:10:29 +04:00
if ( mp ) {
Convert 'int i' to 'size_t i' in tests/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 18:09:33 +04:00
size_t i ;
2013-05-21 11:53:48 +04:00
for ( i = 0 ; i < mp ; i + + ) {
2008-07-07 14:10:29 +04:00
workers [ i ] = fork ( ) ;
if ( workers [ i ] = = 0 ) {
worker = i + 1 ;
break ;
}
}
}
2008-05-29 19:21:45 +04:00
/* Run once for each alloc, failing a different one
and validating that the test case failed */
2013-05-21 11:53:48 +04:00
for ( n = 0 ; n < approxAlloc & & ( ! mp | | worker ) ; n + + ) {
2009-04-01 14:31:01 +04:00
if ( mp & &
( n % mp ) ! = ( worker - 1 ) )
2008-07-07 14:10:29 +04:00
continue ;
2009-11-30 22:01:31 +03:00
if ( ! virTestGetDebug ( ) ) {
2008-07-07 14:10:29 +04:00
if ( mp )
fprintf ( stderr , " %d " , worker ) ;
else
fprintf ( stderr , " . " ) ;
2008-05-29 19:21:45 +04:00
fflush ( stderr ) ;
}
virAllocTestOOM ( n + 1 , oomCount ) ;
2011-04-29 20:21:20 +04:00
if ( ( ( func ) ( ) ) ! = EXIT_FAILURE ) {
2008-05-29 19:21:45 +04:00
ret = EXIT_FAILURE ;
break ;
}
}
2008-07-07 14:10:29 +04:00
if ( mp ) {
if ( worker ) {
_exit ( ret ) ;
} else {
Convert 'int i' to 'size_t i' in tests/ files
Convert the type of loop iterators named 'i', 'j', k',
'ii', 'jj', 'kk', to be 'size_t' instead of 'int' or
'unsigned int', also santizing 'ii', 'jj', 'kk' to use
the normal 'i', 'j', 'k' naming
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2013-07-08 18:09:33 +04:00
size_t i ;
2013-05-21 11:53:48 +04:00
for ( i = 0 ; i < mp ; i + + ) {
2012-09-24 20:59:31 +04:00
if ( virProcessWait ( workers [ i ] , NULL ) < 0 )
2008-07-07 14:10:29 +04:00
ret = EXIT_FAILURE ;
}
VIR_FREE ( workers ) ;
}
}
2009-11-30 22:01:31 +03:00
if ( virTestGetDebug ( ) )
2008-05-29 19:21:45 +04:00
fprintf ( stderr , " ... OOM of %d allocs " , approxAlloc ) ;
if ( ret = = EXIT_SUCCESS )
fprintf ( stderr , " OK \n " ) ;
else
fprintf ( stderr , " FAILED \n " ) ;
}
2009-01-29 00:53:48 +03:00
cleanup :
2008-05-29 19:21:45 +04:00
# else
2011-04-29 20:21:20 +04:00
ret = ( func ) ( ) ;
2008-05-29 19:21:45 +04:00
# endif
2009-01-29 00:53:48 +03:00
2011-04-29 21:14:23 +04:00
if ( abs_srcdir_cleanup )
VIR_FREE ( abs_srcdir ) ;
2009-01-29 00:53:48 +03:00
virResetLastError ( ) ;
2011-07-09 13:50:38 +04:00
if ( ! virTestGetVerbose ( ) & & ret ! = EXIT_AM_SKIP ) {
2011-07-11 19:19:11 +04:00
if ( testCounter = = 0 | | testCounter % 40 )
2013-07-18 18:02:19 +04:00
fprintf ( stderr , " %*s " , 40 - ( int ) ( testCounter % 40 ) , " " ) ;
fprintf ( stderr , " %-3zu %s \n " , testCounter , ret = = 0 ? " OK " : " FAIL " ) ;
2009-11-30 22:01:31 +03:00
}
2009-01-29 00:53:48 +03:00
return ret ;
2008-05-29 19:21:45 +04:00
}
2009-05-21 18:22:51 +04:00
int virtTestClearLineRegex ( const char * pattern ,
char * str )
{
regex_t reg ;
char * lineStart = str ;
char * lineEnd = strchr ( str , ' \n ' ) ;
if ( regcomp ( & reg , pattern , REG_EXTENDED | REG_NOSUB ) ! = 0 )
return - 1 ;
while ( lineStart ) {
int ret ;
if ( lineEnd )
* lineEnd = ' \0 ' ;
ret = regexec ( & reg , lineStart , 0 , NULL , 0 ) ;
//fprintf(stderr, "Match %d '%s' '%s'\n", ret, lineStart, pattern);
if ( ret = = 0 ) {
if ( lineEnd ) {
memmove ( lineStart , lineEnd + 1 , strlen ( lineEnd + 1 ) + 1 ) ;
/* Don't update lineStart - just iterate again on this
location */
lineEnd = strchr ( lineStart , ' \n ' ) ;
} else {
* lineStart = ' \0 ' ;
lineStart = NULL ;
}
} else {
if ( lineEnd ) {
* lineEnd = ' \n ' ;
lineStart = lineEnd + 1 ;
lineEnd = strchr ( lineStart , ' \n ' ) ;
} else {
lineStart = NULL ;
}
}
}
regfree ( & reg ) ;
return 0 ;
}