2013-02-13 22:04:05 +04:00
/*
2014-04-02 05:13:51 +04:00
* Copyright ( C ) 2013 - 2014 Red Hat , Inc .
2013-02-13 22:04:05 +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
* License along with this library . If not , see
* < http : //www.gnu.org/licenses/>.
*/
# include <config.h>
2020-02-17 00:59:28 +03:00
# include <unistd.h>
2013-02-13 22:04:05 +04:00
2021-01-22 12:36:21 +03:00
# include "storage_source.h"
2013-02-13 22:04:05 +04:00
# include "testutils.h"
# include "vircommand.h"
2013-05-09 22:59:04 +04:00
# include "virfile.h"
2013-02-13 22:04:05 +04:00
# include "virlog.h"
2014-04-24 14:14:01 +04:00
# include "storage/storage_driver.h"
2013-02-13 22:04:05 +04:00
# define VIR_FROM_THIS VIR_FROM_NONE
2014-02-28 16:16:17 +04:00
VIR_LOG_INIT ( " tests.storagetest " ) ;
2013-02-13 22:04:05 +04:00
# define datadir abs_builddir " / virstoragedata"
static void
testCleanupImages ( void )
{
if ( chdir ( abs_builddir ) < 0 ) {
fprintf ( stderr , " unable to return to correct directory, refusing to "
" clean up %s \n " , datadir ) ;
return ;
}
2014-04-03 01:52:18 +04:00
virFileDeleteTree ( datadir ) ;
2013-02-13 22:04:05 +04:00
}
2014-04-18 16:49:54 +04:00
2021-03-11 10:16:13 +03:00
static virStorageSource *
2014-04-18 16:49:54 +04:00
testStorageFileGetMetadata ( const char * path ,
int format ,
2018-06-04 10:39:28 +03:00
uid_t uid , gid_t gid )
2014-04-18 16:49:54 +04:00
{
2014-04-25 23:44:06 +04:00
struct stat st ;
2020-09-22 12:04:17 +03:00
g_autoptr ( virStorageSource ) def = virStorageSourceNew ( ) ;
2014-04-18 16:49:54 +04:00
2019-02-08 16:35:56 +03:00
def - > type = VIR_STORAGE_TYPE_FILE ;
def - > format = format ;
2014-04-18 16:49:54 +04:00
2014-04-25 23:44:06 +04:00
if ( stat ( path , & st ) = = 0 ) {
if ( S_ISDIR ( st . st_mode ) ) {
2019-02-08 16:35:56 +03:00
def - > type = VIR_STORAGE_TYPE_DIR ;
2014-04-25 23:44:06 +04:00
} else if ( S_ISBLK ( st . st_mode ) ) {
2019-02-08 16:35:56 +03:00
def - > type = VIR_STORAGE_TYPE_BLOCK ;
2014-04-25 23:44:06 +04:00
}
}
2019-10-20 14:49:46 +03:00
def - > path = g_strdup ( path ) ;
2014-04-18 16:49:54 +04:00
2021-03-22 19:21:12 +03:00
/* 20 is picked as an arbitrary depth, since the chains used here don't exceed it */
if ( virStorageSourceGetMetadata ( def , uid , gid , 20 , true ) < 0 )
2019-02-12 21:17:56 +03:00
return NULL ;
2014-04-18 16:49:54 +04:00
2019-10-17 11:10:10 +03:00
return g_steal_pointer ( & def ) ;
2014-04-18 16:49:54 +04:00
}
2021-09-08 18:28:51 +03:00
static char *
2013-02-13 22:04:05 +04:00
testPrepImages ( void )
{
2021-09-08 18:14:29 +03:00
g_autoptr ( virCommand ) cmdraw = NULL ;
2021-09-08 18:13:04 +03:00
g_autoptr ( virCommand ) cmdqcow2 = NULL ;
g_autoptr ( virCommand ) cmdwrap = NULL ;
2021-09-08 17:49:03 +03:00
g_autofree char * absraw = g_strdup_printf ( " %s/raw " , datadir ) ;
g_autofree char * absqcow2 = g_strdup_printf ( " %s/qcow2 " , datadir ) ;
2021-09-08 18:28:51 +03:00
g_autofree char * abswrap = g_strdup_printf ( " %s/wrap " , datadir ) ;
2021-09-08 17:49:03 +03:00
g_autofree char * qemuimg = virFindFileInPath ( " qemu-img " ) ;
2013-02-13 22:04:05 +04:00
2013-02-26 23:45:38 +04:00
if ( ! qemuimg )
2021-09-08 18:28:51 +03:00
return NULL ;
2013-02-13 22:04:05 +04:00
2014-04-10 23:34:15 +04:00
/* Clean up from any earlier failed tests */
virFileDeleteTree ( datadir ) ;
2021-09-08 17:30:52 +03:00
if ( g_mkdir_with_parents ( datadir , 0777 ) < 0 ) {
2021-09-08 18:28:51 +03:00
VIR_TEST_VERBOSE ( " unable to create directory '%s' \n " , datadir ) ;
return NULL ;
2013-02-13 22:04:05 +04:00
}
2021-09-10 13:48:47 +03:00
/* create the following real backing chain with qcow2 images with absolute
2021-09-08 18:28:51 +03:00
* backing and different qcow2 versions :
* datadir / raw < - datadir / qcow2 ( qcow2v2 ) < - datadir / wrap ( qcow2v3 ) */
2021-09-08 18:14:29 +03:00
cmdraw = virCommandNewArgList ( qemuimg , " create " ,
" -f " , " raw " ,
absraw , " 1k " , NULL ) ;
2013-02-13 22:04:05 +04:00
2021-09-08 18:13:04 +03:00
cmdqcow2 = virCommandNewArgList ( qemuimg , " create " ,
" -f " , " qcow2 " ,
" -F " , " raw " ,
" -b " , absraw ,
" -o " , " compat=0.10 " ,
absqcow2 , NULL ) ;
2013-02-13 22:04:05 +04:00
2021-09-08 18:13:04 +03:00
cmdwrap = virCommandNewArgList ( qemuimg , " create " ,
" -f " , " qcow2 " ,
" -F " , " qcow2 " ,
" -b " , absqcow2 ,
" -o " , " compat=1.1 " ,
abswrap , NULL ) ;
2013-02-13 22:04:05 +04:00
2021-09-08 18:28:51 +03:00
if ( virCommandRun ( cmdraw , NULL ) < 0 | |
virCommandRun ( cmdqcow2 , NULL ) < 0 | |
virCommandRun ( cmdwrap , NULL ) < 0 ) {
VIR_TEST_VERBOSE ( " failed to create backing chain in '%s' \n " , datadir ) ;
return NULL ;
}
2013-02-26 23:45:38 +04:00
2021-09-08 18:28:51 +03:00
return g_steal_pointer ( & abswrap ) ;
2013-02-13 22:04:05 +04:00
}
2021-09-08 18:28:51 +03:00
2013-02-13 22:04:05 +04:00
enum {
EXP_PASS = 0 ,
EXP_FAIL = 1 ,
} ;
struct testChainData
{
2021-09-06 15:13:29 +03:00
const char * testname ;
2013-02-13 22:04:05 +04:00
const char * start ;
2014-04-27 04:15:22 +04:00
virStorageFileFormat format ;
2013-02-13 22:04:05 +04:00
unsigned int flags ;
} ;
2014-05-26 17:38:29 +04:00
2013-02-13 22:04:05 +04:00
static int
testStorageChain ( const void * args )
{
const struct testChainData * data = args ;
2021-03-11 10:16:13 +03:00
virStorageSource * elt ;
2019-10-15 15:47:50 +03:00
g_autoptr ( virStorageSource ) meta = NULL ;
2021-09-06 15:13:29 +03:00
g_auto ( virBuffer ) buf = VIR_BUFFER_INITIALIZER ;
g_autofree char * actual = NULL ;
g_autofree char * expectpath = g_strdup_printf ( " %s/virstoragetestdata/out/%s " ,
abs_srcdir , data - > testname ) ;
2013-02-13 22:04:05 +04:00
2021-09-08 15:10:51 +03:00
/* If the filename is NULL it means that the images couldn't be created,
* thus skip this particular test . */
if ( ! data - > start )
return EXIT_AM_SKIP ;
2018-06-04 10:39:28 +03:00
meta = testStorageFileGetMetadata ( data - > start , data - > format , - 1 , - 1 ) ;
2013-02-13 22:04:05 +04:00
if ( ! meta ) {
if ( data - > flags & EXP_FAIL ) {
virResetLastError ( ) ;
2019-02-12 21:17:56 +03:00
return 0 ;
2013-02-13 22:04:05 +04:00
}
2019-02-12 21:17:56 +03:00
return - 1 ;
2013-02-13 22:04:05 +04:00
} else if ( data - > flags & EXP_FAIL ) {
fprintf ( stderr , " call should have failed \n " ) ;
2019-02-12 21:17:56 +03:00
return - 1 ;
2013-02-13 22:04:05 +04:00
}
2019-12-17 19:49:36 +03:00
if ( virGetLastErrorCode ( ) ) {
fprintf ( stderr , " call should not have reported error \n " ) ;
return - 1 ;
}
2021-09-06 15:13:29 +03:00
for ( elt = meta ; virStorageSourceIsBacking ( elt ) ; elt = elt - > backingStore ) {
g_autofree char * strippedPath = virTestStablePath ( elt - > path ) ;
g_autofree char * strippedBackingStoreRaw = virTestStablePath ( elt - > backingStoreRaw ) ;
g_autofree char * strippedRelPath = virTestStablePath ( elt - > relPath ) ;
virBufferAsprintf ( & buf ,
" path:%s \n "
" backingStoreRaw: %s \n "
" capacity: %lld \n "
" encryption: %d \n "
" relPath:%s \n "
" type:%d \n "
" format:%d \n "
" protocol:%s \n "
" hostname:%s \n \n " ,
strippedPath ,
strippedBackingStoreRaw ,
elt - > capacity ,
! ! elt - > encryption ,
strippedRelPath ,
elt - > type ,
elt - > format ,
virStorageNetProtocolTypeToString ( elt - > protocol ) ,
NULLSTR ( elt - > nhosts ? elt - > hosts [ 0 ] . name : NULL ) ) ;
}
2013-02-13 22:04:05 +04:00
2021-09-06 15:13:29 +03:00
virBufferTrim ( & buf , " \n " ) ;
2013-02-13 22:04:05 +04:00
2021-09-06 15:13:29 +03:00
actual = virBufferContentAndReset ( & buf ) ;
if ( virTestCompareToFile ( actual , expectpath ) < 0 )
2019-02-12 21:17:56 +03:00
return - 1 ;
2013-02-13 22:04:05 +04:00
2019-02-12 21:17:56 +03:00
return 0 ;
2013-02-13 22:04:05 +04:00
}
2014-04-10 23:56:57 +04:00
struct testLookupData
{
2021-03-11 10:16:13 +03:00
virStorageSource * chain ;
2014-04-18 16:35:33 +04:00
const char * target ;
2021-03-11 10:16:13 +03:00
virStorageSource * from ;
2014-04-10 23:56:57 +04:00
const char * name ;
2014-04-18 16:35:33 +04:00
unsigned int expIndex ;
2021-03-11 10:16:13 +03:00
virStorageSource * expMeta ;
virStorageSource * expParent ;
2014-04-10 23:56:57 +04:00
} ;
static int
testStorageLookup ( const void * args )
{
const struct testLookupData * data = args ;
int ret = 0 ;
2021-03-11 10:16:13 +03:00
virStorageSource * result ;
virStorageSource * actualParent ;
2014-04-10 23:56:57 +04:00
2021-01-21 18:46:14 +03:00
result = virStorageSourceChainLookup ( data - > chain , data - > from ,
2021-01-25 17:02:26 +03:00
data - > name , data - > target , & actualParent ) ;
2021-09-07 18:32:22 +03:00
if ( ! data - > expMeta )
2014-04-10 23:56:57 +04:00
virResetLastError ( ) ;
2014-04-18 17:25:19 +04:00
if ( data - > expMeta ! = result ) {
2021-09-07 18:32:22 +03:00
fprintf ( stderr , " meta: expected %s, got %s \n " ,
NULLSTR ( data - > expMeta ? data - > expMeta - > path : NULL ) ,
NULLSTR ( result ? result - > path : NULL ) ) ;
2014-04-10 23:56:57 +04:00
ret = - 1 ;
}
2021-09-07 18:32:22 +03:00
2021-01-25 17:15:02 +03:00
if ( data - > expIndex > 0 ) {
if ( ! result ) {
fprintf ( stderr , " index: resulting lookup is empty, can't match index \n " ) ;
ret = - 1 ;
} else {
if ( result - > id ! = data - > expIndex ) {
fprintf ( stderr , " index: expected %u, got %u \n " , data - > expIndex , result - > id ) ;
ret = - 1 ;
}
}
}
2014-06-25 17:43:04 +04:00
if ( data - > expParent ! = actualParent ) {
2014-04-10 23:56:57 +04:00
fprintf ( stderr , " parent: expected %s, got %s \n " ,
2014-06-25 17:43:04 +04:00
NULLSTR ( data - > expParent ? data - > expParent - > path : NULL ) ,
NULLSTR ( actualParent ? actualParent - > path : NULL ) ) ;
2014-04-10 23:56:57 +04:00
ret = - 1 ;
}
return ret ;
}
2014-05-02 21:22:17 +04:00
2014-05-13 12:10:56 +04:00
static virStorageSource backingchain [ 12 ] ;
static void
testPathRelativePrepare ( void )
{
size_t i ;
2019-10-15 14:55:26 +03:00
for ( i = 0 ; i < G_N_ELEMENTS ( backingchain ) ; i + + ) {
2017-10-12 21:45:50 +03:00
backingchain [ i ] . type = VIR_STORAGE_TYPE_FILE ;
2019-10-15 14:55:26 +03:00
if ( i < G_N_ELEMENTS ( backingchain ) - 1 )
2014-05-13 12:10:56 +04:00
backingchain [ i ] . backingStore = & backingchain [ i + 1 ] ;
else
backingchain [ i ] . backingStore = NULL ;
2014-05-27 12:40:59 +04:00
backingchain [ i ] . relPath = NULL ;
2014-05-13 12:10:56 +04:00
}
/* normal relative backing chain */
backingchain [ 0 ] . path = ( char * ) " /path/to/some/img " ;
backingchain [ 1 ] . path = ( char * ) " /path/to/some/asdf " ;
backingchain [ 1 ] . relPath = ( char * ) " asdf " ;
backingchain [ 2 ] . path = ( char * ) " /path/to/some/test " ;
backingchain [ 2 ] . relPath = ( char * ) " test " ;
backingchain [ 3 ] . path = ( char * ) " /path/to/some/blah " ;
backingchain [ 3 ] . relPath = ( char * ) " blah " ;
/* ovirt's backing chain */
backingchain [ 4 ] . path = ( char * ) " /path/to/volume/image1 " ;
backingchain [ 5 ] . path = ( char * ) " /path/to/volume/image2 " ;
backingchain [ 5 ] . relPath = ( char * ) " ../volume/image2 " ;
backingchain [ 6 ] . path = ( char * ) " /path/to/volume/image3 " ;
backingchain [ 6 ] . relPath = ( char * ) " ../volume/image3 " ;
backingchain [ 7 ] . path = ( char * ) " /path/to/volume/image4 " ;
backingchain [ 7 ] . relPath = ( char * ) " ../volume/image4 " ;
/* some arbitrarily crazy backing chains */
backingchain [ 8 ] . path = ( char * ) " /crazy/base/image " ;
backingchain [ 9 ] . path = ( char * ) " /crazy/base/directory/stuff/volumes/garbage/image2 " ;
backingchain [ 9 ] . relPath = ( char * ) " directory/stuff/volumes/garbage/image2 " ;
backingchain [ 10 ] . path = ( char * ) " /crazy/base/directory/image3 " ;
backingchain [ 10 ] . relPath = ( char * ) " ../../../image3 " ;
backingchain [ 11 ] . path = ( char * ) " /crazy/base/blah/image4 " ;
backingchain [ 11 ] . relPath = ( char * ) " ../blah/image4 " ;
}
struct testPathRelativeBacking
{
2021-03-11 10:16:13 +03:00
virStorageSource * top ;
virStorageSource * base ;
2014-05-13 12:10:56 +04:00
const char * expect ;
} ;
static int
testPathRelative ( const void * args )
{
const struct testPathRelativeBacking * data = args ;
2019-10-15 16:16:31 +03:00
g_autofree char * actual = NULL ;
2014-05-13 12:10:56 +04:00
2021-01-21 18:46:14 +03:00
if ( virStorageSourceGetRelativeBackingPath ( data - > top ,
data - > base ,
& actual ) < 0 ) {
2014-05-13 12:10:56 +04:00
fprintf ( stderr , " relative backing path resolution failed \n " ) ;
2019-02-01 20:03:16 +03:00
return - 1 ;
2014-05-13 12:10:56 +04:00
}
if ( STRNEQ_NULLABLE ( data - > expect , actual ) ) {
fprintf ( stderr , " relative path resolution from '%s' to '%s': "
" expected '%s', got '%s' \n " ,
data - > top - > path , data - > base - > path ,
NULLSTR ( data - > expect ) , NULLSTR ( actual ) ) ;
2019-02-01 20:03:16 +03:00
return - 1 ;
2014-05-13 12:10:56 +04:00
}
2019-02-01 20:03:16 +03:00
return 0 ;
2014-05-13 12:10:56 +04:00
}
2014-05-02 21:22:17 +04:00
2016-07-12 18:04:16 +03:00
struct testBackingParseData {
const char * backing ;
const char * expect ;
2019-08-15 20:27:43 +03:00
int rv ;
2016-07-12 18:04:16 +03:00
} ;
static int
testBackingParse ( const void * args )
{
const struct testBackingParseData * data = args ;
2019-10-15 15:47:50 +03:00
g_auto ( virBuffer ) buf = VIR_BUFFER_INITIALIZER ;
2019-10-15 16:16:31 +03:00
g_autofree char * xml = NULL ;
2019-10-15 15:47:50 +03:00
g_autoptr ( virStorageSource ) src = NULL ;
2019-08-15 20:27:43 +03:00
int rc ;
int erc = data - > rv ;
2020-04-14 11:26:24 +03:00
unsigned int xmlformatflags = VIR_DOMAIN_DEF_FORMAT_SECURE ;
2016-07-12 18:04:16 +03:00
2019-08-15 20:27:43 +03:00
/* expect failure return code with NULL expected data */
if ( ! data - > expect )
erc = - 1 ;
if ( ( rc = virStorageSourceNewFromBackingAbsolute ( data - > backing , & src ) ) ! = erc ) {
fprintf ( stderr , " expected return value '%d' actual '%d' \n " , erc , rc ) ;
return - 1 ;
2016-07-12 18:04:16 +03:00
}
2019-08-15 20:27:43 +03:00
if ( ! src )
return 0 ;
2016-07-12 18:04:16 +03:00
if ( src & & ! data - > expect ) {
fprintf ( stderr , " parsing of backing store string '%s' should "
" have failed \n " , data - > backing ) ;
2019-08-15 20:16:21 +03:00
return - 1 ;
2016-07-12 18:04:16 +03:00
}
2020-05-07 15:00:28 +03:00
if ( virDomainDiskSourceFormat ( & buf , src , " source " , 0 , false , xmlformatflags ,
false , false , NULL ) < 0 | |
2016-07-12 18:04:16 +03:00
! ( xml = virBufferContentAndReset ( & buf ) ) ) {
fprintf ( stderr , " failed to format disk source xml \n " ) ;
2019-08-15 20:16:21 +03:00
return - 1 ;
2016-07-12 18:04:16 +03:00
}
2016-06-16 15:16:43 +03:00
if ( STRNEQ ( xml , data - > expect ) ) {
2016-07-12 18:04:16 +03:00
fprintf ( stderr , " \n backing store string '%s' \n "
" expected storage source xml: \n %s \n "
" actual storage source xml: \n %s \n " ,
data - > backing , data - > expect , xml ) ;
2019-08-15 20:16:21 +03:00
return - 1 ;
2016-07-12 18:04:16 +03:00
}
2019-08-15 20:16:21 +03:00
return 0 ;
2016-07-12 18:04:16 +03:00
}
2013-02-13 22:04:05 +04:00
static int
mymain ( void )
{
2021-09-08 18:28:51 +03:00
int ret = 0 ;
tests: refactor virstoragetest for less stack space
I'm about to add fields to virStorageFileMetadata, which means
also adding fields to the testFileData struct in virstoragetest.
Alas, adding even one pointer on an x86_64 machine gave me a
dreaded compiler error:
virstoragetest.c:712:1: error: the frame size of 4208 bytes is larger than 4096 bytes [-Werror=frame-larger-than=]
After some experimentation, I realized that each test was creating
yet another testChainData (which contains testFileData) on the stack;
forcing the reuse of one of these structures instead of creating a
fresh one each time drastically reduces the size requirements. While
at it, I also got rid of a lot of intermediate structs, with some
macro magic that lets me directly build up the destination chains
inline.
For a bit more insight into what this patch does:
The old code uses an intermediate variable as a fixed-size array
of structs:
testFileData chain[] = { a, b };
data.files = chain;
In the new code, the use of VIR_FLATTEN_* allows the TEST_CHAIN()
macro to still take a single argument for each chain, but now of
the form '(a, b)', where it is turned into the var-args 'a, b'
multiple arguments understood by TEST_ONE_CHAIN(). Thus, the
new code avoids an intermediate variable, and directly provides
the list of pointers to be assigned into array elements:
data.files = { &a, &b };
* tests/virstoragetest.c (mymain): Rewrite TEST_ONE_CHAIN to
reuse the same struct for each test, and to take the data
inline rather than via intermediate variables.
(testChainData): Use bounded array of pointers instead of
unlimited array of struct.
(testStorageChain): Reflect struct change.
Signed-off-by: Eric Blake <eblake@redhat.com>
2014-04-04 06:26:59 +04:00
struct testChainData data ;
2014-06-13 19:23:10 +04:00
struct testLookupData data2 ;
2014-05-13 12:10:56 +04:00
struct testPathRelativeBacking data4 ;
2016-07-12 18:04:16 +03:00
struct testBackingParseData data5 ;
2021-09-08 18:28:51 +03:00
g_autofree char * realchain = NULL ;
2021-09-07 19:58:32 +03:00
virStorageSource fakeChain [ 4 ] ;
virStorageSource * chain = & fakeChain [ 0 ] ;
virStorageSource * chain2 = & fakeChain [ 1 ] ;
virStorageSource * chain3 = & fakeChain [ 2 ] ;
2013-02-13 22:04:05 +04:00
2017-05-11 17:50:04 +03:00
if ( storageRegisterAll ( ) < 0 )
return EXIT_FAILURE ;
2017-01-13 18:50:11 +03:00
2021-09-06 15:13:29 +03:00
# define TEST_CHAIN(testname, start, format, flags) \
2017-11-03 15:09:47 +03:00
do { \
2021-09-06 15:13:29 +03:00
data = ( struct testChainData ) { testname , start , format , flags } ; \
if ( virTestRun ( testname , testStorageChain , & data ) < 0 ) \
2017-11-03 15:09:47 +03:00
ret = - 1 ; \
2013-02-13 22:04:05 +04:00
} while ( 0 )
/* Missing file */
2021-09-06 15:13:29 +03:00
TEST_CHAIN ( " missing " , " bogus " , VIR_STORAGE_FILE_RAW , EXP_FAIL ) ;
2013-02-13 22:04:05 +04:00
/* Raw image, whether with right format or no specified format */
2021-09-08 15:01:42 +03:00
TEST_CHAIN ( " raw-raw " ,
abs_srcdir " /virstoragetestdata/images/raw " ,
VIR_STORAGE_FILE_RAW , EXP_PASS ) ;
TEST_CHAIN ( " raw-auto " ,
abs_srcdir " /virstoragetestdata/images/raw " ,
VIR_STORAGE_FILE_AUTO , EXP_PASS ) ;
2013-02-13 22:04:05 +04:00
/* Qcow2 file with relative raw backing, format provided */
2021-09-08 15:08:47 +03:00
TEST_CHAIN ( " qcow2-qcow2_raw-raw-relative " ,
abs_srcdir " /virstoragetestdata/images/qcow2_raw-raw-relative.qcow2 " ,
VIR_STORAGE_FILE_QCOW2 , EXP_PASS ) ;
TEST_CHAIN ( " qcow2-auto_raw-raw-relative " ,
abs_srcdir " /virstoragetestdata/images/qcow2_raw-raw-relative.qcow2 " ,
VIR_STORAGE_FILE_AUTO , EXP_PASS ) ;
2013-02-13 22:04:05 +04:00
2021-09-08 17:44:13 +03:00
/* qcow2 chain with absolute backing formatted with a real qemu-img */
2021-09-08 18:28:51 +03:00
/* Prep some files with qemu-img; if that is not found on PATH, the test
* using the data skips itself if the data can ' t be prepared */
realchain = testPrepImages ( ) ;
TEST_CHAIN ( " qcow2-qcow2_qcow2-qcow2_raw-raw " , realchain , VIR_STORAGE_FILE_QCOW2 , EXP_PASS ) ;
TEST_CHAIN ( " qcow2-auto_qcow2-qcow2_raw-raw " , realchain , VIR_STORAGE_FILE_AUTO , EXP_PASS ) ;
testCleanupImages ( ) ;
2013-02-13 22:04:05 +04:00
2021-09-08 18:57:30 +03:00
/* Test various combinations of qcow2 images with missing 'backing_format' */
TEST_CHAIN ( " qcow2-qcow2_qcow2-qcow2_qcow2-auto " ,
abs_srcdir " /virstoragetestdata/images/qcow2_qcow2-qcow2_qcow2-auto.qcow2 " ,
VIR_STORAGE_FILE_QCOW2 , EXP_PASS ) ;
TEST_CHAIN ( " qcow2-qcow2_qcow2-qcow2_raw-auto " ,
abs_srcdir " /virstoragetestdata/images/qcow2_qcow2-qcow2_raw-auto.qcow2 " ,
VIR_STORAGE_FILE_QCOW2 , EXP_PASS ) ;
TEST_CHAIN ( " qcow2-qcow2_qcow2-auto_qcow2-auto " ,
abs_srcdir " /virstoragetestdata/images/qcow2_qcow2-auto_qcow2-auto.qcow2 " ,
VIR_STORAGE_FILE_QCOW2 , EXP_FAIL ) ;
TEST_CHAIN ( " qcow2-qcow2_qcow2-auto " ,
abs_srcdir " /virstoragetestdata/images/qcow2_qcow2-auto.qcow2 " ,
VIR_STORAGE_FILE_QCOW2 , EXP_PASS ) ;
2013-02-13 22:04:05 +04:00
/* Qcow2 file with missing backing file but specified type */
2021-09-08 10:18:03 +03:00
TEST_CHAIN ( " qcow2-qcow2_missing " ,
abs_srcdir " /virstoragetestdata/images/qcow2_qcow2-missing.qcow2 " ,
VIR_STORAGE_FILE_QCOW2 , EXP_FAIL ) ;
2013-02-13 22:04:05 +04:00
2014-10-29 12:55:23 +03:00
/* Qcow2 file with backing protocol instead of file */
2021-09-08 10:11:54 +03:00
TEST_CHAIN ( " qcow2-qcow2_nbd-raw " ,
abs_srcdir " /virstoragetestdata/images/qcow2_nbd-raw.qcow2 " ,
VIR_STORAGE_FILE_QCOW2 , EXP_PASS ) ;
2014-10-29 12:55:23 +03:00
2013-02-13 22:04:05 +04:00
/* qed file */
2021-09-08 10:06:08 +03:00
TEST_CHAIN ( " qed-qed_raw " ,
abs_srcdir " /virstoragetestdata/images/qed_raw-raw-relative " ,
VIR_STORAGE_FILE_QED , EXP_PASS ) ;
TEST_CHAIN ( " qed-auto_raw " ,
abs_srcdir " /virstoragetestdata/images/qed_raw-raw-relative " ,
VIR_STORAGE_FILE_AUTO , EXP_PASS ) ;
2013-02-13 22:04:05 +04:00
2014-04-04 23:35:22 +04:00
/* directory */
2021-09-08 10:03:06 +03:00
TEST_CHAIN ( " directory-raw " , abs_srcdir " /virstoragetestdata/images/ " , VIR_STORAGE_FILE_RAW , EXP_PASS ) ;
TEST_CHAIN ( " directory-none " , abs_srcdir " /virstoragetestdata/images/ " , VIR_STORAGE_FILE_NONE , EXP_PASS ) ;
TEST_CHAIN ( " directory-dir " , abs_srcdir " /virstoragetestdata/images/ " , VIR_STORAGE_FILE_DIR , EXP_PASS ) ;
2014-04-04 23:35:22 +04:00
2013-02-13 22:04:05 +04:00
/* Behavior of symlinks to qcow2 with relative backing files */
2021-09-08 17:30:52 +03:00
TEST_CHAIN ( " qcow2-symlinks " ,
abs_srcdir " /virstoragetestdata/images/sub/link2 " ,
VIR_STORAGE_FILE_QCOW2 , EXP_PASS ) ;
2014-04-04 23:35:22 +04:00
/* Behavior of an infinite loop chain */
2021-09-06 17:56:19 +03:00
TEST_CHAIN ( " qcow2-qcow2_infinite-self " ,
abs_srcdir " /virstoragetestdata/images/loop-self.qcow2 " ,
VIR_STORAGE_FILE_QCOW2 , EXP_FAIL ) ;
TEST_CHAIN ( " qcow2-qcow2_infinite-mutual " ,
abs_srcdir " /virstoragetestdata/images/loop-2.qcow2 " ,
VIR_STORAGE_FILE_QCOW2 , EXP_FAIL ) ;
2014-11-04 19:35:16 +03:00
2021-09-07 19:58:32 +03:00
/* setup data for backing chain lookup testing */
if ( chdir ( abs_srcdir " /virstoragetestdata/lookup " ) < 0 ) {
2021-09-09 10:53:30 +03:00
VIR_TEST_VERBOSE ( " failed to chdir into '%s' \n " ,
abs_srcdir " /virstoragetestdata/lookup " ) ;
return EXIT_FAILURE ;
2014-04-10 23:56:57 +04:00
}
2021-09-07 19:58:32 +03:00
memset ( fakeChain , 0 , sizeof ( fakeChain ) ) ;
fakeChain [ 0 ] . backingStore = & fakeChain [ 1 ] ;
fakeChain [ 1 ] . backingStore = & fakeChain [ 2 ] ;
fakeChain [ 2 ] . backingStore = & fakeChain [ 3 ] ;
fakeChain [ 0 ] . type = VIR_STORAGE_TYPE_FILE ;
fakeChain [ 1 ] . type = VIR_STORAGE_TYPE_FILE ;
fakeChain [ 2 ] . type = VIR_STORAGE_TYPE_FILE ;
fakeChain [ 0 ] . format = VIR_STORAGE_FILE_QCOW2 ;
fakeChain [ 1 ] . format = VIR_STORAGE_FILE_QCOW2 ;
fakeChain [ 2 ] . format = VIR_STORAGE_FILE_RAW ;
/* backing chain with relative start and absolute backing paths */
fakeChain [ 0 ] . path = ( char * ) " wrap " ;
fakeChain [ 1 ] . path = ( char * ) abs_srcdir " /virstoragetestdata/lookup/qcow2 " ;
fakeChain [ 2 ] . path = ( char * ) abs_srcdir " /virstoragetestdata/lookup/raw " ;
2014-04-10 23:56:57 +04:00
2021-09-07 18:32:22 +03:00
# define TEST_LOOKUP_TARGET(id, target, from, name, index, meta, parent) \
2017-11-03 15:09:47 +03:00
do { \
data2 = ( struct testLookupData ) { \
2021-09-07 18:32:22 +03:00
chain , target , from , name , index , meta , parent , } ; \
if ( virTestRun ( " Chain lookup " # id , testStorageLookup , & data2 ) < 0 ) \
2017-11-03 15:09:47 +03:00
ret = - 1 ; \
2014-04-10 23:56:57 +04:00
} while ( 0 )
2021-09-07 18:32:22 +03:00
# define TEST_LOOKUP(id, from, name, meta, parent) \
TEST_LOOKUP_TARGET ( id , NULL , from , name , 0 , meta , parent )
TEST_LOOKUP ( 0 , NULL , " bogus " , NULL , NULL ) ;
TEST_LOOKUP ( 1 , chain , " bogus " , NULL , NULL ) ;
TEST_LOOKUP ( 2 , NULL , " wrap " , chain , NULL ) ;
TEST_LOOKUP ( 3 , chain , " wrap " , NULL , NULL ) ;
TEST_LOOKUP ( 4 , chain2 , " wrap " , NULL , NULL ) ;
2021-09-07 19:58:32 +03:00
TEST_LOOKUP ( 5 , NULL , abs_srcdir " /virstoragetestdata/lookup/wrap " , chain , NULL ) ;
TEST_LOOKUP ( 6 , chain , abs_srcdir " /virstoragetestdata/lookup/wrap " , NULL , NULL ) ;
TEST_LOOKUP ( 7 , chain2 , abs_srcdir " /virstoragetestdata/lookup/wrap " , NULL , NULL ) ;
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 8 , NULL , " qcow2 " , chain2 , chain ) ;
TEST_LOOKUP ( 9 , chain , " qcow2 " , chain2 , chain ) ;
TEST_LOOKUP ( 10 , chain2 , " qcow2 " , NULL , NULL ) ;
TEST_LOOKUP ( 11 , chain3 , " qcow2 " , NULL , NULL ) ;
2021-09-07 19:58:32 +03:00
TEST_LOOKUP ( 12 , NULL , abs_srcdir " /virstoragetestdata/lookup/qcow2 " , chain2 , chain ) ;
TEST_LOOKUP ( 13 , chain , abs_srcdir " /virstoragetestdata/lookup/qcow2 " , chain2 , chain ) ;
TEST_LOOKUP ( 14 , chain2 , abs_srcdir " /virstoragetestdata/lookup/qcow2 " , NULL , NULL ) ;
TEST_LOOKUP ( 15 , chain3 , abs_srcdir " /virstoragetestdata/lookup/qcow2 " , NULL , NULL ) ;
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 16 , NULL , " raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 17 , chain , " raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 18 , chain2 , " raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 19 , chain3 , " raw " , NULL , NULL ) ;
2021-09-07 19:58:32 +03:00
TEST_LOOKUP ( 20 , NULL , abs_srcdir " /virstoragetestdata/lookup/raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 21 , chain , abs_srcdir " /virstoragetestdata/lookup/raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 22 , chain2 , abs_srcdir " /virstoragetestdata/lookup/raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 23 , chain3 , abs_srcdir " /virstoragetestdata/lookup/raw " , NULL , NULL ) ;
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 24 , NULL , NULL , chain3 , chain2 ) ;
TEST_LOOKUP ( 25 , chain , NULL , chain3 , chain2 ) ;
TEST_LOOKUP ( 26 , chain2 , NULL , chain3 , chain2 ) ;
TEST_LOOKUP ( 27 , chain3 , NULL , NULL , NULL ) ;
2014-04-10 23:56:57 +04:00
2021-09-07 19:58:32 +03:00
/* relative backing, absolute start */
fakeChain [ 0 ] . path = ( char * ) abs_srcdir " /virstoragetestdata/lookup/wrap " ;
2014-04-10 23:56:57 +04:00
2021-09-07 19:58:32 +03:00
fakeChain [ 1 ] . relPath = ( char * ) " qcow2 " ;
fakeChain [ 2 ] . relPath = ( char * ) " raw " ;
2014-04-10 23:56:57 +04:00
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 28 , NULL , " bogus " , NULL , NULL ) ;
TEST_LOOKUP ( 29 , chain , " bogus " , NULL , NULL ) ;
TEST_LOOKUP ( 30 , NULL , " wrap " , chain , NULL ) ;
TEST_LOOKUP ( 31 , chain , " wrap " , NULL , NULL ) ;
TEST_LOOKUP ( 32 , chain2 , " wrap " , NULL , NULL ) ;
2021-09-07 19:58:32 +03:00
TEST_LOOKUP ( 33 , NULL , abs_srcdir " /virstoragetestdata/lookup/wrap " , chain , NULL ) ;
TEST_LOOKUP ( 34 , chain , abs_srcdir " /virstoragetestdata/lookup/wrap " , NULL , NULL ) ;
TEST_LOOKUP ( 35 , chain2 , abs_srcdir " /virstoragetestdata/lookup/wrap " , NULL , NULL ) ;
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 36 , NULL , " qcow2 " , chain2 , chain ) ;
TEST_LOOKUP ( 37 , chain , " qcow2 " , chain2 , chain ) ;
TEST_LOOKUP ( 38 , chain2 , " qcow2 " , NULL , NULL ) ;
TEST_LOOKUP ( 39 , chain3 , " qcow2 " , NULL , NULL ) ;
2021-09-07 19:58:32 +03:00
TEST_LOOKUP ( 40 , NULL , abs_srcdir " /virstoragetestdata/lookup/qcow2 " , chain2 , chain ) ;
TEST_LOOKUP ( 41 , chain , abs_srcdir " /virstoragetestdata/lookup/qcow2 " , chain2 , chain ) ;
TEST_LOOKUP ( 42 , chain2 , abs_srcdir " /virstoragetestdata/lookup/qcow2 " , NULL , NULL ) ;
TEST_LOOKUP ( 43 , chain3 , abs_srcdir " /virstoragetestdata/lookup/qcow2 " , NULL , NULL ) ;
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 44 , NULL , " raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 45 , chain , " raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 46 , chain2 , " raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 47 , chain3 , " raw " , NULL , NULL ) ;
2021-09-07 19:58:32 +03:00
TEST_LOOKUP ( 48 , NULL , abs_srcdir " /virstoragetestdata/lookup/raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 49 , chain , abs_srcdir " /virstoragetestdata/lookup/raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 50 , chain2 , abs_srcdir " /virstoragetestdata/lookup/raw " , chain3 , chain2 ) ;
TEST_LOOKUP ( 51 , chain3 , abs_srcdir " /virstoragetestdata/lookup/raw " , NULL , NULL ) ;
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 52 , NULL , NULL , chain3 , chain2 ) ;
TEST_LOOKUP ( 53 , chain , NULL , chain3 , chain2 ) ;
TEST_LOOKUP ( 54 , chain2 , NULL , chain3 , chain2 ) ;
TEST_LOOKUP ( 55 , chain3 , NULL , NULL , NULL ) ;
2014-04-10 23:56:57 +04:00
/* Use link to wrap with cross-directory relative backing */
2021-09-07 19:58:32 +03:00
fakeChain [ 0 ] . path = ( char * ) abs_srcdir " /virstoragetestdata/lookup/sub/link2 " ;
2014-04-10 23:56:57 +04:00
2021-09-07 19:58:32 +03:00
fakeChain [ 1 ] . relPath = ( char * ) " ../qcow2 " ;
fakeChain [ 2 ] . relPath = ( char * ) " raw " ;
2014-04-10 23:56:57 +04:00
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 56 , NULL , " bogus " , NULL , NULL ) ;
TEST_LOOKUP ( 57 , NULL , " sub/link2 " , chain , NULL ) ;
TEST_LOOKUP ( 58 , NULL , " wrap " , chain , NULL ) ;
2021-09-07 19:58:32 +03:00
TEST_LOOKUP ( 59 , NULL , abs_srcdir " /virstoragetestdata/lookup/wrap " , chain , NULL ) ;
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 60 , NULL , " ../qcow2 " , chain2 , chain ) ;
TEST_LOOKUP ( 61 , NULL , " qcow2 " , NULL , NULL ) ;
2021-09-07 19:58:32 +03:00
TEST_LOOKUP ( 62 , NULL , abs_srcdir " /virstoragetestdata/lookup/qcow2 " , chain2 , chain ) ;
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 63 , NULL , " raw " , chain3 , chain2 ) ;
2021-09-07 19:58:32 +03:00
TEST_LOOKUP ( 64 , NULL , abs_srcdir " /virstoragetestdata/lookup/raw " , chain3 , chain2 ) ;
2021-09-07 18:32:22 +03:00
TEST_LOOKUP ( 65 , NULL , NULL , chain3 , chain2 ) ;
2021-09-07 19:58:32 +03:00
/* index lookup */
fakeChain [ 0 ] . id = 0 ;
fakeChain [ 1 ] . id = 1 ;
fakeChain [ 2 ] . id = 2 ;
2021-09-07 18:32:22 +03:00
TEST_LOOKUP_TARGET ( 66 , " vda " , NULL , " bogus[1] " , 0 , NULL , NULL ) ;
TEST_LOOKUP_TARGET ( 67 , " vda " , NULL , " vda[-1] " , 0 , NULL , NULL ) ;
TEST_LOOKUP_TARGET ( 68 , " vda " , NULL , " vda[1][1] " , 0 , NULL , NULL ) ;
TEST_LOOKUP_TARGET ( 69 , " vda " , NULL , " wrap " , 0 , chain , NULL ) ;
TEST_LOOKUP_TARGET ( 70 , " vda " , chain , " wrap " , 0 , NULL , NULL ) ;
TEST_LOOKUP_TARGET ( 71 , " vda " , chain2 , " wrap " , 0 , NULL , NULL ) ;
TEST_LOOKUP_TARGET ( 72 , " vda " , NULL , " vda[0] " , 0 , NULL , NULL ) ;
TEST_LOOKUP_TARGET ( 73 , " vda " , NULL , " vda[1] " , 1 , chain2 , chain ) ;
TEST_LOOKUP_TARGET ( 74 , " vda " , chain , " vda[1] " , 1 , chain2 , chain ) ;
TEST_LOOKUP_TARGET ( 75 , " vda " , chain2 , " vda[1] " , 0 , NULL , NULL ) ;
TEST_LOOKUP_TARGET ( 76 , " vda " , chain3 , " vda[1] " , 0 , NULL , NULL ) ;
TEST_LOOKUP_TARGET ( 77 , " vda " , NULL , " vda[2] " , 2 , chain3 , chain2 ) ;
TEST_LOOKUP_TARGET ( 78 , " vda " , chain , " vda[2] " , 2 , chain3 , chain2 ) ;
TEST_LOOKUP_TARGET ( 79 , " vda " , chain2 , " vda[2] " , 2 , chain3 , chain2 ) ;
TEST_LOOKUP_TARGET ( 80 , " vda " , chain3 , " vda[2] " , 0 , NULL , NULL ) ;
TEST_LOOKUP_TARGET ( 81 , " vda " , NULL , " vda[3] " , 0 , NULL , NULL ) ;
2014-04-18 16:35:33 +04:00
2017-11-03 15:09:47 +03:00
# define TEST_RELATIVE_BACKING(id, TOP, BASE, EXPECT) \
do { \
data4 . top = & TOP ; \
data4 . base = & BASE ; \
data4 . expect = EXPECT ; \
if ( virTestRun ( " Path relative resolve " # id , \
testPathRelative , & data4 ) < 0 ) \
ret = - 1 ; \
2014-05-13 12:10:56 +04:00
} while ( 0 )
testPathRelativePrepare ( ) ;
/* few negative tests first */
/* a non-relative image is in the backing chain span */
TEST_RELATIVE_BACKING ( 1 , backingchain [ 0 ] , backingchain [ 1 ] , NULL ) ;
TEST_RELATIVE_BACKING ( 2 , backingchain [ 0 ] , backingchain [ 2 ] , NULL ) ;
TEST_RELATIVE_BACKING ( 3 , backingchain [ 0 ] , backingchain [ 3 ] , NULL ) ;
TEST_RELATIVE_BACKING ( 4 , backingchain [ 1 ] , backingchain [ 5 ] , NULL ) ;
/* image is not in chain (specified backwards) */
TEST_RELATIVE_BACKING ( 5 , backingchain [ 2 ] , backingchain [ 1 ] , NULL ) ;
/* positive tests */
TEST_RELATIVE_BACKING ( 6 , backingchain [ 1 ] , backingchain [ 1 ] , " asdf " ) ;
TEST_RELATIVE_BACKING ( 7 , backingchain [ 1 ] , backingchain [ 2 ] , " test " ) ;
TEST_RELATIVE_BACKING ( 8 , backingchain [ 1 ] , backingchain [ 3 ] , " blah " ) ;
TEST_RELATIVE_BACKING ( 9 , backingchain [ 2 ] , backingchain [ 2 ] , " test " ) ;
TEST_RELATIVE_BACKING ( 10 , backingchain [ 2 ] , backingchain [ 3 ] , " blah " ) ;
TEST_RELATIVE_BACKING ( 11 , backingchain [ 3 ] , backingchain [ 3 ] , " blah " ) ;
/* oVirt spelling */
TEST_RELATIVE_BACKING ( 12 , backingchain [ 5 ] , backingchain [ 5 ] , " ../volume/image2 " ) ;
TEST_RELATIVE_BACKING ( 13 , backingchain [ 5 ] , backingchain [ 6 ] , " ../volume/../volume/image3 " ) ;
TEST_RELATIVE_BACKING ( 14 , backingchain [ 5 ] , backingchain [ 7 ] , " ../volume/../volume/../volume/image4 " ) ;
TEST_RELATIVE_BACKING ( 15 , backingchain [ 6 ] , backingchain [ 6 ] , " ../volume/image3 " ) ;
TEST_RELATIVE_BACKING ( 16 , backingchain [ 6 ] , backingchain [ 7 ] , " ../volume/../volume/image4 " ) ;
TEST_RELATIVE_BACKING ( 17 , backingchain [ 7 ] , backingchain [ 7 ] , " ../volume/image4 " ) ;
/* crazy spellings */
TEST_RELATIVE_BACKING ( 17 , backingchain [ 9 ] , backingchain [ 9 ] , " directory/stuff/volumes/garbage/image2 " ) ;
TEST_RELATIVE_BACKING ( 18 , backingchain [ 9 ] , backingchain [ 10 ] , " directory/stuff/volumes/garbage/../../../image3 " ) ;
TEST_RELATIVE_BACKING ( 19 , backingchain [ 9 ] , backingchain [ 11 ] , " directory/stuff/volumes/garbage/../../../../blah/image4 " ) ;
TEST_RELATIVE_BACKING ( 20 , backingchain [ 10 ] , backingchain [ 10 ] , " ../../../image3 " ) ;
TEST_RELATIVE_BACKING ( 21 , backingchain [ 10 ] , backingchain [ 11 ] , " ../../../../blah/image4 " ) ;
TEST_RELATIVE_BACKING ( 22 , backingchain [ 11 ] , backingchain [ 11 ] , " ../blah/image4 " ) ;
2016-07-12 18:04:16 +03:00
virTestCounterReset ( " Backing store parse " ) ;
2019-08-15 20:27:43 +03:00
# define TEST_BACKING_PARSE_FULL(bck, xml, rc) \
2017-11-03 15:09:47 +03:00
do { \
data5 . backing = bck ; \
data5 . expect = xml ; \
2019-08-15 20:27:43 +03:00
data5 . rv = rc ; \
2017-11-03 15:09:47 +03:00
if ( virTestRun ( virTestCounterNext ( ) , \
testBackingParse , & data5 ) < 0 ) \
ret = - 1 ; \
2016-07-12 18:04:16 +03:00
} while ( 0 )
2019-08-15 20:27:43 +03:00
# define TEST_BACKING_PARSE(bck, xml) \
TEST_BACKING_PARSE_FULL ( bck , xml , 0 )
2016-07-12 18:04:16 +03:00
TEST_BACKING_PARSE ( " path " , " <source file='path'/> \n " ) ;
2020-03-23 18:04:19 +03:00
TEST_BACKING_PARSE ( " fat:/somedir " , " <source dir='/somedir'/> \n " ) ;
2016-07-12 18:04:16 +03:00
TEST_BACKING_PARSE ( " :// " , NULL ) ;
2018-10-11 13:22:21 +03:00
TEST_BACKING_PARSE ( " http://example.com " ,
" <source protocol='http' name=''> \n "
" <host name='example.com' port='80'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " http://example.com/ " ,
" <source protocol='http' name=''> \n "
" <host name='example.com' port='80'/> \n "
" </source> \n " ) ;
2016-07-12 18:04:16 +03:00
TEST_BACKING_PARSE ( " http://example.com/file " ,
" <source protocol='http' name='file'> \n "
2017-07-20 15:18:04 +03:00
" <host name='example.com' port='80'/> \n "
2016-07-12 18:04:16 +03:00
" </source> \n " ) ;
2019-08-15 20:29:43 +03:00
TEST_BACKING_PARSE_FULL ( " http://user:pass@example.com/file " ,
" <source protocol='http' name='file'> \n "
" <host name='example.com' port='80'/> \n "
" </source> \n " , 1 ) ;
2016-07-12 18:04:16 +03:00
TEST_BACKING_PARSE ( " rbd:testshare:id=asdf:mon_host=example.com " ,
" <source protocol='rbd' name='testshare'> \n "
" <host name='example.com'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " nbd:example.org:6000:exportname=blah " ,
" <source protocol='nbd' name='blah'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
2019-07-31 18:17:30 +03:00
TEST_BACKING_PARSE ( " nbd:example.org:6000:exportname=: " ,
" <source protocol='nbd' name=':'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " nbd:example.org:6000:exportname=:test " ,
" <source protocol='nbd' name=':test'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
2020-04-24 14:59:21 +03:00
TEST_BACKING_PARSE ( " nbd:[::1]:6000:exportname=:test " ,
" <source protocol='nbd' name=':test'> \n "
" <host name='::1' port='6000'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " nbd:127.0.0.1:6000:exportname=:test " ,
" <source protocol='nbd' name=':test'> \n "
" <host name='127.0.0.1' port='6000'/> \n "
" </source> \n " ) ;
2020-01-16 14:34:13 +03:00
TEST_BACKING_PARSE ( " nbd:unix:/tmp/sock:exportname=/ " ,
" <source protocol='nbd' name='/'> \n "
" <host transport='unix' socket='/tmp/sock'/> \n "
" </source> \n " ) ;
2020-04-24 14:59:21 +03:00
TEST_BACKING_PARSE ( " nbd:unix:/tmp/sock: " ,
" <source protocol='nbd'> \n "
" <host transport='unix' socket='/tmp/sock:'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " nbd:unix:/tmp/sock::exportname=: " ,
" <source protocol='nbd' name=':'> \n "
" <host transport='unix' socket='/tmp/sock:'/> \n "
" </source> \n " ) ;
2018-10-11 13:22:21 +03:00
TEST_BACKING_PARSE ( " nbd://example.org:1234 " ,
" <source protocol='nbd'> \n "
" <host name='example.org' port='1234'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " nbd://example.org:1234/ " ,
" <source protocol='nbd'> \n "
" <host name='example.org' port='1234'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " nbd://example.org:1234/exportname " ,
" <source protocol='nbd' name='exportname'> \n "
" <host name='example.org' port='1234'/> \n "
" </source> \n " ) ;
2020-01-16 15:49:37 +03:00
TEST_BACKING_PARSE ( " nbd+unix://?socket=/tmp/sock " ,
" <source protocol='nbd'> \n "
" <host transport='unix' socket='/tmp/sock'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " nbd+unix:///?socket=/tmp/sock " ,
" <source protocol='nbd'> \n "
" <host transport='unix' socket='/tmp/sock'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " nbd+unix:////?socket=/tmp/sock " ,
" <source protocol='nbd' name='/'> \n "
" <host transport='unix' socket='/tmp/sock'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " nbd+unix:///exp?socket=/tmp/sock " ,
" <source protocol='nbd' name='exp'> \n "
" <host transport='unix' socket='/tmp/sock'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " nbd+unix:////exp?socket=/tmp/sock " ,
" <source protocol='nbd' name='/exp'> \n "
" <host transport='unix' socket='/tmp/sock'/> \n "
" </source> \n " ) ;
2019-08-15 20:29:43 +03:00
TEST_BACKING_PARSE_FULL ( " iscsi://testuser:testpass@example.org:1234/exportname " ,
" <source protocol='iscsi' name='exportname'> \n "
" <host name='example.org' port='1234'/> \n "
" </source> \n " , 1 ) ;
2017-06-21 15:55:58 +03:00
2018-08-13 14:40:18 +03:00
# ifdef WITH_YAJL
2016-04-08 10:55:46 +03:00
TEST_BACKING_PARSE ( " json: " , NULL ) ;
TEST_BACKING_PARSE ( " json:asdgsdfg " , NULL ) ;
TEST_BACKING_PARSE ( " json:{} " , NULL ) ;
TEST_BACKING_PARSE ( " json: { \" file.driver \" : \" blah \" } " , NULL ) ;
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" file \" } " , NULL ) ;
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" file \" , "
" \" file.filename \" : \" /path/to/file \" } " ,
" <source file='/path/to/file'/> \n " ) ;
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" file \" , "
" \" filename \" : \" /path/to/file \" } " , NULL ) ;
TEST_BACKING_PARSE ( " json:{ \" file \" : { \" driver \" : \" file \" , "
" \" filename \" : \" /path/to/file \" "
" } "
" } " ,
" <source file='/path/to/file'/> \n " ) ;
2020-02-03 18:40:16 +03:00
TEST_BACKING_PARSE ( " json:{ \" driver \" : \" file \" , "
" \" filename \" : \" /path/to/file \" "
" } " ,
" <source file='/path/to/file'/> \n " ) ;
2016-07-14 14:58:26 +03:00
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" host_device \" , "
" \" file.filename \" : \" /path/to/dev \" } " ,
" <source dev='/path/to/dev'/> \n " ) ;
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" host_cdrom \" , "
" \" file.filename \" : \" /path/to/cdrom \" } " ,
" <source dev='/path/to/cdrom'/> \n " ) ;
2016-07-12 18:59:58 +03:00
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" http \" , "
2016-08-16 10:24:12 +03:00
" \" file.url \" : \" http://example.com/file \" } " ,
2016-07-12 18:59:58 +03:00
" <source protocol='http' name='file'> \n "
2017-07-20 15:18:04 +03:00
" <host name='example.com' port='80'/> \n "
2016-07-12 18:59:58 +03:00
" </source> \n " ) ;
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" http \" , "
2016-08-16 10:24:12 +03:00
" \" url \" : \" http://example.com/file \" "
2016-07-12 18:59:58 +03:00
" } "
" } " ,
" <source protocol='http' name='file'> \n "
2017-07-20 15:18:04 +03:00
" <host name='example.com' port='80'/> \n "
2016-07-12 18:59:58 +03:00
" </source> \n " ) ;
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" ftp \" , "
2016-08-16 10:24:12 +03:00
" \" file.url \" : \" http://example.com/file \" } " ,
2016-07-12 18:59:58 +03:00
NULL ) ;
2016-07-13 16:35:29 +03:00
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" gluster \" , "
" \" file.filename \" : \" gluster://example.com/vol/file \" } " ,
" <source protocol='gluster' name='vol/file'> \n "
2017-07-20 15:18:04 +03:00
" <host name='example.com' port='24007'/> \n "
2016-07-13 16:35:29 +03:00
" </source> \n " ) ;
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" gluster \" , "
" \" volume \" : \" testvol \" , "
" \" path \" : \" img.qcow2 \" , "
" \" server \" :[ { \" type \" : \" tcp \" , "
" \" host \" : \" example.com \" , "
" \" port \" : \" 1234 \" "
" }, "
" { \" type \" : \" unix \" , "
" \" socket \" : \" /path/socket \" "
" }, "
" { \" type \" : \" tcp \" , "
" \" host \" : \" example.com \" "
" } "
" ] "
" } "
" } " ,
2016-09-05 16:31:44 +03:00
" <source protocol='gluster' name='testvol/img.qcow2'> \n "
2016-07-13 16:35:29 +03:00
" <host name='example.com' port='1234'/> \n "
" <host transport='unix' socket='/path/socket'/> \n "
2017-07-20 15:18:04 +03:00
" <host name='example.com' port='24007'/> \n "
2016-07-13 16:35:29 +03:00
" </source> \n " ) ;
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" gluster \" , "
" \" file.volume \" : \" testvol \" , "
" \" file.path \" : \" img.qcow2 \" , "
" \" file.server \" :[ { \" type \" : \" tcp \" , "
" \" host \" : \" example.com \" , "
" \" port \" : \" 1234 \" "
" }, "
" { \" type \" : \" unix \" , "
" \" socket \" : \" /path/socket \" "
" }, "
2017-06-19 15:37:47 +03:00
" { \" type \" : \" inet \" , "
2016-07-13 16:35:29 +03:00
" \" host \" : \" example.com \" "
" } "
" ] "
" } " ,
2016-09-05 16:31:44 +03:00
" <source protocol='gluster' name='testvol/img.qcow2'> \n "
2016-07-13 16:35:29 +03:00
" <host name='example.com' port='1234'/> \n "
" <host transport='unix' socket='/path/socket'/> \n "
2017-07-20 15:18:04 +03:00
" <host name='example.com' port='24007'/> \n "
2016-07-13 16:35:29 +03:00
" </source> \n " ) ;
2017-12-14 20:01:05 +03:00
TEST_BACKING_PARSE ( " json:{ \" driver \" : \" raw \" , "
" \" file \" : { \" server.0.host \" : \" A.A.A.A \" , "
" \" server.1.host \" : \" B.B.B.B \" , "
" \" server.2.host \" : \" C.C.C.C \" , "
" \" driver \" : \" gluster \" , "
" \" path \" : \" raw \" , "
" \" server.0.type \" : \" tcp \" , "
" \" server.1.type \" : \" tcp \" , "
" \" server.2.type \" : \" tcp \" , "
" \" server.0.port \" : \" 24007 \" , "
" \" server.1.port \" : \" 24007 \" , "
" \" server.2.port \" : \" 24007 \" , "
" \" volume \" : \" vol1 \" }} " ,
" <source protocol='gluster' name='vol1/raw'> \n "
" <host name='A.A.A.A' port='24007'/> \n "
" <host name='B.B.B.B' port='24007'/> \n "
" <host name='C.C.C.C' port='24007'/> \n "
" </source> \n " ) ;
2016-07-14 09:10:31 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" nbd \" , "
" \" path \" : \" /path/to/socket \" "
" } "
" } " ,
" <source protocol='nbd'> \n "
" <host transport='unix' socket='/path/to/socket'/> \n "
" </source> \n " ) ;
2020-02-03 18:40:16 +03:00
TEST_BACKING_PARSE ( " json:{ \" driver \" : \" nbd \" , "
" \" path \" : \" /path/to/socket \" "
" } " ,
" <source protocol='nbd'> \n "
" <host transport='unix' socket='/path/to/socket'/> \n "
" </source> \n " ) ;
2016-07-14 09:10:31 +03:00
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" nbd \" , "
" \" file.path \" : \" /path/to/socket \" "
" } " ,
" <source protocol='nbd'> \n "
" <host transport='unix' socket='/path/to/socket'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" nbd \" , "
" \" export \" : \" blah \" , "
" \" host \" : \" example.org \" , "
" \" port \" : \" 6000 \" "
" } "
" } " ,
" <source protocol='nbd' name='blah'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" nbd \" , "
" \" file.export \" : \" blah \" , "
" \" file.host \" : \" example.org \" , "
" \" file.port \" : \" 6000 \" "
" } " ,
" <source protocol='nbd' name='blah'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
2017-06-15 18:44:18 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" nbd \" , "
" \" export \" : \" blah \" , "
" \" server \" : { \" type \" : \" inet \" , "
" \" host \" : \" example.org \" , "
" \" port \" : \" 6000 \" "
" } "
" } "
" } " ,
" <source protocol='nbd' name='blah'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
2018-02-12 18:16:42 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" nbd \" , "
" \" server \" : { \" type \" : \" unix \" , "
" \" path \" : \" /path/socket \" "
" } "
" } "
" } " ,
" <source protocol='nbd'> \n "
" <host transport='unix' socket='/path/socket'/> \n "
" </source> \n " ) ;
2016-07-15 16:12:10 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" ssh \" , "
" \" host \" : \" example.org \" , "
" \" port \" : \" 6000 \" , "
" \" path \" : \" blah \" , "
" \" user \" : \" user \" "
" } "
" } " ,
" <source protocol='ssh' name='blah'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" ssh \" , "
" \" file.host \" : \" example.org \" , "
" \" file.port \" : \" 6000 \" , "
" \" file.path \" : \" blah \" , "
" \" file.user \" : \" user \" "
" } " ,
" <source protocol='ssh' name='blah'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
2017-06-15 18:44:18 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" ssh \" , "
" \" path \" : \" blah \" , "
" \" server \" :{ \" host \" : \" example.org \" , "
" \" port \" : \" 6000 \" "
" }, "
" \" user \" : \" user \" "
" } "
" } " ,
" <source protocol='ssh' name='blah'> \n "
" <host name='example.org' port='6000'/> \n "
" </source> \n " ) ;
2016-09-05 16:15:22 +03:00
TEST_BACKING_PARSE ( " json:{ \" file.driver \" : \" rbd \" , "
" \" file.filename \" : \" rbd:testshare:id=asdf:mon_host=example.com \" "
" } " ,
" <source protocol='rbd' name='testshare'> \n "
" <host name='example.com'/> \n "
" </source> \n " ) ;
2017-06-15 18:44:18 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" rbd \" , "
" \" image \" : \" test \" , "
" \" pool \" : \" libvirt \" , "
" \" conf \" : \" /path/to/conf \" , "
" \" snapshot \" : \" snapshotname \" , "
" \" server \" :[ { \" host \" : \" example.com \" , "
" \" port \" : \" 1234 \" "
" }, "
" { \" host \" : \" example2.com \" "
" } "
" ] "
" } "
" } " ,
" <source protocol='rbd' name='libvirt/test'> \n "
" <host name='example.com' port='1234'/> \n "
" <host name='example2.com'/> \n "
" <snapshot name='snapshotname'/> \n "
" <config file='/path/to/conf'/> \n "
" </source> \n " ) ;
2017-02-14 01:53:43 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" : { "
" \" driver \" : \" raw \" , "
" \" file \" : { "
" \" driver \" : \" file \" , "
" \" filename \" : \" /path/to/file \" } } } " ,
" <source file='/path/to/file'/> \n " ) ;
2017-06-15 18:12:01 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" iscsi \" , "
" \" transport \" : \" tcp \" , "
" \" portal \" : \" test.org \" , "
" \" target \" : \" iqn.2016-12.com.virttest:emulated-iscsi-noauth.target \" "
" } "
" } " ,
" <source protocol='iscsi' name='iqn.2016-12.com.virttest:emulated-iscsi-noauth.target/0'> \n "
2017-07-20 15:18:04 +03:00
" <host name='test.org' port='3260'/> \n "
2017-06-15 18:12:01 +03:00
" </source> \n " ) ;
2019-08-15 20:29:43 +03:00
TEST_BACKING_PARSE_FULL ( " json:{ \" file \" :{ \" driver \" : \" iscsi \" , "
" \" transport \" : \" tcp \" , "
" \" portal \" : \" test.org \" , "
" \" user \" : \" testuser \" , "
" \" target \" : \" iqn.2016-12.com.virttest:emulated-iscsi-auth.target \" "
" } "
" } " ,
" <source protocol='iscsi' name='iqn.2016-12.com.virttest:emulated-iscsi-auth.target/0'> \n "
" <host name='test.org' port='3260'/> \n "
" </source> \n " , 1 ) ;
TEST_BACKING_PARSE_FULL ( " json:{ \" file \" :{ \" driver \" : \" iscsi \" , "
" \" transport \" : \" tcp \" , "
" \" portal \" : \" test.org \" , "
" \" password \" : \" testpass \" , "
" \" target \" : \" iqn.2016-12.com.virttest:emulated-iscsi-auth.target \" "
" } "
" } " ,
" <source protocol='iscsi' name='iqn.2016-12.com.virttest:emulated-iscsi-auth.target/0'> \n "
" <host name='test.org' port='3260'/> \n "
" </source> \n " , 1 ) ;
2017-06-15 18:12:01 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" iscsi \" , "
" \" transport \" : \" tcp \" , "
" \" portal \" : \" test.org:1234 \" , "
" \" target \" : \" iqn.2016-12.com.virttest:emulated-iscsi-noauth.target \" , "
2018-01-31 14:00:42 +03:00
" \" lun \" : \" 6 \" "
2017-06-15 18:12:01 +03:00
" } "
" } " ,
" <source protocol='iscsi' name='iqn.2016-12.com.virttest:emulated-iscsi-noauth.target/6'> \n "
" <host name='test.org' port='1234'/> \n "
" </source> \n " ) ;
2017-11-07 18:20:23 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" iscsi \" , "
" \" transport \" : \" tcp \" , "
" \" portal \" : \" [2001::0]:1234 \" , "
" \" target \" : \" iqn.2016-12.com.virttest:emulated-iscsi-noauth.target \" , "
" \" lun \" :6 "
" } "
" } " ,
" <source protocol='iscsi' name='iqn.2016-12.com.virttest:emulated-iscsi-noauth.target/6'> \n "
" <host name='[2001::0]' port='1234'/> \n "
" </source> \n " ) ;
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" iscsi \" , "
" \" transport \" : \" tcp \" , "
" \" portal \" : \" [2001::0] \" , "
" \" target \" : \" iqn.2016-12.com.virttest:emulated-iscsi-noauth.target \" , "
" \" lun \" :6 "
" } "
" } " ,
" <source protocol='iscsi' name='iqn.2016-12.com.virttest:emulated-iscsi-noauth.target/6'> \n "
" <host name='[2001::0]' port='3260'/> \n "
" </source> \n " ) ;
2017-06-15 18:44:18 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" sheepdog \" , "
" \" vdi \" : \" test \" , "
" \" server \" :{ \" type \" : \" inet \" , "
" \" host \" : \" example.com \" , "
" \" port \" : \" 321 \" "
" } "
" } "
" } " ,
" <source protocol='sheepdog' name='test'> \n "
" <host name='example.com' port='321'/> \n "
" </source> \n " ) ;
2017-06-26 20:42:06 +03:00
TEST_BACKING_PARSE ( " json:{ \" driver \" : \" raw \" , "
" \" file \" : { \" server.host \" : \" 10.10.10.10 \" , "
" \" server.port \" : \" 7000 \" , "
" \" tag \" : \" \" , "
" \" driver \" : \" sheepdog \" , "
" \" server.type \" : \" inet \" , "
" \" vdi \" : \" Alice \" }} " ,
" <source protocol='sheepdog' name='Alice'> \n "
" <host name='10.10.10.10' port='7000'/> \n "
" </source> \n " ) ;
2017-08-30 16:46:50 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" vxhs \" , "
" \" vdisk-id \" : \" c6718f6b-0401-441d-a8c3-1f0064d75ee0 \" , "
2017-10-23 19:02:28 +03:00
" \" server \" : { \" host \" : \" example.com \" , "
2017-08-30 16:46:50 +03:00
" \" port \" : \" 9999 \" "
" } "
" } "
" } " ,
" <source protocol='vxhs' name='c6718f6b-0401-441d-a8c3-1f0064d75ee0'> \n "
" <host name='example.com' port='9999'/> \n "
" </source> \n " ) ;
2021-01-07 00:32:31 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" nfs \" , "
" \" user \" :2, "
" \" group \" :9, "
" \" path \" : \" /foo/bar/baz \" , "
" \" server \" : { \" host \" : \" example.com \" , "
" \" type \" : \" inet \" "
" } "
" } "
" } " ,
" <source protocol='nfs' name='/foo/bar/baz'> \n "
" <host name='example.com'/> \n "
" <identity user='+2' group='+9'/> \n "
" </source> \n " ) ;
2020-01-16 18:02:15 +03:00
TEST_BACKING_PARSE_FULL ( " json:{ \" driver \" : \" raw \" , "
" \" offset \" : 10752, "
" \" size \" : 4063232, "
" \" file \" : { \" driver \" : \" file \" , "
" \" filename \" : \" /tmp/testfle \" "
" } "
" } " ,
2020-02-05 20:09:55 +03:00
" <source file='/tmp/testfle'> \n "
" <slices> \n "
" <slice type='storage' offset='10752' size='4063232'/> \n "
" </slices> \n "
" </source> \n " , 0 ) ;
2020-01-16 18:02:15 +03:00
2020-03-06 10:13:06 +03:00
TEST_BACKING_PARSE_FULL ( " json:{ \" file.cookie \" : \" vmware_soap_session= \\ \" 0c8db85112873a79b7ef74f294cb70ef7f \\ \" \" , "
" \" file.sslverify \" : false, "
" \" file.driver \" : \" https \" , "
2020-03-06 10:29:59 +03:00
" \" file.url \" : \" https://host/folder/esx6.5-rhel7.7-x86%5f64/esx6.5-rhel7.7-x86%5f64-flat.vmdk?dcPath=data&dsName=esx6.5-matrix \" , "
" \" file.timeout \" : 2000 "
" } " ,
2020-03-27 18:26:50 +03:00
" <source protocol='https' name='folder/esx6.5-rhel7.7-x86_64/esx6.5-rhel7.7-x86_64-flat.vmdk' query='dcPath=data&dsName=esx6.5-matrix'> \n "
2020-03-06 10:29:59 +03:00
" <host name='host' port='443'/> \n "
" <ssl verify='no'/> \n "
" <cookies> \n "
" <cookie name='vmware_soap_session'>"0c8db85112873a79b7ef74f294cb70ef7f"</cookie> \n "
" </cookies> \n "
" <timeout seconds='2000'/> \n "
" </source> \n " , 0 ) ;
TEST_BACKING_PARSE_FULL ( " json:{ \" file.cookie \" : \" vmware_soap_session= \\ \" 0c8db85112873a79b7ef74f294cb70ef7f \\ \" \" , "
" \" file.sslverify \" : \" off \" , "
" \" file.driver \" : \" https \" , "
2020-03-06 10:13:06 +03:00
" \" file.url \" : \" https://host/folder/esx6.5-rhel7.7-x86%5f64/esx6.5-rhel7.7-x86%5f64-flat.vmdk?dcPath=data&dsName=esx6.5-matrix \" , "
" \" file.timeout \" : 2000 "
" } " ,
2020-03-27 18:26:50 +03:00
" <source protocol='https' name='folder/esx6.5-rhel7.7-x86_64/esx6.5-rhel7.7-x86_64-flat.vmdk' query='dcPath=data&dsName=esx6.5-matrix'> \n "
2020-03-06 10:13:06 +03:00
" <host name='host' port='443'/> \n "
" <ssl verify='no'/> \n "
" <cookies> \n "
" <cookie name='vmware_soap_session'>"0c8db85112873a79b7ef74f294cb70ef7f"</cookie> \n "
" </cookies> \n "
" <timeout seconds='2000'/> \n "
" </source> \n " , 0 ) ;
2020-03-23 20:06:56 +03:00
TEST_BACKING_PARSE ( " json:{ \" file \" :{ \" driver \" : \" nvme \" , "
" \" device \" : \" 0000:01:00.0 \" , "
" \" namespace \" : 1 "
" } "
" } " ,
" <source type='pci' namespace='1'> \n "
" <address domain='0x0000' bus='0x01' slot='0x00' function='0x0'/> \n "
" </source> \n " ) ;
2018-08-13 14:40:18 +03:00
# endif /* WITH_YAJL */
2016-07-12 18:04:16 +03:00
2013-02-13 22:04:05 +04:00
return ret = = 0 ? EXIT_SUCCESS : EXIT_FAILURE ;
}
2017-03-29 17:45:42 +03:00
VIR_TEST_MAIN ( mymain )