2012-09-14 11:46:57 +04:00
/*
2013-08-16 14:12:55 +04:00
* virbitmaptest . c : Test the bitmap code
*
2013-02-02 04:33:18 +04:00
* Copyright ( C ) 2013 Red Hat , Inc .
2012-09-14 11:46:57 +04:00
* Copyright ( C ) 2012 Fujitsu .
*
* 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-09-14 11:46:57 +04:00
* < http : //www.gnu.org/licenses/>.
*
*/
# include <config.h>
# include "testutils.h"
2012-12-04 15:56:32 +04:00
# include "virbitmap.h"
2012-09-14 11:46:57 +04:00
2020-10-05 13:06:14 +03:00
static int
checkBitmap ( virBitmapPtr map ,
const char * expect ,
ssize_t expectedSize )
{
g_autofree char * actual = virBitmapFormat ( map ) ;
if ( expectedSize ! = - 1 & &
virBitmapSize ( map ) ! = expectedSize ) {
fprintf ( stderr , " \n expected bitmap size: '%zd' actual size: "
" '%zu' \n " , expectedSize , virBitmapSize ( map ) ) ;
return - 1 ;
}
if ( STRNEQ_NULLABLE ( expect , actual ) ) {
fprintf ( stderr , " \n expected bitmap contents '%s' actual contents " \
" '%s' \n " , NULLSTR ( expect ) , NULLSTR ( actual ) ) ;
return - 1 ;
}
return 0 ;
}
2013-08-16 14:12:55 +04:00
static int
2019-10-14 15:45:03 +03:00
test1 ( const void * data G_GNUC_UNUSED )
2012-09-14 11:46:57 +04:00
{
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) bitmap = NULL ;
2012-09-14 11:46:57 +04:00
int size ;
int bit ;
bool result ;
size = 1024 ;
bit = 100 ;
2020-10-01 18:42:11 +03:00
bitmap = virBitmapNew ( size ) ;
2013-01-23 02:09:28 +04:00
2012-09-14 11:46:57 +04:00
if ( virBitmapSetBit ( bitmap , bit ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( virBitmapGetBit ( bitmap , bit , & result ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( ! result )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( virBitmapGetBit ( bitmap , bit + 1 , & result ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( result )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-01-23 02:09:28 +04:00
2020-10-01 17:36:05 +03:00
return 0 ;
2012-09-14 11:46:57 +04:00
}
static int
testBit ( virBitmapPtr bitmap ,
unsigned int start ,
unsigned int end ,
bool expected )
{
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 ;
2012-09-14 11:46:57 +04:00
bool result ;
for ( i = start ; i < = end ; i + + ) {
if ( virBitmapGetBit ( bitmap , i , & result ) < 0 )
return - 1 ;
2015-03-06 19:55:38 +03:00
if ( result ! = expected )
return - 1 ;
2012-09-14 11:46:57 +04:00
}
2015-03-06 19:55:38 +03:00
return 0 ;
2012-09-14 11:46:57 +04:00
}
2013-08-16 14:12:55 +04:00
static int
2019-10-14 15:45:03 +03:00
test2 ( const void * data G_GNUC_UNUSED )
2012-09-14 11:46:57 +04:00
{
const char * bitsString1 = " 1-32,50,88-99,1021-1023 " ;
2020-10-01 17:26:51 +03:00
g_autofree char * bitsString2 = NULL ;
g_autoptr ( virBitmap ) bitmap = NULL ;
2012-09-14 11:46:57 +04:00
int size = 1025 ;
2016-06-17 15:56:45 +03:00
if ( virBitmapParse ( bitsString1 , & bitmap , size ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( testBit ( bitmap , 1 , 32 , true ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( testBit ( bitmap , 50 , 50 , true ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( testBit ( bitmap , 88 , 99 , true ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( testBit ( bitmap , 1021 , 1023 , true ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( testBit ( bitmap , 0 , 0 , false ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( testBit ( bitmap , 33 , 49 , false ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( testBit ( bitmap , 51 , 87 , false ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( testBit ( bitmap , 100 , 1020 , false ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
2012-10-25 04:44:27 +04:00
if ( virBitmapCountBits ( bitmap ) ! = 48 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-10-25 04:44:27 +04:00
2013-01-23 02:09:28 +04:00
if ( ! ( bitsString2 = virBitmapFormat ( bitmap ) ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( strcmp ( bitsString1 , bitsString2 ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
virBitmapSetAll ( bitmap ) ;
if ( testBit ( bitmap , 0 , size - 1 , true ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-10-25 04:44:27 +04:00
if ( virBitmapCountBits ( bitmap ) ! = size )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( ! virBitmapIsAllSet ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
virBitmapClearAll ( bitmap ) ;
2013-04-05 22:06:16 +04:00
if ( ! virBitmapIsAllClear ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( testBit ( bitmap , 0 , size - 1 , false ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-10-25 04:44:27 +04:00
if ( virBitmapCountBits ( bitmap ) ! = 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
2020-10-01 17:36:05 +03:00
return 0 ;
2012-09-14 11:46:57 +04:00
}
2013-08-16 14:12:55 +04:00
static int
2019-10-14 15:45:03 +03:00
test3 ( const void * data G_GNUC_UNUSED )
2012-09-14 11:46:57 +04:00
{
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) bitmap = NULL ;
2012-09-14 11:46:57 +04:00
int size = 5 ;
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 ;
2012-09-14 11:46:57 +04:00
2020-10-01 18:42:11 +03:00
bitmap = virBitmapNew ( size ) ;
2012-09-14 11:46:57 +04:00
for ( i = 0 ; i < size ; i + + )
ignore_value ( virBitmapSetBit ( bitmap , i ) ) ;
if ( ! virBitmapIsAllSet ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
2013-04-05 22:06:16 +04:00
virBitmapClearAll ( bitmap ) ;
if ( ! virBitmapIsAllClear ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
2020-10-01 17:36:05 +03:00
return 0 ;
2012-09-14 11:46:57 +04:00
}
2014-11-04 05:44:39 +03:00
/* test for virBitmapNextSetBit, virBitmapLastSetBit, virBitmapNextClearBit */
2013-08-16 14:12:55 +04:00
static int
2020-10-05 12:17:38 +03:00
test4a ( const void * data G_GNUC_UNUSED )
2012-09-14 11:46:57 +04:00
{
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) bitmap = NULL ;
2013-02-02 04:33:18 +04:00
2016-07-06 15:02:28 +03:00
/* 0. empty set */
2020-10-01 18:02:16 +03:00
bitmap = virBitmapNew ( 0 ) ;
2016-07-06 15:02:28 +03:00
if ( virBitmapNextSetBit ( bitmap , - 1 ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-07-06 15:02:28 +03:00
if ( virBitmapLastSetBit ( bitmap ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-07-06 15:02:28 +03:00
if ( virBitmapNextClearBit ( bitmap , - 1 ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-07-06 15:02:28 +03:00
2020-10-05 12:17:38 +03:00
return 0 ;
}
static int
test4b ( const void * data G_GNUC_UNUSED )
{
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) bitmap = NULL ;
2020-10-05 12:17:38 +03:00
int size = 40 ;
size_t i ;
2016-07-06 15:02:28 +03:00
2012-09-14 11:46:57 +04:00
/* 1. zero set */
bitmap = virBitmapNew ( size ) ;
2013-02-02 04:33:18 +04:00
if ( virBitmapNextSetBit ( bitmap , - 1 ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-02-02 04:33:18 +04:00
2014-11-04 05:44:39 +03:00
if ( virBitmapLastSetBit ( bitmap ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2014-11-04 05:44:39 +03:00
2013-02-02 04:33:18 +04:00
for ( i = 0 ; i < size ; i + + ) {
if ( virBitmapNextClearBit ( bitmap , i - 1 ) ! = i )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-02-02 04:33:18 +04:00
}
if ( virBitmapNextClearBit ( bitmap , i ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
2013-04-05 22:06:16 +04:00
if ( ! virBitmapIsAllClear ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-04-05 22:06:16 +04:00
2020-10-05 12:17:38 +03:00
return 0 ;
}
static int
test4c ( const void * data G_GNUC_UNUSED )
{
const char * bitsString = " 0, 2-4, 6-10, 12, 14-18, 20, 22, 25 " ;
int size = 40 ;
int bitsPos [ ] = {
0 , 2 , 3 , 4 , 6 , 7 , 8 , 9 , 10 , 12 ,
14 , 15 , 16 , 17 , 18 , 20 , 22 , 25
} ;
int bitsPosInv [ ] = {
1 , 5 , 11 , 13 , 19 , 21 , 23 , 24 , 26 , 27 ,
28 , 29 , 30 , 31 , 32 , 33 , 34 , 35 , 36 , 37 , 38 , 39
} ;
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) bitmap = NULL ;
2020-10-05 12:17:38 +03:00
ssize_t i , j ;
if ( G_N_ELEMENTS ( bitsPos ) + G_N_ELEMENTS ( bitsPosInv ) ! = size )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
/* 2. partial set */
2016-06-17 15:56:45 +03:00
if ( virBitmapParse ( bitsString , & bitmap , size ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
if ( ! bitmap )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
j = 0 ;
i = - 1 ;
2019-10-15 14:55:26 +03:00
while ( j < G_N_ELEMENTS ( bitsPos ) ) {
2012-09-14 11:46:57 +04:00
i = virBitmapNextSetBit ( bitmap , i ) ;
if ( i ! = bitsPos [ j + + ] )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
}
2013-02-02 04:33:18 +04:00
if ( virBitmapNextSetBit ( bitmap , i ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-02-02 04:33:18 +04:00
2014-11-04 05:44:39 +03:00
j = sizeof ( bitsPos ) / sizeof ( int ) - 1 ;
if ( virBitmapLastSetBit ( bitmap ) ! = bitsPos [ j ] )
2020-10-01 17:36:05 +03:00
return - 1 ;
2014-11-04 05:44:39 +03:00
2013-02-02 04:33:18 +04:00
j = 0 ;
i = - 1 ;
2019-10-15 14:55:26 +03:00
while ( j < G_N_ELEMENTS ( bitsPosInv ) ) {
2013-02-02 04:33:18 +04:00
i = virBitmapNextClearBit ( bitmap , i ) ;
if ( i ! = bitsPosInv [ j + + ] )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-02-02 04:33:18 +04:00
}
if ( virBitmapNextClearBit ( bitmap , i ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
/* 3. full set */
virBitmapSetAll ( bitmap ) ;
2013-02-02 04:33:18 +04:00
for ( i = 0 ; i < size ; i + + ) {
if ( virBitmapNextSetBit ( bitmap , i - 1 ) ! = i )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
}
2013-02-02 04:33:18 +04:00
if ( virBitmapNextSetBit ( bitmap , i ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
2014-11-04 05:44:39 +03:00
if ( virBitmapLastSetBit ( bitmap ) ! = size - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2014-11-04 05:44:39 +03:00
2013-02-02 04:33:18 +04:00
if ( virBitmapNextClearBit ( bitmap , - 1 ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
return 0 ;
}
2017-08-23 10:05:41 +03:00
/* test for virBitmapNewData/ToData/DataFormat */
2013-08-16 14:12:55 +04:00
static int
2019-10-14 15:45:03 +03:00
test5 ( const void * v G_GNUC_UNUSED )
2012-09-14 11:46:57 +04:00
{
2012-09-19 03:20:03 +04:00
char data [ ] = { 0x01 , 0x02 , 0x00 , 0x00 , 0x04 } ;
2020-10-01 17:26:51 +03:00
g_autofree unsigned char * data2 = NULL ;
2012-09-14 11:46:57 +04:00
int len2 ;
2012-09-19 03:20:03 +04:00
int bits [ ] = { 0 , 9 , 34 } ;
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) bitmap = NULL ;
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 ;
ssize_t j ;
2020-10-05 12:28:14 +03:00
g_autofree char * actual1 = NULL ;
g_autofree char * actual2 = NULL ;
2012-09-14 11:46:57 +04:00
2012-09-19 03:20:03 +04:00
bitmap = virBitmapNewData ( data , sizeof ( data ) ) ;
2012-09-14 11:46:57 +04:00
if ( ! bitmap )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
i = 0 ;
j = - 1 ;
while ( i < sizeof ( bits ) / sizeof ( int ) & &
( j = virBitmapNextSetBit ( bitmap , j ) ) > = 0 ) {
if ( j ! = bits [ i + + ] )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
}
if ( virBitmapNextSetBit ( bitmap , j ) > 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
ignore_value ( virBitmapSetBit ( bitmap , 2 ) ) ;
ignore_value ( virBitmapSetBit ( bitmap , 15 ) ) ;
if ( virBitmapToData ( bitmap , & data2 , & len2 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
2012-09-19 03:20:03 +04:00
if ( len2 ! = sizeof ( data ) | |
data2 [ 0 ] ! = 0x05 | |
2012-09-14 11:46:57 +04:00
data2 [ 1 ] ! = 0x82 | |
data2 [ 2 ] ! = 0x00 | |
2012-09-19 03:20:03 +04:00
data2 [ 3 ] ! = 0x00 | |
data2 [ 4 ] ! = 0x04 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
2020-10-05 12:28:14 +03:00
if ( ! ( actual1 = virBitmapDataFormat ( data , sizeof ( data ) ) ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2020-10-05 12:28:14 +03:00
if ( STRNEQ ( actual1 , " 0,9,34 " ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2020-10-05 12:28:14 +03:00
if ( ! ( actual2 = virBitmapDataFormat ( data2 , len2 ) ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2020-10-05 12:28:14 +03:00
if ( STRNEQ ( actual2 , " 0,2,9,15,34 " ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2014-06-05 13:23:28 +04:00
2020-10-01 17:36:05 +03:00
return 0 ;
2012-09-14 11:46:57 +04:00
}
/* test for virBitmapFormat */
2013-08-16 14:12:55 +04:00
static int
2019-10-14 15:45:03 +03:00
test6 ( const void * v G_GNUC_UNUSED )
2012-09-14 11:46:57 +04:00
{
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) bitmap = NULL ;
2012-09-14 11:46:57 +04:00
int size = 64 ;
bitmap = virBitmapNew ( size ) ;
2020-10-05 13:10:42 +03:00
if ( checkBitmap ( bitmap , " " , - 1 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
ignore_value ( virBitmapSetBit ( bitmap , 0 ) ) ;
2020-10-05 13:10:42 +03:00
if ( checkBitmap ( bitmap , " 0 " , - 1 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
ignore_value ( virBitmapSetBit ( bitmap , 4 ) ) ;
ignore_value ( virBitmapSetBit ( bitmap , 5 ) ) ;
2020-10-05 13:10:42 +03:00
if ( checkBitmap ( bitmap , " 0,4-5 " , - 1 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
ignore_value ( virBitmapSetBit ( bitmap , 6 ) ) ;
2020-10-05 13:10:42 +03:00
if ( checkBitmap ( bitmap , " 0,4-6 " , - 1 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
ignore_value ( virBitmapSetBit ( bitmap , 13 ) ) ;
ignore_value ( virBitmapSetBit ( bitmap , 14 ) ) ;
ignore_value ( virBitmapSetBit ( bitmap , 15 ) ) ;
ignore_value ( virBitmapSetBit ( bitmap , 16 ) ) ;
2020-10-05 13:10:42 +03:00
if ( checkBitmap ( bitmap , " 0,4-6,13-16 " , - 1 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
ignore_value ( virBitmapSetBit ( bitmap , 62 ) ) ;
ignore_value ( virBitmapSetBit ( bitmap , 63 ) ) ;
2020-10-05 13:10:42 +03:00
if ( checkBitmap ( bitmap , " 0,4-6,13-16,62-63 " , - 1 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-09-14 11:46:57 +04:00
2020-10-01 17:36:05 +03:00
return 0 ;
2012-09-14 11:46:57 +04:00
}
2013-08-16 14:12:55 +04:00
static int
2019-10-14 15:45:03 +03:00
test7 ( const void * v G_GNUC_UNUSED )
2012-11-28 10:15:38 +04:00
{
size_t i ;
size_t maxBit [ ] = {
1 , 8 , 31 , 32 , 63 , 64 , 95 , 96 , 127 , 128 , 159 , 160
} ;
size_t nmaxBit = 12 ;
for ( i = 0 ; i < nmaxBit ; i + + ) {
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) bitmap = virBitmapNew ( maxBit [ i ] ) ;
2012-11-28 10:15:38 +04:00
if ( virBitmapIsAllSet ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-11-28 10:15:38 +04:00
ignore_value ( virBitmapSetBit ( bitmap , 1 ) ) ;
if ( virBitmapIsAllSet ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-11-28 10:15:38 +04:00
virBitmapSetAll ( bitmap ) ;
if ( ! virBitmapIsAllSet ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-11-28 10:15:38 +04:00
2013-04-05 22:06:16 +04:00
virBitmapClearAll ( bitmap ) ;
if ( ! virBitmapIsAllClear ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2012-11-28 10:15:38 +04:00
}
return 0 ;
}
2013-08-16 14:12:55 +04:00
static int
2019-10-14 15:45:03 +03:00
test8 ( const void * v G_GNUC_UNUSED )
2013-04-05 22:06:16 +04:00
{
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) bitmap = NULL ;
2013-04-05 22:06:16 +04:00
char data [ 108 ] = { 0x00 , } ;
bitmap = virBitmapNewData ( data , sizeof ( data ) ) ;
if ( ! bitmap )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-04-05 22:06:16 +04:00
if ( ! virBitmapIsAllClear ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-04-05 22:06:16 +04:00
if ( virBitmapSetBit ( bitmap , 11 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-04-05 22:06:16 +04:00
if ( virBitmapIsAllClear ( bitmap ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-04-05 22:06:16 +04:00
2020-10-01 17:36:05 +03:00
return 0 ;
2013-04-05 22:06:16 +04:00
}
2013-08-16 14:13:27 +04:00
/* test out of bounds conditions on virBitmapParse */
static int
2019-10-14 15:45:03 +03:00
test9 ( const void * opaque G_GNUC_UNUSED )
2013-08-16 14:13:27 +04:00
{
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) bitmap = NULL ;
2013-08-16 14:13:27 +04:00
2016-06-17 15:56:45 +03:00
if ( virBitmapParse ( " 100000000 " , & bitmap , 20 ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-08-16 14:13:27 +04:00
if ( bitmap )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-08-16 14:13:27 +04:00
2016-06-17 15:56:45 +03:00
if ( virBitmapParse ( " 1-1000000000 " , & bitmap , 20 ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-08-16 14:13:27 +04:00
if ( bitmap )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-08-16 14:13:27 +04:00
2016-06-17 15:56:45 +03:00
if ( virBitmapParse ( " 1-10^10000000000 " , & bitmap , 20 ) ! = - 1 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-08-16 14:13:27 +04:00
if ( bitmap )
2020-10-01 17:36:05 +03:00
return - 1 ;
2013-08-16 14:13:27 +04:00
2020-10-01 17:36:05 +03:00
return 0 ;
2013-08-16 14:13:27 +04:00
}
2014-07-23 19:37:19 +04:00
static int
2019-10-14 15:45:03 +03:00
test10 ( const void * opaque G_GNUC_UNUSED )
2014-07-23 19:37:19 +04:00
{
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) b1 = NULL ;
g_autoptr ( virBitmap ) b2 = NULL ;
g_autoptr ( virBitmap ) b3 = NULL ;
g_autoptr ( virBitmap ) b4 = NULL ;
2014-07-23 19:37:19 +04:00
2016-06-17 15:38:11 +03:00
if ( virBitmapParseSeparator ( " 0-3,5-8,11-15f16 " , ' f ' , & b1 , 20 ) < 0 | |
2016-06-17 15:56:45 +03:00
virBitmapParse ( " 4,9,10,16-19 " , & b2 , 20 ) < 0 | |
virBitmapParse ( " 15 " , & b3 , 20 ) < 0 | |
virBitmapParse ( " 0,^0 " , & b4 , 20 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2015-04-10 12:11:21 +03:00
if ( ! virBitmapIsAllClear ( b4 ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2014-07-23 19:37:19 +04:00
if ( virBitmapOverlaps ( b1 , b2 ) | |
2015-04-10 12:11:21 +03:00
virBitmapOverlaps ( b1 , b4 ) | |
2014-07-23 19:37:19 +04:00
virBitmapOverlaps ( b2 , b3 ) | |
2015-04-10 12:11:21 +03:00
virBitmapOverlaps ( b2 , b4 ) | |
! virBitmapOverlaps ( b1 , b3 ) | |
virBitmapOverlaps ( b3 , b4 ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2014-07-23 19:37:19 +04:00
2020-10-01 17:36:05 +03:00
return 0 ;
2014-07-23 19:37:19 +04:00
}
2016-01-07 17:45:39 +03:00
struct testBinaryOpData {
const char * a ;
const char * b ;
const char * res ;
} ;
static int
test11 ( const void * opaque )
{
const struct testBinaryOpData * data = opaque ;
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) amap = NULL ;
g_autoptr ( virBitmap ) bmap = NULL ;
g_autoptr ( virBitmap ) resmap = NULL ;
2016-01-07 17:45:39 +03:00
2016-06-17 15:56:45 +03:00
if ( virBitmapParse ( data - > a , & amap , 256 ) < 0 | |
virBitmapParse ( data - > b , & bmap , 256 ) < 0 | |
virBitmapParse ( data - > res , & resmap , 256 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-01-07 17:45:39 +03:00
2017-07-12 14:30:47 +03:00
virBitmapIntersect ( amap , bmap ) ;
2016-01-07 17:45:39 +03:00
if ( ! virBitmapEqual ( amap , resmap ) ) {
2017-07-12 14:30:47 +03:00
fprintf ( stderr ,
" \n bitmap intersection failed: intersect('%s','%s') !='%s' \n " ,
2016-01-07 17:45:39 +03:00
data - > a , data - > b , data - > res ) ;
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-01-07 17:45:39 +03:00
}
2020-10-01 17:36:05 +03:00
return 0 ;
2016-01-07 17:45:39 +03:00
}
2016-03-18 17:41:59 +03:00
/* test self-expanding bitmap APIs */
static int
2020-10-05 12:17:38 +03:00
test12a ( const void * opaque G_GNUC_UNUSED )
2016-03-18 17:41:59 +03:00
{
2020-10-01 18:02:16 +03:00
g_autoptr ( virBitmap ) map = virBitmapNew ( 0 ) ;
2016-03-18 17:41:59 +03:00
2020-10-05 13:06:14 +03:00
if ( checkBitmap ( map , " " , 0 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-03-18 17:41:59 +03:00
2017-01-30 15:52:02 +03:00
if ( virBitmapSetBitExpand ( map , 128 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-03-18 17:41:59 +03:00
2020-10-05 13:06:14 +03:00
if ( checkBitmap ( map , " 128 " , 129 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-03-18 17:41:59 +03:00
if ( virBitmapClearBitExpand ( map , 150 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-03-18 17:41:59 +03:00
2020-10-05 13:06:14 +03:00
if ( checkBitmap ( map , " 128 " , 151 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2020-10-05 12:17:38 +03:00
2020-10-01 17:36:05 +03:00
return 0 ;
2020-10-05 12:17:38 +03:00
}
static int
test12b ( const void * opaque G_GNUC_UNUSED )
{
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) map = NULL ;
2020-10-05 12:17:38 +03:00
2017-03-22 16:39:53 +03:00
if ( ! ( map = virBitmapParseUnlimited ( " 34,1023 " ) ) )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-06-17 16:12:02 +03:00
2020-10-05 13:06:14 +03:00
if ( checkBitmap ( map , " 34,1023 " , 1024 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-06-17 16:12:02 +03:00
2018-02-05 15:50:44 +03:00
virBitmapShrink ( map , 35 ) ;
2020-10-05 13:06:14 +03:00
if ( checkBitmap ( map , " 34 " , 35 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2018-02-01 16:33:02 +03:00
2018-02-05 15:50:44 +03:00
virBitmapShrink ( map , 34 ) ;
2020-10-05 13:06:14 +03:00
if ( checkBitmap ( map , " " , 34 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2016-03-18 17:41:59 +03:00
2020-10-01 17:36:05 +03:00
return 0 ;
2016-03-18 17:41:59 +03:00
}
2016-06-17 16:12:02 +03:00
2017-08-23 10:12:10 +03:00
/* virBitmap(New/To)String */
static int
2019-10-14 15:45:03 +03:00
test13 ( const void * opaque G_GNUC_UNUSED )
2017-08-23 10:12:10 +03:00
{
2020-10-01 15:14:21 +03:00
const char * strings [ ] = { " 1234feebee " , " 000c0fefe " , " 0 " , " " } ;
2017-08-23 10:12:10 +03:00
size_t i = 0 ;
2019-10-15 14:55:26 +03:00
for ( i = 0 ; i < G_N_ELEMENTS ( strings ) ; i + + ) {
2020-10-01 17:16:21 +03:00
g_autoptr ( virBitmap ) map = NULL ;
g_autofree char * str = NULL ;
2017-08-23 10:12:10 +03:00
2020-10-01 17:16:21 +03:00
if ( ! ( map = virBitmapNewString ( strings [ i ] ) ) )
return - 1 ;
if ( ! ( str = virBitmapToString ( map ) ) )
return - 1 ;
2017-08-23 10:12:10 +03:00
if ( STRNEQ ( strings [ i ] , str ) ) {
fprintf ( stderr , " \n expected bitmap string '%s' actual string "
" '%s' \n " , strings [ i ] , str ) ;
2020-10-01 17:16:21 +03:00
return - 1 ;
2017-08-23 10:12:10 +03:00
}
}
2020-10-01 17:16:21 +03:00
return 0 ;
2017-08-23 10:12:10 +03:00
}
2016-03-18 17:41:59 +03:00
2017-10-05 16:09:30 +03:00
static int
test14 ( const void * opaque )
{
const struct testBinaryOpData * data = opaque ;
2020-10-01 17:26:51 +03:00
g_autoptr ( virBitmap ) amap = NULL ;
g_autoptr ( virBitmap ) bmap = NULL ;
g_autoptr ( virBitmap ) resmap = NULL ;
2017-10-05 16:09:30 +03:00
if ( virBitmapParse ( data - > a , & amap , 256 ) < 0 | |
virBitmapParse ( data - > b , & bmap , 256 ) < 0 | |
virBitmapParse ( data - > res , & resmap , 256 ) < 0 )
2020-10-01 17:36:05 +03:00
return - 1 ;
2017-10-05 16:09:30 +03:00
virBitmapSubtract ( amap , bmap ) ;
if ( ! virBitmapEqual ( amap , resmap ) ) {
fprintf ( stderr ,
" \n bitmap subtraction failed: '%s' - '%s' != '%s' \n " ,
data - > a , data - > b , data - > res ) ;
2020-10-01 17:36:05 +03:00
return - 1 ;
2017-10-05 16:09:30 +03:00
}
2020-10-01 17:36:05 +03:00
return 0 ;
2017-10-05 16:09:30 +03:00
}
2019-05-30 20:08:28 +03:00
/* virBitmapUnion() */
static int
test15 ( const void * opaque )
{
const struct testBinaryOpData * data = opaque ;
2019-10-15 15:47:50 +03:00
g_autoptr ( virBitmap ) amap = NULL ;
g_autoptr ( virBitmap ) bmap = NULL ;
g_autoptr ( virBitmap ) resmap = NULL ;
2019-05-30 20:08:28 +03:00
if ( ! ( amap = virBitmapParseUnlimited ( data - > a ) ) | |
! ( bmap = virBitmapParseUnlimited ( data - > b ) ) | |
! ( resmap = virBitmapParseUnlimited ( data - > res ) ) ) {
return - 1 ;
}
if ( virBitmapUnion ( amap , bmap ) < 0 )
return - 1 ;
if ( ! virBitmapEqual ( amap , resmap ) ) {
fprintf ( stderr ,
" \n bitmap union failed: union('%s', '%s') != '%s' \n " ,
data - > a , data - > b , data - > res ) ;
return - 1 ;
}
return 0 ;
}
2016-03-18 17:41:59 +03:00
2020-10-01 18:02:16 +03:00
/* virBitmapNew(0) + virBitmapToString */
2020-10-01 15:14:21 +03:00
static int
test16 ( const void * opaque G_GNUC_UNUSED )
{
2020-10-01 18:02:16 +03:00
g_autoptr ( virBitmap ) map = virBitmapNew ( 0 ) ;
2020-10-01 15:14:21 +03:00
g_autofree char * res_empty = NULL ;
g_autofree char * res_set = NULL ;
if ( ! ( res_empty = virBitmapToString ( map ) ) | |
STRNEQ_NULLABLE ( res_empty , " " ) ) {
fprintf ( stderr , " \n expected bitmap string '%s' actual string '%s' \n " ,
" " , NULLSTR ( res_empty ) ) ;
return - 1 ;
}
ignore_value ( virBitmapSetBitExpand ( map , 2 ) ) ;
ignore_value ( virBitmapSetBitExpand ( map , 11 ) ) ;
if ( ! ( res_set = virBitmapToString ( map ) ) | |
STRNEQ_NULLABLE ( res_set , " 804 " ) ) {
fprintf ( stderr , " \n expected bitmap string '%s' actual string '%s' \n " ,
" 804 " , NULLSTR ( res_set ) ) ;
return - 1 ;
}
return 0 ;
}
2017-11-03 15:09:47 +03:00
# define TESTBINARYOP(A, B, RES, FUNC) \
testBinaryOpData . a = A ; \
testBinaryOpData . b = B ; \
testBinaryOpData . res = RES ; \
if ( virTestRun ( virTestCounterNext ( ) , FUNC , & testBinaryOpData ) < 0 ) \
2016-01-07 17:45:39 +03:00
ret = - 1 ;
2012-09-14 11:46:57 +04:00
static int
mymain ( void )
{
2016-01-07 17:45:39 +03:00
struct testBinaryOpData testBinaryOpData ;
2012-09-14 11:46:57 +04:00
int ret = 0 ;
2016-05-26 18:01:50 +03:00
if ( virTestRun ( " test1 " , test1 , NULL ) < 0 )
2012-09-14 11:46:57 +04:00
ret = - 1 ;
2016-05-26 18:01:50 +03:00
if ( virTestRun ( " test2 " , test2 , NULL ) < 0 )
2012-09-14 11:46:57 +04:00
ret = - 1 ;
2016-05-26 18:01:50 +03:00
if ( virTestRun ( " test3 " , test3 , NULL ) < 0 )
2012-09-14 11:46:57 +04:00
ret = - 1 ;
2020-10-05 12:17:38 +03:00
if ( virTestRun ( " test4a " , test4a , NULL ) < 0 )
ret = - 1 ;
if ( virTestRun ( " test4b " , test4b , NULL ) < 0 )
ret = - 1 ;
if ( virTestRun ( " test4c " , test4c , NULL ) < 0 )
2012-09-14 11:46:57 +04:00
ret = - 1 ;
2016-05-26 18:01:50 +03:00
if ( virTestRun ( " test5 " , test5 , NULL ) < 0 )
2012-09-14 11:46:57 +04:00
ret = - 1 ;
2016-05-26 18:01:50 +03:00
if ( virTestRun ( " test6 " , test6 , NULL ) < 0 )
2012-09-14 11:46:57 +04:00
ret = - 1 ;
2016-05-26 18:01:50 +03:00
if ( virTestRun ( " test7 " , test7 , NULL ) < 0 )
2012-11-28 10:15:38 +04:00
ret = - 1 ;
2016-05-26 18:01:50 +03:00
if ( virTestRun ( " test8 " , test8 , NULL ) < 0 )
2013-04-05 22:06:16 +04:00
ret = - 1 ;
2016-05-26 18:01:50 +03:00
if ( virTestRun ( " test9 " , test9 , NULL ) < 0 )
2013-08-16 14:13:27 +04:00
ret = - 1 ;
2016-05-26 18:01:50 +03:00
if ( virTestRun ( " test10 " , test10 , NULL ) < 0 )
2014-07-23 19:37:19 +04:00
ret = - 1 ;
2012-09-14 11:46:57 +04:00
2016-05-26 18:01:57 +03:00
virTestCounterReset ( " test11- " ) ;
2017-07-12 14:30:47 +03:00
TESTBINARYOP ( " 0 " , " 0 " , " 0 " , test11 ) ;
TESTBINARYOP ( " 0-3 " , " 0 " , " 0 " , test11 ) ;
TESTBINARYOP ( " 0-3 " , " 0,3 " , " 0,3 " , test11 ) ;
2016-01-07 17:45:39 +03:00
TESTBINARYOP ( " 0,^0 " , " 0 " , " 0,^0 " , test11 ) ;
2017-07-12 14:30:47 +03:00
TESTBINARYOP ( " 0-3 " , " 0-3 " , " 0-3 " , test11 ) ;
TESTBINARYOP ( " 0-3 " , " 0,^0 " , " 0,^0 " , test11 ) ;
TESTBINARYOP ( " 0,2 " , " 1,3 " , " 0,^0 " , test11 ) ;
2016-01-07 17:45:39 +03:00
2020-10-05 12:17:38 +03:00
if ( virTestRun ( " test12a " , test12a , NULL ) < 0 )
ret = - 1 ;
if ( virTestRun ( " test12b " , test12b , NULL ) < 0 )
2016-03-18 17:41:59 +03:00
ret = - 1 ;
2017-08-23 10:12:10 +03:00
if ( virTestRun ( " test13 " , test13 , NULL ) < 0 )
ret = - 1 ;
2016-03-18 17:41:59 +03:00
2017-10-05 16:09:30 +03:00
virTestCounterReset ( " test14- " ) ;
TESTBINARYOP ( " 0 " , " 0 " , " 0,^0 " , test14 ) ;
TESTBINARYOP ( " 0-3 " , " 0 " , " 1-3 " , test14 ) ;
TESTBINARYOP ( " 0-3 " , " 0,3 " , " 1-2 " , test14 ) ;
TESTBINARYOP ( " 0,^0 " , " 0 " , " 0,^0 " , test14 ) ;
TESTBINARYOP ( " 0-3 " , " 0-3 " , " 0,^0 " , test14 ) ;
TESTBINARYOP ( " 0-3 " , " 0,^0 " , " 0-3 " , test14 ) ;
TESTBINARYOP ( " 0,2 " , " 1,3 " , " 0,2 " , test14 ) ;
2019-05-30 20:08:28 +03:00
/* virBitmapUnion() */
virTestCounterReset ( " test15- " ) ;
TESTBINARYOP ( " 0-1 " , " 0-1 " , " 0-1 " , test15 ) ;
TESTBINARYOP ( " 0 " , " 1 " , " 0-1 " , test15 ) ;
TESTBINARYOP ( " 0-1 " , " 2-3 " , " 0-3 " , test15 ) ;
TESTBINARYOP ( " 0-3 " , " 1-2 " , " 0-3 " , test15 ) ;
TESTBINARYOP ( " 0,^0 " , " 12345 " , " 12345 " , test15 ) ;
TESTBINARYOP ( " 12345 " , " 0,^0 " , " 12345 " , test15 ) ;
TESTBINARYOP ( " 0,^0 " , " 0,^0 " , " 0,^0 " , test15 ) ;
2020-10-01 15:14:21 +03:00
if ( virTestRun ( " test16 " , test16 , NULL ) < 0 )
ret = - 1 ;
2012-09-14 11:46:57 +04:00
return ret ;
}
2017-03-29 17:45:42 +03:00
VIR_TEST_MAIN ( mymain )