void
test_value(void) {
printf("Running value tests.");
test_value_alloc_dealloc();
test_value_integer();
test_value_bool();
test_value_double();
test_value_datetime();
test_value_string_no_null();
test_value_string_null();
test_value_string_wide();
test_value_base64();
test_value_array();
test_value_array2();
test_value_array_nil();
test_value_value();
test_value_AS();
test_value_AS_typecheck();
test_value_cptr();
test_value_nil();
test_value_type_mismatch();
test_value_invalid_type();
test_value_missing_array_delim();
test_value_missing_struct_delim();
test_value_invalid_struct();
test_value_parse_value();
test_struct();
printf("\n");
printf("Value tests done.\n");
}
int main(int argc, char* argv[]) {
test_unsigned();
test_struct();
return 0;
}
void testmain(void) {
print("sizeof");
test_primitives();
test_pointers();
test_unsigned();
test_literals();
test_arrays();
test_vars();
test_struct();
test_constexpr();
}
int main()
{
test_MDBU();
test_ROU();
test_hex();
test_struct();
test_ptr();
test_ptr2();
test_st();
return;
}
int main()
{
int a = 10;
int b = 11;
int res = test_call(a, b, compar);
printf("res:%d\n", res);
struct point pt;
pt.x = 1;
pt.y = 2;
pt.name = "zenki";
test_struct(pt);
return 0;
}
void main(int a) {
test_ull ();
test_struct () ;
test_struct_ptr () ;
test_tab (13) ;
test_float_double ();
int b = init(5); // TODO: init(5); b = 0;
z = add3 (a, 0, 0);
int *p = test_ptr (y);
//@ assert *p == 7 ;
int *q = a?p:&y;
int yy = *q;
//@ assert a==0 ==> q==&y ;
//@ assert *q == 7 ;
}
void testmain(void) {
print("function");
expect(77, t1());
t2(79);
t3(1, 2, 3, 4, 5, 6);
t4();
t5();
expect(3, t6());
expect(12, t7(3, 4));
t8(23);
t9();
expect(7, t10(3, 4.0));
func_ptr_call();
func_name();
empty();
empty2();
test_bool();
test_struct();
}
void testmain() {
print("function");
expect(77, t1());
t2(79);
t3(1, 2, 3, 4, 5, 6);
t4();
t5();
expect(3, t6());
expect(12, t7(3, 4));
expect(77, (1 ? t1 : t6)());
expect(3, (0 ? t1 : t6)());
t8(23);
t9();
expect(7, t10(3, 4.0));
func_ptr_call();
func_name();
local_static();
empty();
empty2();
test_bool();
test_struct();
test_funcdesg();
}
/**
* Main function. Call several tests and print-out the results. It try to stress the convertor
* using difficult data-type constructions as well as strange segment sizes for the conversion.
* Usually, it is able to detect most of the data-type and convertor problems. Any modifications
* on the data-type engine should first pass all the tests from this file, before going into other
* tests.
*/
int main( int argc, char* argv[] )
{
opal_datatype_t *pdt, *pdt1, *pdt2, *pdt3;
int rc, length = 500;
opal_datatype_init();
/**
* By default simulate homogeneous architectures.
*/
remote_arch = opal_local_arch;
printf( "\n\n#\n * TEST CREATE CONTIGUOUS\n #\n\n" );
pdt = create_contiguous_type( &opal_datatype_int1, 10 );
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 100);
local_copy_with_convertor(pdt, 100, 956);
}
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "\n\n#\n * TEST STRANGE DATATYPE\n #\n\n" );
pdt = create_strange_dt();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 1);
local_copy_with_convertor(pdt, 1, 956);
}
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "\n\n#\n * TEST UPPER TRIANGULAR MATRIX (size 100)\n #\n\n" );
pdt = upper_matrix(100);
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 1);
local_copy_with_convertor(pdt, 1, 48);
}
OBJ_RELEASE( pdt );
assert( pdt == NULL );
mpich_typeub();
mpich_typeub2();
mpich_typeub3();
printf( "\n\n#\n * TEST UPPER MATRIX\n #\n\n" );
rc = test_upper( length );
if( rc == 0 )
printf( "decode [PASSED]\n" );
else
printf( "decode [NOT PASSED]\n" );
printf( "\n\n#\n * TEST MATRIX BORDERS\n #\n\n" );
pdt = test_matrix_borders( length, 100 );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
opal_datatype_dump( pdt );
}
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "\n\n#\n * TEST CONTIGUOUS\n #\n\n" );
pdt = test_contiguous();
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "\n\n#\n * TEST STRUCT\n #\n\n" );
pdt = test_struct();
OBJ_RELEASE( pdt );
assert( pdt == NULL );
opal_datatype_create_contiguous(0, &opal_datatype_empty, &pdt1);
opal_datatype_create_contiguous(0, &opal_datatype_empty, &pdt2);
opal_datatype_create_contiguous(0, &opal_datatype_empty, &pdt3);
opal_datatype_add( pdt3, &opal_datatype_int4, 10, 0, -1 );
opal_datatype_add( pdt3, &opal_datatype_float4, 5, 10 * sizeof(int), -1 );
opal_datatype_add( pdt2, &opal_datatype_float4, 1, 0, -1 );
opal_datatype_add( pdt2, pdt3, 3, sizeof(int) * 1, -1 );
opal_datatype_add( pdt1, &opal_datatype_int8, 5, 0, -1 );
opal_datatype_add( pdt1, &opal_datatype_float16, 2, sizeof(long long) * 5, -1 );
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
opal_datatype_dump( pdt1 );
}
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
opal_datatype_dump( pdt2 );
}
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
opal_datatype_dump( pdt3 );
}
OBJ_RELEASE( pdt1 );
assert( pdt1 == NULL );
OBJ_RELEASE( pdt2 );
assert( pdt2 == NULL );
OBJ_RELEASE( pdt3 );
assert( pdt3 == NULL );
printf( ">>--------------------------------------------<<\n" );
printf( " Contiguous data-type (opal_datatype_float8)\n" );
if( outputFlags & CHECK_PACK_UNPACK ) {
const opal_datatype_t const* ddt = &opal_datatype_float8;
local_copy_ddt_count( ddt, 4500);
local_copy_with_convertor( ddt, 4500, 12 );
local_copy_with_convertor_2datatypes( ddt, 4500, ddt, 4500, 12 );
}
printf( ">>--------------------------------------------<<\n" );
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & CHECK_PACK_UNPACK ) {
printf( "Contiguous multiple data-type (4500*1)\n" );
pdt = create_contiguous_type( &opal_datatype_float8, 4500 );
local_copy_ddt_count(pdt, 1);
local_copy_with_convertor( pdt, 1, 12 );
local_copy_with_convertor_2datatypes( pdt, 1, pdt, 1, 12 );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (450*10)\n" );
pdt = create_contiguous_type( &opal_datatype_float8, 450 );
local_copy_ddt_count(pdt, 10);
local_copy_with_convertor( pdt, 10, 12 );
local_copy_with_convertor_2datatypes( pdt, 10, pdt, 10, 12 );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (45*100)\n" );
pdt = create_contiguous_type( &opal_datatype_float8, 45 );
local_copy_ddt_count(pdt, 100);
local_copy_with_convertor( pdt, 100, 12 );
local_copy_with_convertor_2datatypes( pdt, 100, pdt, 100, 12 );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (100*45)\n" );
pdt = create_contiguous_type( &opal_datatype_float8, 100 );
local_copy_ddt_count(pdt, 45);
local_copy_with_convertor( pdt, 45, 12 );
local_copy_with_convertor_2datatypes( pdt, 45, pdt, 45, 12 );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (10*450)\n" );
pdt = create_contiguous_type( &opal_datatype_float8, 10 );
local_copy_ddt_count(pdt, 450);
local_copy_with_convertor( pdt, 450, 12 );
local_copy_with_convertor_2datatypes( pdt, 450, pdt, 450, 12 );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (1*4500)\n" );
pdt = create_contiguous_type( &opal_datatype_float8, 1 );
local_copy_ddt_count(pdt, 4500);
local_copy_with_convertor( pdt, 4500, 12 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 12 );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
}
printf( ">>--------------------------------------------<<\n" );
printf( ">>--------------------------------------------<<\n" );
printf( "Vector data-type (450 times 10 double stride 11)\n" );
pdt = create_vector_type( &opal_datatype_float8, 450, 10, 11 );
opal_datatype_dump( pdt );
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 1);
local_copy_with_convertor( pdt, 1, 12 );
local_copy_with_convertor_2datatypes( pdt, 1, pdt, 1, 12 );
local_copy_with_convertor( pdt, 1, 82 );
local_copy_with_convertor_2datatypes( pdt, 1, pdt, 1, 82 );
local_copy_with_convertor( pdt, 1, 6000 );
local_copy_with_convertor_2datatypes( pdt, 1, pdt, 1, 6000 );
local_copy_with_convertor( pdt, 1, 36000 );
local_copy_with_convertor_2datatypes( pdt, 1, pdt, 1, 36000 );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_struct_char_double();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 4500);
local_copy_with_convertor( pdt, 4500, 12 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 12 );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_create_twice_two_doubles();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_count(pdt, 4500);
local_copy_with_convertor( pdt, 4500, 12 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 12 );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_create_blacs_type();
if( outputFlags & CHECK_PACK_UNPACK ) {
opal_datatype_dump( pdt );
local_copy_ddt_count(pdt, 4500);
local_copy_with_convertor( pdt, 4500, 956 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 956 );
local_copy_with_convertor( pdt, 4500, 16*1024 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 16*1024 );
local_copy_with_convertor( pdt, 4500, 64*1024 );
local_copy_with_convertor_2datatypes( pdt, 4500, pdt, 4500, 64*1024 );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt1 = test_create_blacs_type1( &opal_datatype_int4 );
pdt2 = test_create_blacs_type2( &opal_datatype_int4 );
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_with_convertor_2datatypes( pdt1, 1, pdt2, 1, 100 );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt1 );
assert( pdt1 == NULL );
OBJ_RELEASE( pdt2 );
assert( pdt2 == NULL );
/* clean-ups all data allocations */
opal_datatype_finalize();
return OPAL_SUCCESS;
}
/**
* Main function. Call several tests and print-out the results. It try to stress the convertor
* using difficult data-type constructions as well as strange segment sizes for the conversion.
* Usually, it is able to detect most of the data-type and convertor problems. Any modifications
* on the data-type engine should first pass all the tests from this file, before going into other
* tests.
*/
int main( int argc, char* argv[] )
{
ompi_datatype_t *pdt, *pdt1, *pdt2, *pdt3;
int rc, length = 500, iov_num = 5;
ompi_datatype_init();
/**
* By default simulate homogeneous architectures.
*/
remote_arch = opal_local_arch;
printf( "\n\n#\n * TEST INVERSED VECTOR\n #\n\n" );
pdt = create_inversed_vector( &ompi_mpi_int.dt, 10 );
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw(pdt, 100, iov_num);
}
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "\n\n#\n * TEST STRANGE DATATYPE\n #\n\n" );
pdt = create_strange_dt();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw(pdt, 1, iov_num);
}
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "\n\n#\n * TEST UPPER TRIANGULAR MATRIX (size 100)\n #\n\n" );
pdt = upper_matrix(100);
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw(pdt, 1, iov_num);
}
OBJ_RELEASE( pdt );
assert( pdt == NULL );
mpich_typeub();
mpich_typeub2();
mpich_typeub3();
printf( "\n\n#\n * TEST UPPER MATRIX\n #\n\n" );
rc = test_upper( length );
if( rc == 0 )
printf( "decode [PASSED]\n" );
else
printf( "decode [NOT PASSED]\n" );
printf( "\n\n#\n * TEST MATRIX BORDERS\n #\n\n" );
pdt = test_matrix_borders( length, 100 );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt );
}
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "\n\n#\n * TEST CONTIGUOUS\n #\n\n" );
pdt = test_contiguous();
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "\n\n#\n * TEST STRUCT\n #\n\n" );
pdt = test_struct();
OBJ_RELEASE( pdt );
assert( pdt == NULL );
ompi_datatype_create_contiguous(0, &ompi_mpi_datatype_null.dt, &pdt1);
ompi_datatype_create_contiguous(0, &ompi_mpi_datatype_null.dt, &pdt2);
ompi_datatype_create_contiguous(0, &ompi_mpi_datatype_null.dt, &pdt3);
ompi_datatype_add( pdt3, &ompi_mpi_int.dt, 10, 0, -1 );
ompi_datatype_add( pdt3, &ompi_mpi_float.dt, 5, 10 * sizeof(int), -1 );
ompi_datatype_add( pdt2, &ompi_mpi_float.dt, 1, 0, -1 );
ompi_datatype_add( pdt2, pdt3, 3, sizeof(int) * 1, -1 );
ompi_datatype_add( pdt1, &ompi_mpi_long_long_int.dt, 5, 0, -1 );
ompi_datatype_add( pdt1, &ompi_mpi_long_double.dt, 2, sizeof(long long) * 5, -1 );
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt1 );
}
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt2 );
}
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt3 );
}
OBJ_RELEASE( pdt1 );
assert( pdt1 == NULL );
OBJ_RELEASE( pdt2 );
assert( pdt2 == NULL );
OBJ_RELEASE( pdt3 );
assert( pdt3 == NULL );
printf( ">>--------------------------------------------<<\n" );
printf( " Contiguous data-type (MPI_DOUBLE)\n" );
pdt = MPI_DOUBLE;
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw(pdt, 4500, iov_num);
}
printf( ">>--------------------------------------------<<\n" );
printf( ">>--------------------------------------------<<\n" );
if( outputFlags & CHECK_PACK_UNPACK ) {
printf( "Contiguous multiple data-type (4500*1)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 4500 );
local_copy_ddt_raw(pdt, 1, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (450*10)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 450 );
local_copy_ddt_raw(pdt, 10, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (45*100)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 45 );
local_copy_ddt_raw(pdt, 100, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (100*45)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 100 );
local_copy_ddt_raw(pdt, 45, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (10*450)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 10 );
local_copy_ddt_raw(pdt, 450, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( "Contiguous multiple data-type (1*4500)\n" );
pdt = create_contiguous_type( MPI_DOUBLE, 1 );
local_copy_ddt_raw(pdt, 4500, iov_num);
OBJ_RELEASE( pdt );
assert( pdt == NULL );
}
printf( ">>--------------------------------------------<<\n" );
printf( ">>--------------------------------------------<<\n" );
printf( "Vector data-type (450 times 10 double stride 11)\n" );
pdt = create_vector_type( MPI_DOUBLE, 450, 10, 11 );
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt );
}
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw(pdt, 1, iov_num);
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_struct_char_double();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw(pdt, 4500, iov_num);
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_create_twice_two_doubles();
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw(pdt, 4500, iov_num);
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt = test_create_blacs_type();
if( outputFlags & CHECK_PACK_UNPACK ) {
if( outputFlags & DUMP_DATA_AFTER_COMMIT ) {
ompi_datatype_dump( pdt );
}
local_copy_ddt_raw(pdt, 4500, iov_num);
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt );
assert( pdt == NULL );
printf( ">>--------------------------------------------<<\n" );
pdt1 = test_create_blacs_type1( &ompi_mpi_int.dt );
if( outputFlags & CHECK_PACK_UNPACK ) {
local_copy_ddt_raw( pdt1, 1, iov_num );
}
printf( ">>--------------------------------------------<<\n" );
OBJ_RELEASE( pdt1 );
assert( pdt1 == NULL );
/* clean-ups all data allocations */
ompi_datatype_finalize();
return OMPI_SUCCESS;
}
int
main(int argc,char *argv[])
{
printf("%d",add(1,2));
test_t tt = test_struct(1,2,3);
}