mirror of
https://github.com/nasa/trick.git
synced 2024-12-25 07:41:08 +00:00
a9aa7088ad
* Updated convert_swig to account for template directive changes in SWIG 4 * Fixed merge issues * Merge cleanup
3021 lines
130 KiB
Python
3021 lines
130 KiB
Python
|
|
import math
|
|
from trick.unit_test import *
|
|
|
|
def main():
|
|
|
|
# These are here as a reference for the add_collect syntax... I have changed the code to not use collect
|
|
# An example of removing collect in the input file (original collect added in S_define file)
|
|
#test_so.obj.state.work.external_force = trick.delete_collect(test_so.obj.state.work.external_force, test_so.obj.force.output.force)
|
|
# An example of adding a collect in the input file
|
|
#test_so.obj.state.work.external_force = trick.add_collect(test_so.obj.state.work.external_force, test_so.obj.force.output.force)
|
|
|
|
# An example of turning off a sim_object
|
|
trick.exec_set_sim_object_onoff("disabled_obj" , False)
|
|
|
|
trick.exec_set_terminate_time(1.0)
|
|
|
|
trick_utest.unit_tests.enable()
|
|
trick_utest.unit_tests.set_file_name( os.getenv("TRICK_HOME") + "/trick_test/SIM_test_ip.xml" )
|
|
trick_utest.unit_tests.set_test_name( "IPtest" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "double"
|
|
|
|
test_so.obj.d = 2
|
|
TRICK_EXPECT_NEAR( test_so.obj.d , 2.0 , 0.000001 , test_suite , "no units" )
|
|
trick.trick_test_add_parent( test_suite , "no units" , "910635102")
|
|
|
|
test_so.obj.d = trick.attach_units("lb" , 2)
|
|
TRICK_EXPECT_NEAR( test_so.obj.d , 0.907185 , 0.000001 , test_suite , "units convert" )
|
|
|
|
test_so.obj.da = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[0] , 20 , 0.000001 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[1] , 21 , 0.000001 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[2] , 22 , 0.000001 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.da = [ 30.1 , 31.1 , 32.1 ]
|
|
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[0] , 30.1 , 0.000001 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[1] , 31.1 , 0.000001 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[2] , 32.1 , 0.000001 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.da = 40.1 , 41.1 , 42.1
|
|
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[0] , 40.1 , 0.000001 , test_suite , "1D array, tuple float value, no units" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[1] , 41.1 , 0.000001 , test_suite , "1D array, tuple float value, no units" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[2] , 42.1 , 0.000001 , test_suite , "1D array, tuple float value, no units" )
|
|
|
|
test_so.obj.da = trick.attach_units("lb" , [2 , 3 , 4])
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[0] , 0.907185 , 0.000001 , test_suite , "1D array, float value, units convert" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[1] , 1.36078 , 0.00001 , test_suite , "1D array, float value, units convert" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.da[2] , 1.81437 , 0.00001 , test_suite , "1D array, float value, units convert" )
|
|
|
|
test_so.obj.dp = trick.TMM_declare_var_s("double[6]")
|
|
TRICK_EXPECT_NEAR( test_so.obj.dp[0] , 0 , 0.00001 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.dp[5] , 0 , 0.00001 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dp) , "[0 kg, 0 kg, 0 kg, 0 kg, 0 kg, 0 kg]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.dp = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dp) , "[30 kg, 31 kg, 32 kg, 33 kg]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.dp[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dp) , "[30 kg, 31 kg, 62 kg, 33 kg]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( test_so.obj.dp[-1], 33, test_suite , "negative index integer value" )
|
|
TRICK_EXPECT_EQ( test_so.obj.dp[-1.0], 33, test_suite , "negative index float value" )
|
|
|
|
test_so.obj.dp[-1] = 55
|
|
test_so.obj.dp[-2] = 54
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dp) , "[30 kg, 31 kg, 54 kg, 55 kg]", test_suite , "negative index assignments" )
|
|
|
|
test_so.obj.dp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
# Mixed tuple/list notation
|
|
test_so.obj.daa = trick.attach_units( "kg", (( 50 , 51 , 52) , [53, 54, 55]) )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.daa) , "[[50 kg, 51 kg, 52 kg],[53 kg, 54 kg, 55 kg]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.daa = trick.attach_units( "kg", [[ 40 , 41 , 42] , [43, 44, 45]] )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.daa) , "[[40 kg, 41 kg, 42 kg],[43 kg, 44 kg, 45 kg]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.daa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.daa) , "[[40 kg, 41 kg, 42 kg],[50 kg, 51 kg, 52 kg]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.daa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.daa) , "[[40 kg, 41 kg, 42 kg],[50.1 kg, 51.2 kg, 52.3 kg]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.daa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.daa) , "[[40 kg, 41 kg, 42 kg],[50.1 kg, 60 kg, 52.3 kg]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
test_so.obj.daa[0] = trick.attach_units( "lb",[ 4.0, 5.0, 6.0])
|
|
TRICK_EXPECT_EQ( str(test_so.obj.daa[0]) , "[1.81436948 kg, 2.26796185 kg, 2.72155422 kg]",
|
|
test_suite , "2D array, single single row assignment with units conversion" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dap) , "[NULL, NULL, NULL, NULL]", test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.dap[0] = trick.TMM_declare_var_1d( "double", 3)
|
|
test_so.obj.dap[1] = trick.TMM_declare_var_1d( "double", 4)
|
|
test_so.obj.dap[2] = trick.TMM_declare_var_1d( "double", 5)
|
|
test_so.obj.dap[3] = trick.TMM_declare_var_1d( "double", 6)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dap[0]) , "[0 kg, 0 kg, 0 kg]", test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.dap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dap[3]) , "[60 kg, 61 kg, 62 kg, 63 kg]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.dap[3][1] = 75
|
|
test_so.obj.dap[3][3] = trick.attach_units("lb", float(test_so.obj.dap[3][3]) + 1.0)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dap[3]) , "[60 kg, 75 kg, 62 kg, 29.02991168 kg]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.dpp = trick.TMM_declare_var_s("double *[4]")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dpp) , "[NULL, NULL, NULL, NULL]", test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.dpp[0] = trick.TMM_declare_var_1d( "double", 5)
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dpp[0]) , "[0 kg, 0 kg, 0 kg, 0 kg, 0 kg]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.dpp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dpp[0]) , "[0 kg, 85 kg, 0 kg, 0 kg, 0 kg]",
|
|
test_suite , "2D ptr of ptr, scalar assignment" )
|
|
|
|
test_so.obj.dpp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dpp[1]) , "[91 kg, 92 kg, 93 kg]",
|
|
test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.dpp[2] = trick.attach_units("lb" , [ 91 , 92 , 93 , 94 , 95])
|
|
TRICK_EXPECT_NEAR( test_so.obj.dpp[2][0] , 41.276905 , 0.000001 ,
|
|
test_suite , "2D ptr of ptr, united value" )
|
|
|
|
test_so.obj.dpp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dpp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.daaa[0][0] = [1, 2, 3, 4]
|
|
test_so.obj.daaa[0][1] = [5, 6, 7, 8]
|
|
test_so.obj.daaa[0][2][0] = 9
|
|
test_so.obj.daaa[0][2][1] = 10
|
|
test_so.obj.daaa[0][2][2] = 11
|
|
test_so.obj.daaa[0][2][3] = 12
|
|
# 2D assignment fails with error message but does not exit sim. :(
|
|
#test_so.obj.daaa[1][0] = [[101, 102, 103, 104] , [105, 106, 107, 108] , [109, 110, 111, 112]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.daaa[0]) , "[[1 kg, 2 kg, 3 kg, 4 kg],[5 kg, 6 kg, 7 kg, 8 kg],[9 kg, 10 kg, 11 kg, 12 kg]]",
|
|
test_suite , "3D array, list and scalar assignment" )
|
|
|
|
# 4D assignment array is not supported yet
|
|
#test_so.obj.daaaa[0][0][0] = [51, 52, 53, 54, 55]
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "float"
|
|
|
|
test_so.obj.f = 2
|
|
TRICK_EXPECT_NEAR( test_so.obj.f , 2.0 , 0.000001 , test_suite , "no units" )
|
|
trick.trick_test_add_parent( test_suite , "no units" , "1532242077")
|
|
|
|
test_so.obj.f = trick.attach_units("lb" , 2)
|
|
TRICK_EXPECT_NEAR( test_so.obj.f , 0.907185 , 0.000001 , test_suite , "units convert" )
|
|
|
|
test_so.obj.fa = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_NEAR( test_so.obj.fa[0] , 20 , 0.000001 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.fa[1] , 21 , 0.000001 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.fa[2] , 22 , 0.000001 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.fa = [ 30.1 , 31.1 , 32.1 ]
|
|
|
|
TRICK_EXPECT_NEAR( test_so.obj.fa[0] , 30.1 , 0.0001 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.fa[1] , 31.1 , 0.0001 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.fa[2] , 32.1 , 0.0001 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.fa = trick.attach_units("lb" , [2 , 3 , 4])
|
|
TRICK_EXPECT_NEAR( test_so.obj.fa[0] , 0.907185 , 0.000001 , test_suite , "1D array, float value, units convert" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.fa[1] , 1.36078 , 0.00001 , test_suite , "1D array, float value, units convert" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.fa[2] , 1.81437 , 0.00001 , test_suite , "1D array, float value, units convert" )
|
|
|
|
test_so.obj.fp = trick.alloc_type( 6 , "float")
|
|
TRICK_EXPECT_NEAR( test_so.obj.fp[0] , 0 , 0.00001 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.fp[5] , 0 , 0.00001 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fp) , "[0 kg, 0 kg, 0 kg, 0 kg, 0 kg, 0 kg]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.fp = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fp) , "[30 kg, 31 kg, 32 kg, 33 kg]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.fp[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fp) , "[30 kg, 31 kg, 62 kg, 33 kg]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.fp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.faa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.faa) , "[[40 kg, 41 kg, 42 kg],[43 kg, 44 kg, 45 kg]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.faa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.faa) , "[[40 kg, 41 kg, 42 kg],[50 kg, 51 kg, 52 kg]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.faa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.faa) , "[[40 kg, 41 kg, 42 kg],[50.099998 kg, 51.200001 kg, 52.299999 kg]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.faa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.faa) , "[[40 kg, 41 kg, 42 kg],[50.099998 kg, 60 kg, 52.299999 kg]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.fap[0] = trick.alloc_type( 3 , "float")
|
|
test_so.obj.fap[1] = trick.alloc_type( 4 , "float")
|
|
test_so.obj.fap[2] = trick.alloc_type( 5 , "float")
|
|
test_so.obj.fap[3] = trick.alloc_type( 6 , "float")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fap[0]) , "[0 kg, 0 kg, 0 kg]",
|
|
test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.fap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fap[3]) , "[60 kg, 61 kg, 62 kg, 63 kg]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.fap[3][1] = 75
|
|
test_so.obj.fap[3][3] = trick.attach_units("lb", float(test_so.obj.fap[3][3]) + 1.0)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fap[3]) , "[60 kg, 75 kg, 62 kg, 29.029911 kg]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.fpp = trick.alloc_type( 4 , "float *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fpp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.fpp[0] = trick.alloc_type( 5 , "float")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fpp[0]) , "[0 kg, 0 kg, 0 kg, 0 kg, 0 kg]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.fpp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fpp[0]) , "[0 kg, 85 kg, 0 kg, 0 kg, 0 kg]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.fpp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fpp[1]) , "[91 kg, 92 kg, 93 kg]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.fpp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.fpp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.f_rad = 2.0
|
|
TRICK_EXPECT_NEAR( test_so.obj.f_rad , 2.0 , 0.000001 , test_suite , "no units" )
|
|
|
|
test_so.obj.f_rad = trick.attach_units("degree" , 45.0)
|
|
TRICK_EXPECT_NEAR( test_so.obj.f_rad , 0.785398 , 0.000001 , test_suite , "unit conv" )
|
|
|
|
test_so.obj.d_deg = test_so.obj.f_rad
|
|
TRICK_EXPECT_NEAR( test_so.obj.d_deg , 45.0 , 0.00001 , test_suite , "value to value assign with conversion" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "char"
|
|
|
|
test_so.obj.c = 'g'
|
|
TRICK_EXPECT_EQ( str(test_so.obj.c) , "103", test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "2896569040")
|
|
|
|
test_so.obj.c = 123
|
|
TRICK_EXPECT_EQ( str(test_so.obj.c) , "123", test_suite , "assignment" )
|
|
|
|
test_so.obj.ca = "Trick is great"
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ca) , "Trick is great", test_suite , "arrray assignment" )
|
|
|
|
test_so.obj.ca = [65, 66, 67, 68, 69]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ca) , "ABCDE", test_suite , "arrray assignment" )
|
|
|
|
test_so.obj.ca = [65.1, 66.2, 67.3, 68.4, 69.6]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ca) , "ABCDE", test_suite , "arrray assignment" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ca[3] , 68 , test_suite , "arrray assignment" )
|
|
|
|
test_so.obj.cp = trick.alloc_type( 6 , "char")
|
|
TRICK_EXPECT_EQ( test_so.obj.cp[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.cp[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cp) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.cp = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cp) , "[30, 31, ' ', '!']", test_suite , "float 1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.cp[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cp) , "[30, 31, '>', '!']", test_suite , "float 1D ptr, partial assign, no units" )
|
|
|
|
|
|
test_so.obj.cp = "testing"
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cp) , "testing", test_suite , "ptr assignment" )
|
|
|
|
test_so.obj.cp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.caa = [ "abcdefg" , "hijklmn" ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.caa) , "[\"abcdefg\",\"hijklmn\",[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]", test_suite , "2D array string assignment" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.caa[1]) , "hijklmn", test_suite , "2D array item access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.caa[1][4] , 108, test_suite , "2D array single char access" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cap) , """[NULL, NULL, NULL, NULL]""", test_suite , "2D array of ptr initial value" )
|
|
|
|
test_so.obj.cap[0] = "cap0"
|
|
test_so.obj.cap[1] = "cap1"
|
|
test_so.obj.cap[2] = "cap2"
|
|
test_so.obj.cap[3] = "cap3"
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cap) , "[\"cap0\", \"cap1\", \"cap2\", \"cap3\"]", test_suite , "2D array of ptr single item assignment" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cap[0]) , "cap0", test_suite , "2D array of ptr single item assignment" )
|
|
|
|
TRICK_EXPECT_EQ( test_so.obj.cap[3][2] , 112 , test_suite , "2D array of ptr single item assignment" )
|
|
|
|
test_so.obj.cpp = trick.alloc_type( 4 , "char *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cpp) , """[NULL, NULL, NULL, NULL]""", test_suite , "2D ptr of ptr initial value" )
|
|
|
|
test_so.obj.cpp[0] = "cpp_string_0"
|
|
test_so.obj.cpp[1] = "cpp_string_1"
|
|
test_so.obj.cpp[2] = "cpp_string_2"
|
|
test_so.obj.cpp[3] = "cpp_string_3"
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cpp[2]) , "cpp_string_2", test_suite , "2D ptr of ptr single string access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.cpp[2][3] , 95 , test_suite , "2D ptr of ptr single character access" )
|
|
|
|
test_so.obj.cpp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.cpp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "unsigned char"
|
|
|
|
test_so.obj.uc = 95
|
|
TRICK_EXPECT_EQ( test_so.obj.uc , 95 , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "219444977")
|
|
|
|
test_so.obj.uc += 1
|
|
TRICK_EXPECT_EQ( test_so.obj.uc , 96 , test_suite , "increment" )
|
|
|
|
test_so.obj.uc = test_so.obj.uc + 1
|
|
TRICK_EXPECT_EQ( test_so.obj.uc , 97 , test_suite , "increment" )
|
|
|
|
test_so.obj.uc = 1 + test_so.obj.uc
|
|
TRICK_EXPECT_EQ( test_so.obj.uc , 98 , test_suite , "increment" )
|
|
|
|
test_so.obj.uca = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.uca[0] , 20 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.uca[1] , 21 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.uca[2] , 22 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.uca = [ 30.1 , 31.1 , 32.1 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.uca[0] , 30 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.uca[1] , 31 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.uca[2] , 32 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.ucp = trick.alloc_type( 6 , "unsigned char")
|
|
TRICK_EXPECT_EQ( test_so.obj.ucp[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ucp[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucp) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.ucp = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucp) , "[30, 31, 32, 33]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.ucp[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucp) , "[30, 31, 62, 33]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.ucp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.ucaa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucaa) , "[[40, 41, 42],[43, 44, 45]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.ucaa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.ucaa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.ucaa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucaa) , "[[40, 41, 42],[50, 60, 52]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.ucap[0] = trick.alloc_type( 3 , "unsigned char")
|
|
test_so.obj.ucap[1] = trick.alloc_type( 4 , "unsigned char")
|
|
test_so.obj.ucap[2] = trick.alloc_type( 5 , "unsigned char")
|
|
test_so.obj.ucap[3] = trick.alloc_type( 6 , "unsigned char")
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucap[0]) , "[0, 0, 0]",
|
|
test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.ucap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucap[3]) , "[60, 61, 62, 63]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.ucap[3][1] = 75
|
|
test_so.obj.ucap[3][3] = trick.attach_units("--", int(test_so.obj.ucap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucap[3]) , "[60, 75, 62, 64]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.ucpp = trick.alloc_type( 4 , "unsigned char *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucpp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.ucpp[0] = trick.alloc_type( 5 , "unsigned char")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucpp[0]) , "[0, 0, 0, 0, 0]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.ucpp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucpp[0]) , "[0, 85, 0, 0, 0]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.ucpp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucpp[1]) , "[91, 92, 93]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.ucpp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ucpp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "short"
|
|
|
|
test_so.obj.s = 95
|
|
TRICK_EXPECT_EQ( test_so.obj.s , 95 , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "2880907803")
|
|
|
|
test_so.obj.s += 1
|
|
TRICK_EXPECT_EQ( test_so.obj.s , 96 , test_suite , "increment" )
|
|
|
|
test_so.obj.s = test_so.obj.s + 1
|
|
TRICK_EXPECT_EQ( test_so.obj.s , 97 , test_suite , "increment" )
|
|
|
|
test_so.obj.s = 1 + test_so.obj.s
|
|
TRICK_EXPECT_EQ( test_so.obj.s , 98 , test_suite , "increment" )
|
|
|
|
test_so.obj.sa = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.sa[0] , 20 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.sa[1] , 21 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.sa[2] , 22 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.sa = [ 30.1 , 31.1 , 32.1 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.sa[0] , 30 , test_suite , "short 1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.sa[1] , 31 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.sa[2] , 32 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.sp = trick.alloc_type( 6 , "short")
|
|
TRICK_EXPECT_EQ( test_so.obj.sp[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.sp[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.sp) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.sp = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.sp) , "[30, 31, 32, 33]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.sp[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.sp) , "[30, 31, 62, 33]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.sp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.sp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.saa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.saa) , "[[40, 41, 42],[43, 44, 45]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.saa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.saa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.saa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.saa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.saa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.saa) , "[[40, 41, 42],[50, 60, 52]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.sap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.sap[0] = trick.alloc_type( 3 , "short")
|
|
test_so.obj.sap[1] = trick.alloc_type( 4 , "short")
|
|
test_so.obj.sap[2] = trick.alloc_type( 5 , "short")
|
|
test_so.obj.sap[3] = trick.alloc_type( 6 , "short")
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.sap[0]) , "[0, 0, 0]",
|
|
test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.sap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.sap[3]) , "[60, 61, 62, 63]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.sap[3][1] = 75
|
|
test_so.obj.sap[3][3] = trick.attach_units("--", int(test_so.obj.sap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.sap[3]) , "[60, 75, 62, 64]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.spp = trick.alloc_type( 4 , "short *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.spp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.spp[0] = trick.alloc_type( 5 , "short")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.spp[0]) , "[0, 0, 0, 0, 0]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.spp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.spp[0]) , "[0, 85, 0, 0, 0]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.spp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.spp[1]) , "[91, 92, 93]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.spp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.spp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "unsigned short"
|
|
|
|
test_so.obj.us = 95
|
|
TRICK_EXPECT_EQ( test_so.obj.us , 95 , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "217750348")
|
|
|
|
test_so.obj.us += 1
|
|
TRICK_EXPECT_EQ( test_so.obj.us , 96 , test_suite , "increment" )
|
|
|
|
test_so.obj.us = test_so.obj.us + 1
|
|
TRICK_EXPECT_EQ( test_so.obj.us , 97 , test_suite , "increment" )
|
|
|
|
test_so.obj.us = 1 + test_so.obj.us
|
|
TRICK_EXPECT_EQ( test_so.obj.us , 98 , test_suite , "increment" )
|
|
|
|
test_so.obj.usa = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.usa[0] , 20 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.usa[1] , 21 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.usa[2] , 22 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.usa = [ 30.1 , 31.1 , 32.1 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.usa[0] , 30 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.usa[1] , 31 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.usa[2] , 32 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.usp = trick.alloc_type( 6 , "unsigned short")
|
|
TRICK_EXPECT_EQ( test_so.obj.usp[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.usp[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usp) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.usp = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usp) , "[30, 31, 32, 33]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.usp[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usp) , "[30, 31, 62, 33]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.usp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.usaa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usaa) , "[[40, 41, 42],[43, 44, 45]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.usaa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.usaa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.usaa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usaa) , "[[40, 41, 42],[50, 60, 52]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.usap[0] = trick.alloc_type( 3 , "unsigned short")
|
|
test_so.obj.usap[1] = trick.alloc_type( 4 , "unsigned short")
|
|
test_so.obj.usap[2] = trick.alloc_type( 5 , "unsigned short")
|
|
test_so.obj.usap[3] = trick.alloc_type( 6 , "unsigned short")
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usap[0]) , "[0, 0, 0]",
|
|
test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.usap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usap[3]) , "[60, 61, 62, 63]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.usap[3][1] = 75
|
|
test_so.obj.usap[3][3] = trick.attach_units("--", int(test_so.obj.usap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.usap[3]) , "[60, 75, 62, 64]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.uspp = trick.alloc_type( 4 , "unsigned short *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uspp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.uspp[0] = trick.alloc_type( 5 , "unsigned short")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uspp[0]) , "[0, 0, 0, 0, 0]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.uspp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uspp[0]) , "[0, 85, 0, 0, 0]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.uspp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uspp[1]) , "[91, 92, 93]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.uspp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uspp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "enum"
|
|
|
|
test_so.obj.e = trick.THIRD
|
|
TRICK_EXPECT_EQ( test_so.obj.e , trick.THIRD , test_suite , "scalar, integer value, no units" )
|
|
trick.trick_test_add_parent( test_suite , "scalar, integer value, no units" , "3331066868")
|
|
|
|
test_so.obj.ea = [ trick.THIRD , trick.SECOND , trick.FIRST ]
|
|
TRICK_EXPECT_EQ( test_so.obj.ea[0] , trick.THIRD , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ea[1] , trick.SECOND , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ea[2] , trick.FIRST , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.ea[1] = trick.THIRD
|
|
test_so.obj.ea[2] = trick.SECOND
|
|
TRICK_EXPECT_EQ( test_so.obj.ea[1] , trick.THIRD , test_suite , "1D array single value assignment" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ea[2] , trick.SECOND , test_suite , "1D array single value assignment" )
|
|
|
|
test_so.obj.ep = trick.alloc_type( 6 , "MY_ENUM")
|
|
TRICK_EXPECT_EQ( test_so.obj.ep[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ep[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ep) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.ep = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ep) , "[30, 31, 32, 33]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.ep[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ep) , "[30, 31, 62, 33]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.ep = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ep) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.eaa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.eaa) , "[[40, 41, 42],[43, 44, 45]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.eaa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.eaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.eaa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.eaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.eaa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.eaa) , "[[40, 41, 42],[50, 60, 52]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.eap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.eap[0] = trick.alloc_type( 3 , "MY_ENUM")
|
|
test_so.obj.eap[1] = trick.alloc_type( 4 , "MY_ENUM")
|
|
test_so.obj.eap[2] = trick.alloc_type( 5 , "MY_ENUM")
|
|
test_so.obj.eap[3] = trick.alloc_type( 6 , "MY_ENUM")
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.eap[0]) , "[0, 0, 0]", test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.eap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.eap[3]) , "[60, 61, 62, 63]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.eap[3][1] = 75
|
|
test_so.obj.eap[3][3] = trick.attach_units("--", int(test_so.obj.eap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.eap[3]) , "[60, 75, 62, 64]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.epp = trick.alloc_type( 4 , "MY_ENUM *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.epp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "int 2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.epp[0] = trick.alloc_type( 5 , "MY_ENUM")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.epp[0]) , "[0, 0, 0, 0, 0]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.epp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.epp[0]) , "[0, 85, 0, 0, 0]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.epp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.epp[1]) , "[91, 92, 93]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.epp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.epp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "int"
|
|
|
|
test_so.obj.i = 95
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 95 , test_suite , "assignment" )
|
|
#print "test_so.obj.i = " , test_so.obj.i
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "3074788233")
|
|
|
|
test_so.obj.i += 1
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 96 , test_suite , "increment" )
|
|
|
|
test_so.obj.i = test_so.obj.i + 1
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 97 , test_suite , "increment" )
|
|
|
|
test_so.obj.i = 1 + test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 98 , test_suite , "increment" )
|
|
|
|
test_so.obj.ia = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.ia[0] , 20 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ia[1] , 21 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ia[2] , 22 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.ia = [ 30.1 , 31.1 , 32.1 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.ia[0] , 30 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ia[1] , 31 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ia[2] , 32 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.ia = trick.attach_units("--" , [60, 70])
|
|
TRICK_EXPECT_EQ( test_so.obj.ia[0] , 60 , test_suite , "1D array, -- units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ia[1] , 70 , test_suite , "1D array, -- units" )
|
|
|
|
test_so.obj.ip = trick.alloc_type( 6 , "int")
|
|
TRICK_EXPECT_EQ( test_so.obj.ip[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ip[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.ip = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip) , "[30, 31, 32, 33]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.ip[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip) , "[30, 31, 62, 33]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.ip = trick.attach_units("--" , [60, 70])
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip) , "[60, 70]", test_suite , "1D ptr, assign list -- unit-ed values" )
|
|
|
|
test_so.obj.ip = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.iaa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.iaa) , "[[40, 41, 42],[43, 44, 45]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.iaa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.iaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.iaa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.iaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.iaa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.iaa) , "[[40, 41, 42],[50, 60, 52]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.iap) , "[NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.iap[0] = trick.alloc_type( 3 , "int")
|
|
test_so.obj.iap[1] = trick.alloc_type( 4 , "int")
|
|
test_so.obj.iap[2] = trick.alloc_type( 5 , "int")
|
|
test_so.obj.iap[3] = trick.alloc_type( 6 , "int")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.iap[0]) , "[0, 0, 0]", test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.iap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.iap[3]) , "[60, 61, 62, 63]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.iap[3][1] = 75
|
|
test_so.obj.iap[3][3] = trick.attach_units("--", int(test_so.obj.iap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.iap[3]) , "[60, 75, 62, 64]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.ipp = trick.alloc_type( 4 , "int *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ipp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.ipp[0] = trick.alloc_type( 5 , "int")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ipp[0]) , "[0, 0, 0, 0, 0]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.ipp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ipp[0]) , "[0, 85, 0, 0, 0]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.ipp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ipp[1]) , "[91, 92, 93]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.ipp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ipp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "unsigned int"
|
|
|
|
test_so.obj.ui = 95
|
|
TRICK_EXPECT_EQ( test_so.obj.ui , 95 , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "1873736978")
|
|
|
|
test_so.obj.ui += 1
|
|
TRICK_EXPECT_EQ( test_so.obj.ui , 96 , test_suite , "increment" )
|
|
|
|
test_so.obj.ui = test_so.obj.ui + 1
|
|
TRICK_EXPECT_EQ( test_so.obj.ui , 97 , test_suite , "increment" )
|
|
|
|
test_so.obj.ui = 1 + test_so.obj.ui
|
|
TRICK_EXPECT_EQ( test_so.obj.ui , 98 , test_suite , "increment" )
|
|
|
|
test_so.obj.uia = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.uia[0] , 20 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.uia[1] , 21 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.uia[2] , 22 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.uia = [ 30.1 , 31.1 , 32.1 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.uia[0] , 30 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.uia[1] , 31 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.uia[2] , 32 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.uip = trick.alloc_type( 6 , "unsigned int")
|
|
TRICK_EXPECT_EQ( test_so.obj.uip[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.uip[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uip) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.uip = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uip) , "[30, 31, 32, 33]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.uip[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uip) , "[30, 31, 62, 33]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.uip = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uip) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.uiaa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uiaa) , "[[40, 41, 42],[43, 44, 45]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.uiaa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uiaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.uiaa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uiaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.uiaa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uiaa) , "[[40, 41, 42],[50, 60, 52]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uiap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.uiap[0] = trick.alloc_type( 3 , "unsigned int")
|
|
test_so.obj.uiap[1] = trick.alloc_type( 4 , "unsigned int")
|
|
test_so.obj.uiap[2] = trick.alloc_type( 5 , "unsigned int")
|
|
test_so.obj.uiap[3] = trick.alloc_type( 6 , "unsigned int")
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uiap[0]) , "[0, 0, 0]",
|
|
test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.uiap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uiap[3]) , "[60, 61, 62, 63]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.uiap[3][1] = 75
|
|
test_so.obj.uiap[3][3] = trick.attach_units("--", int(test_so.obj.uiap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uiap[3]) , "[60, 75, 62, 64]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.uipp = trick.alloc_type( 4 , "unsigned int *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uipp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.uipp[0] = trick.alloc_type( 5 , "unsigned int")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uipp[0]) , "[0, 0, 0, 0, 0]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.uipp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uipp[0]) , "[0, 85, 0, 0, 0]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.uipp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uipp[1]) , "[91, 92, 93]", test_suite , "unsigned int 2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.uipp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.uipp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "long"
|
|
|
|
test_so.obj.l = 95
|
|
TRICK_EXPECT_EQ( test_so.obj.l , 95 , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "3338288463")
|
|
|
|
test_so.obj.l += 1
|
|
TRICK_EXPECT_EQ( test_so.obj.l , 96 , test_suite , "increment" )
|
|
|
|
test_so.obj.l = test_so.obj.l + 1
|
|
TRICK_EXPECT_EQ( test_so.obj.l , 97 , test_suite , "increment" )
|
|
|
|
test_so.obj.l = 1 + test_so.obj.l
|
|
TRICK_EXPECT_EQ( test_so.obj.l , 98 , test_suite , "increment" )
|
|
|
|
test_so.obj.la = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.la[0] , 20 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.la[1] , 21 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.la[2] , 22 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.la = [ 30.1 , 31.1 , 32.1 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.la[0] , 30 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.la[1] , 31 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.la[2] , 32 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.lp = trick.alloc_type( 6 , "long")
|
|
TRICK_EXPECT_EQ( test_so.obj.lp[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.lp[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lp) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.lp = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lp) , "[30, 31, 32, 33]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.lp[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lp) , "[30, 31, 62, 33]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.lp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.laa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.laa) , "[[40, 41, 42],[43, 44, 45]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.laa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.laa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.laa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.laa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.laa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.laa) , "[[40, 41, 42],[50, 60, 52]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.lap[0] = trick.alloc_type( 3 , "long")
|
|
test_so.obj.lap[1] = trick.alloc_type( 4 , "long")
|
|
test_so.obj.lap[2] = trick.alloc_type( 5 , "long")
|
|
test_so.obj.lap[3] = trick.alloc_type( 6 , "long")
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lap[0]) , "[0, 0, 0]",
|
|
test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.lap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lap[3]) , "[60, 61, 62, 63]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.lap[3][1] = 75
|
|
test_so.obj.lap[3][3] = trick.attach_units("--", int(test_so.obj.lap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lap[3]) , "[60, 75, 62, 64]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.lpp = trick.alloc_type( 4 , "long *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lpp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.lpp[0] = trick.alloc_type( 5 , "long")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lpp[0]) , "[0, 0, 0, 0, 0]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.lpp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lpp[0]) , "[0, 85, 0, 0, 0]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.lpp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lpp[1]) , "[91, 92, 93]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.lpp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.lpp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "unsinged long"
|
|
|
|
test_so.obj.ul = 95
|
|
TRICK_EXPECT_EQ( test_so.obj.ul , 95 , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "2844151852")
|
|
|
|
test_so.obj.ul += 1
|
|
TRICK_EXPECT_EQ( test_so.obj.ul , 96 , test_suite , "increment" )
|
|
|
|
test_so.obj.ul = test_so.obj.ul + 1
|
|
TRICK_EXPECT_EQ( test_so.obj.ul , 97 , test_suite , "increment" )
|
|
|
|
test_so.obj.ul = 1 + test_so.obj.ul
|
|
TRICK_EXPECT_EQ( test_so.obj.ul , 98 , test_suite , "increment" )
|
|
|
|
test_so.obj.ula = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.ula[0] , 20 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ula[1] , 21 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ula[2] , 22 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.ula = [ 30.1 , 31.1 , 32.1 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.ula[0] , 30 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ula[1] , 31 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ula[2] , 32 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.ulp = trick.alloc_type( 6 , "unsigned long")
|
|
TRICK_EXPECT_EQ( test_so.obj.ulp[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ulp[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulp) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.ulp = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulp) , "[30, 31, 32, 33]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.ulp[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulp) , "[30, 31, 62, 33]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.ulp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.ulaa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulaa) , "[[40, 41, 42],[43, 44, 45]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.ulaa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.ulaa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.ulaa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulaa) , "[[40, 41, 42],[50, 60, 52]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.ulap[0] = trick.alloc_type( 3 , "unsigned long")
|
|
test_so.obj.ulap[1] = trick.alloc_type( 4 , "unsigned long")
|
|
test_so.obj.ulap[2] = trick.alloc_type( 5 , "unsigned long")
|
|
test_so.obj.ulap[3] = trick.alloc_type( 6 , "unsigned long")
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulap[0]) , "[0, 0, 0]",
|
|
test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.ulap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulap[3]) , "[60, 61, 62, 63]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.ulap[3][1] = 75
|
|
test_so.obj.ulap[3][3] = trick.attach_units("--", int(test_so.obj.ulap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulap[3]) , "[60, 75, 62, 64]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.ulpp = trick.alloc_type( 4 , "unsigned long *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulpp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.ulpp[0] = trick.alloc_type( 5 , "unsigned long")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulpp[0]) , "[0, 0, 0, 0, 0]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.ulpp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulpp[0]) , "[0, 85, 0, 0, 0]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.ulpp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulpp[1]) , "[91, 92, 93]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.ulpp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ulpp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "long long"
|
|
|
|
test_so.obj.ll = 95
|
|
TRICK_EXPECT_EQ( test_so.obj.ll , 95 , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "2165977787")
|
|
|
|
test_so.obj.ll += 1
|
|
TRICK_EXPECT_EQ( test_so.obj.ll , 96 , test_suite , "increment" )
|
|
|
|
test_so.obj.ll = test_so.obj.ll + 1
|
|
TRICK_EXPECT_EQ( test_so.obj.ll , 97 , test_suite , "increment" )
|
|
|
|
test_so.obj.ll = 1 + test_so.obj.ll
|
|
TRICK_EXPECT_EQ( test_so.obj.ll , 98 , test_suite , "increment" )
|
|
|
|
test_so.obj.lla = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.lla[0] , 20 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.lla[1] , 21 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.lla[2] , 22 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.lla = [ 30.1 , 31.1 , 32.1 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.lla[0] , 30 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.lla[1] , 31 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.lla[2] , 32 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.llp = trick.alloc_type( 6 , "long long")
|
|
TRICK_EXPECT_EQ( test_so.obj.llp[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.llp[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llp) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.llp = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llp) , "[30, 31, 32, 33]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.llp[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llp) , "[30, 31, 62, 33]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.llp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.llaa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llaa) , "[[40, 41, 42],[43, 44, 45]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.llaa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.llaa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.llaa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llaa) , "[[40, 41, 42],[50, 60, 52]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.llap[0] = trick.alloc_type( 3 , "long long")
|
|
test_so.obj.llap[1] = trick.alloc_type( 4 , "long long")
|
|
test_so.obj.llap[2] = trick.alloc_type( 5 , "long long")
|
|
test_so.obj.llap[3] = trick.alloc_type( 6 , "long long")
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llap[0]) , "[0, 0, 0]",
|
|
test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.llap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llap[3]) , "[60, 61, 62, 63]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.llap[3][1] = 75
|
|
test_so.obj.llap[3][3] = trick.attach_units("--", int(test_so.obj.llap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llap[3]) , "[60, 75, 62, 64]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.llpp = trick.alloc_type( 4 , "long long *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llpp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.llpp[0] = trick.alloc_type( 5 , "long long")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llpp[0]) , "[0, 0, 0, 0, 0]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.llpp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llpp[0]) , "[0, 85, 0, 0, 0]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.llpp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llpp[1]) , "[91, 92, 93]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.llpp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.llpp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "unsigned long long"
|
|
|
|
test_so.obj.ull = 95
|
|
TRICK_EXPECT_EQ( test_so.obj.ull , 95 , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "3783821020")
|
|
|
|
test_so.obj.ull += 1
|
|
TRICK_EXPECT_EQ( test_so.obj.ull , 96 , test_suite , "increment" )
|
|
|
|
test_so.obj.ull = test_so.obj.ull + 1
|
|
TRICK_EXPECT_EQ( test_so.obj.ull , 97 , test_suite , "increment" )
|
|
|
|
test_so.obj.ull = 1 + test_so.obj.ull
|
|
TRICK_EXPECT_EQ( test_so.obj.ull , 98 , test_suite , "increment" )
|
|
|
|
test_so.obj.ulla = [ 20 , 21 , 22 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.ulla[0] , 20 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ulla[1] , 21 , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ulla[2] , 22 , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.ulla = [ 30.1 , 31.1 , 32.1 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.ulla[0] , 30 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ulla[1] , 31 , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ulla[2] , 32 , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.ullp = trick.alloc_type( 6 , "unsigned long long")
|
|
TRICK_EXPECT_EQ( test_so.obj.ullp[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ullp[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullp) , "[0, 0, 0, 0, 0, 0]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.ullp = [ 30 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullp) , "[30, 31, 32, 33]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.ullp[2] = 62
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullp) , "[30, 31, 62, 33]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.ullp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.ullaa = [[ 40 , 41 , 42] , [43, 44, 45]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullaa) , "[[40, 41, 42],[43, 44, 45]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.ullaa[1] = [ 50 , 51 , 52]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.ullaa[1] = [ 50.1 , 51.2 , 52.3 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullaa) , "[[40, 41, 42],[50, 51, 52]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.ullaa[1][1] = 60
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullaa) , "[[40, 41, 42],[50, 60, 52]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.ullap[0] = trick.alloc_type( 3 , "unsigned long long")
|
|
test_so.obj.ullap[1] = trick.alloc_type( 4 , "unsigned long long")
|
|
test_so.obj.ullap[2] = trick.alloc_type( 5 , "unsigned long long")
|
|
test_so.obj.ullap[3] = trick.alloc_type( 6 , "unsigned long long")
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullap[0]) , "[0, 0, 0]",
|
|
test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.ullap[3] = [ 60 , 61 , 62, 63 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullap[3]) , "[60, 61, 62, 63]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.ullap[3][1] = 75
|
|
test_so.obj.ullap[3][3] = trick.attach_units("--", int(test_so.obj.ullap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullap[3]) , "[60, 75, 62, 64]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.ullpp = trick.alloc_type( 4 , "unsigned long long *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullpp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.ullpp[0] = trick.alloc_type( 5 , "unsigned long long")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullpp[0]) , "[0, 0, 0, 0, 0]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.ullpp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullpp[0]) , "[0, 85, 0, 0, 0]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.ullpp[1] = [ 91 , 92 , 93 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullpp[1]) , "[91, 92, 93]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.ullpp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ullpp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "bool"
|
|
|
|
test_so.obj.b = True
|
|
TRICK_EXPECT_EQ( test_so.obj.b , True , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "4134211307")
|
|
|
|
test_so.obj.b += 1
|
|
TRICK_EXPECT_EQ( test_so.obj.b , True , test_suite , "increment" )
|
|
|
|
test_so.obj.b = test_so.obj.b + 1
|
|
TRICK_EXPECT_EQ( test_so.obj.b , True , test_suite , "increment" )
|
|
|
|
test_so.obj.ull = 1 + test_so.obj.ull
|
|
TRICK_EXPECT_EQ( test_so.obj.b , True , test_suite , "increment" )
|
|
|
|
test_so.obj.ba = [ False , True , True ]
|
|
TRICK_EXPECT_EQ( test_so.obj.ba[0] , False , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ba[1] , True , test_suite , "1D array, integer value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ba[2] , True , test_suite , "1D array, integer value, no units" )
|
|
|
|
test_so.obj.ba = [ 2.2 , 1.1 , 0 ]
|
|
TRICK_EXPECT_EQ( test_so.obj.ba[0] , True , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ba[1] , True , test_suite , "1D array, float value, no units" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ba[2] , False , test_suite , "1D array, float value, no units" )
|
|
|
|
test_so.obj.bp = trick.alloc_type( 6 , "bool" )
|
|
TRICK_EXPECT_EQ( test_so.obj.bp[0] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( test_so.obj.bp[5] , 0 , test_suite , "1D ptr, allocation" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bp) , "[False, False, False, False, False, False]", test_suite , "1D ptr, allocation" )
|
|
|
|
test_so.obj.bp = [ 0 , 31 , 32 , 33 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bp) , "[False, True, True, True]", test_suite , "1D ptr, list assign, no units" )
|
|
|
|
test_so.obj.bp[2] = 0
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bp) , "[False, True, False, True]", test_suite , "1D ptr, partial assign, no units" )
|
|
|
|
test_so.obj.bp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bp) , "NULL", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
test_so.obj.baa = [[ 0 , 1 , 2] , [3, 4, 0]]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.baa) , "[[False, True, True],[True, True, False]]",
|
|
test_suite , "2D array, full assign, no units" )
|
|
|
|
test_so.obj.baa[1] = [ False , False , True]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.baa) , "[[False, True, True],[False, False, True]]",
|
|
test_suite , "2D array, partial assign, no units" )
|
|
|
|
test_so.obj.baa[1][1] = True
|
|
TRICK_EXPECT_EQ( str(test_so.obj.baa) , "[[False, True, True],[False, True, True]]",
|
|
test_suite , "2D array, single assign, no units" )
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bap) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D array of ptr, initial value" )
|
|
|
|
test_so.obj.bap[0] = trick.alloc_type( 3 , "bool")
|
|
test_so.obj.bap[1] = trick.alloc_type( 4 , "bool")
|
|
test_so.obj.bap[2] = trick.alloc_type( 5 , "bool")
|
|
test_so.obj.bap[3] = trick.alloc_type( 6 , "bool")
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bap[0]) , "[False, False, False]",
|
|
test_suite , "2D array of ptr, single row access" )
|
|
|
|
test_so.obj.bap[3] = [ True , False , True, False ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bap[3]) , "[True, False, True, False]",
|
|
test_suite , "2D array of ptr, single row realloc and assignment" )
|
|
|
|
test_so.obj.bap[3][1] = 75
|
|
test_so.obj.bap[3][3] = trick.attach_units("--", int(test_so.obj.bap[3][3]) + 1)
|
|
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bap[3]) , "[True, True, True, True]",
|
|
test_suite , "2D array of ptr, single item assignment with unit conversion" )
|
|
|
|
test_so.obj.bpp = trick.alloc_type( 4 , "bool *")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bpp) , "[NULL, NULL, NULL, NULL]",
|
|
test_suite , "2D ptr of ptr, initial value" )
|
|
|
|
test_so.obj.bpp[0] = trick.alloc_type( 5 , "bool")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bpp[0]) , "[False, False, False, False, False]", test_suite , "2D ptr of ptr, allocate 1 row" )
|
|
|
|
test_so.obj.bpp[0][1] = 85
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bpp[0]) , "[False, True, False, False, False]", test_suite , "2D ptr of ptr, assign 1 value" )
|
|
|
|
test_so.obj.bpp[1] = [ True , False , True ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bpp[1]) , "[True, False, True]", test_suite , "2D ptr of ptr, row assignment" )
|
|
|
|
test_so.obj.bpp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.bpp) , "NULL", test_suite , "2D ptr None (NULL) assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "structure"
|
|
|
|
test_so.obj.cana[0].ii = 250
|
|
test_so.obj.cana[0].jj = 350
|
|
test_so.obj.cana[1].ii = 260
|
|
test_so.obj.cana[1].jj = 360
|
|
TRICK_EXPECT_EQ( test_so.obj.cana[0].ii , 250 , test_suite , "1D array access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.cana[0].jj , 350 , test_suite , "1D array access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.cana[1].ii , 260 , test_suite , "1D array access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.cana[1].jj , 360 , test_suite , "1D array access" )
|
|
trick.trick_test_add_parent( test_suite , "1D array access" , "2797105872")
|
|
|
|
test_so.obj.can.ii = 150
|
|
test_so.obj.can.jj = 160
|
|
test_so.obj.can2 = test_so.obj.can
|
|
TRICK_EXPECT_EQ( test_so.obj.can2.ii , 150 , test_suite , "copy" )
|
|
TRICK_EXPECT_EQ( test_so.obj.can2.jj , 160 , test_suite , "copy" )
|
|
|
|
#test_so.obj.cana[3] = test_so.obj.can
|
|
|
|
test_so.obj.canp = test_so.obj.can
|
|
TRICK_EXPECT_EQ( test_so.obj.canp.ii , 150 , test_suite , "pointer assignment" )
|
|
TRICK_EXPECT_EQ( test_so.obj.canp.jj , 160 , test_suite , "pointer assignment" )
|
|
|
|
test_so.obj.canp = test_so.obj.cana[1]
|
|
TRICK_EXPECT_EQ( test_so.obj.canp.ii , 260 , test_suite , "pointer to array element assignment" )
|
|
TRICK_EXPECT_EQ( test_so.obj.canp.jj , 360 , test_suite , "pointer to array element assignment" )
|
|
|
|
test_so.obj.canp = trick.alloc_type( 2 , "CanCopy" )
|
|
test_so.obj.canp[0].ii = 400
|
|
test_so.obj.canp[0].jj = 500
|
|
test_so.obj.canp[1].ii = 600
|
|
test_so.obj.canp[1].jj = 700
|
|
TRICK_EXPECT_EQ( test_so.obj.canp[0].ii , 400 , test_suite , "pointer to array element assignment" )
|
|
TRICK_EXPECT_EQ( test_so.obj.canp[0].jj , 500 , test_suite , "pointer to array element assignment" )
|
|
TRICK_EXPECT_EQ( test_so.obj.canp[1].ii , 600 , test_suite , "pointer to array element assignment" )
|
|
TRICK_EXPECT_EQ( test_so.obj.canp[1].jj , 700 , test_suite , "pointer to array element assignment" )
|
|
#print test_so.obj.canp[0]
|
|
#print test_so.obj.canp[1]
|
|
|
|
test_so.obj.canp = None
|
|
TRICK_EXPECT_EQ( str(test_so.obj.canp) , "None", test_suite , "1D ptr None (NULL) assignment" )
|
|
|
|
# silently ignored! need to figure out how to flag this
|
|
#test_so.obj.cannot = test_so.obj.cannot2
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "string"
|
|
|
|
test_so.obj.str = "hello"
|
|
TRICK_EXPECT_EQ( test_so.obj.str , "hello" , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "165635378")
|
|
|
|
#TODO: make a std::string typemap to allow assignment of string from char *
|
|
#test_so.obj.str = test_so.obj.cap[1]
|
|
#TRICK_EXPECT_EQ( test_so.obj.str , "cap1" , "IPtest" , "string assignment from char *" )
|
|
#print "test_so.obj.str = " , test_so.obj.str
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "bitfield"
|
|
|
|
test_so.obj.bit_0 = 7
|
|
TRICK_EXPECT_EQ( test_so.obj.bit_0 , 7 , test_suite , "assignment" )
|
|
trick.trick_test_add_parent( test_suite , "assignment" , "1649805110")
|
|
|
|
test_so.obj.bit_1 = 17
|
|
TRICK_EXPECT_EQ( test_so.obj.bit_1 , -15 , test_suite , "assignment with overflow" )
|
|
|
|
test_so.obj.boolbit_0 = True
|
|
TRICK_EXPECT_EQ( test_so.obj.boolbit_0 , True , test_suite , "bool assignment" )
|
|
|
|
test_so.obj.boolbit_1 = 2
|
|
TRICK_EXPECT_EQ( test_so.obj.boolbit_1 , True , test_suite , "bool assignment with overflow" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "union"
|
|
|
|
test_so.obj.ut.i = 20
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ut.i) , "20", test_suite , "test 1" )
|
|
trick.trick_test_add_parent( test_suite , "test 1" , "3095148896")
|
|
|
|
test_so.obj.ut2.i = 30
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ut2.i) , "30", test_suite , "test 2" )
|
|
trick.trick_test_add_parent( test_suite , "test 2" , "3095148896")
|
|
|
|
######################################################################################################################
|
|
|
|
# swig_int from swig_double
|
|
test_suite = "swig_int"
|
|
|
|
test_so.obj.dlbm = 50
|
|
test_so.obj.ilbm = test_so.obj.dlbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ilbm , 50, test_suite , "assignment from swig_double" )
|
|
trick.trick_test_add_parent( test_suite , "assignment from swig_double" , "2901141151")
|
|
|
|
# addition
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.ikg = test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 22, test_suite , "units conversion" )
|
|
|
|
test_so.obj.ikg = test_so.obj.ilbm + 20
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 31, test_suite , "addition with integer" )
|
|
|
|
test_so.obj.ikg = test_so.obj.ilbm + 20.9
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 32, test_suite , "addition with float" )
|
|
|
|
test_so.obj.ikg = test_so.obj.ilbm + test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 45, test_suite , "addition with swig_int" )
|
|
|
|
test_so.obj.ikg = 50
|
|
test_so.obj.ikg = test_so.obj.ilbm + test_so.obj.ikg
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 72, test_suite , "addition with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dlbm = 10
|
|
test_so.obj.ikg = test_so.obj.ilbm + test_so.obj.dlbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 27, test_suite , "addition with swig_double" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.ikg = test_so.obj.ilbm + test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 32, test_suite , "addition with swig_double and unit conversion" )
|
|
|
|
# subtraction
|
|
|
|
test_so.obj.ikg = test_so.obj.ilbm - 20
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 13, test_suite , "subtraction with integer" )
|
|
|
|
test_so.obj.ikg = test_so.obj.ilbm - 20.9
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 13, test_suite , "subtraction with float" )
|
|
|
|
test_so.obj.ikg = test_so.obj.ilbm - test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 0, test_suite , "subtraction with swig_int" )
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.ikg = test_so.obj.ilbm - test_so.obj.ikg
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 12, test_suite , "subtraction with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dlbm = 10
|
|
test_so.obj.ikg = test_so.obj.ilbm - test_so.obj.dlbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 18, test_suite , "subtraction with swig_double" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.ikg = test_so.obj.ilbm - test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 12, test_suite , "subtraction with swig_double and unit conversion" )
|
|
|
|
# multiplication
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.ikg = test_so.obj.ilbm * 3
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 68, test_suite , "multiplication with int" )
|
|
|
|
test_so.obj.ikg = test_so.obj.ilbm * 2.9
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 65, test_suite , "multiplication with float" )
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.i = 2
|
|
test_so.obj.ikg = test_so.obj.ilbm * test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 45, test_suite , "multiplication with unitless swig_int" )
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.dno_units = 2.2
|
|
test_so.obj.ikg = test_so.obj.ilbm * test_so.obj.dno_units
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 49, test_suite , "multiplication with unitless swig_double" )
|
|
|
|
# division
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.ikg = test_so.obj.ilbm / 3
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 7, test_suite , "division with int" )
|
|
|
|
test_so.obj.ikg = test_so.obj.ilbm / 2.9
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 7, test_suite , "division with float" )
|
|
|
|
# floor division
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.ikg = test_so.obj.ikg // 4
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 7, test_suite , "floor division with int" )
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.ikg = test_so.obj.ikg // 4.5
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 6, test_suite , "floor division with int" )
|
|
|
|
# mod
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.ikg = test_so.obj.ikg % 4
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 1, test_suite , "mod with int" )
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.ikg = test_so.obj.ikg % 4.5
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 2, test_suite , "mod with float" )
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.i = 13
|
|
test_so.obj.ikg = test_so.obj.ilbm % test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 4, test_suite , "mod with unitless swig_int" )
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.dno_units = 13.5
|
|
test_so.obj.ikg = test_so.obj.ilbm % test_so.obj.dno_units
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 4, test_suite , "mod with unitless swig_double" )
|
|
|
|
# pow
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i = pow(test_so.obj.i , 4)
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 625, test_suite , "pow with int" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i = pow(test_so.obj.i , 2.5)
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 55, test_suite , "pow with float" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i = pow(test_so.obj.i , test_so.obj.i)
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 3125, test_suite , "pow with unitless swig_int" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.dno_units = 5.0
|
|
test_so.obj.i = pow(test_so.obj.i , test_so.obj.dno_units)
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 3125, test_suite , "pow with unitless swig_double" )
|
|
|
|
# left shift
|
|
|
|
test_so.obj.ikg = 16
|
|
test_so.obj.ikg = test_so.obj.ikg << 2
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 64, test_suite , "left shift with int" )
|
|
|
|
test_so.obj.ikg = 16
|
|
test_so.obj.i = 1
|
|
test_so.obj.ikg = test_so.obj.ikg << test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 32, test_suite , "left shift with unitless swig_int" )
|
|
|
|
# right shift
|
|
|
|
test_so.obj.ikg = 16
|
|
test_so.obj.ikg = test_so.obj.ikg >> 2
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 4, test_suite , "right shift with int" )
|
|
|
|
test_so.obj.ikg = 16
|
|
test_so.obj.i = 1
|
|
test_so.obj.ikg = test_so.obj.ikg >> test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 8, test_suite , "left shift with unitless swig_int" )
|
|
|
|
# and
|
|
|
|
test_so.obj.ikg = 12
|
|
test_so.obj.ikg = test_so.obj.ikg & 5
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 4, test_suite , "and with int" )
|
|
|
|
test_so.obj.ikg = 12
|
|
test_so.obj.i = 5
|
|
test_so.obj.ikg = test_so.obj.ikg & test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 4, test_suite , "and with unitless swig_int" )
|
|
|
|
# xor
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.ikg = test_so.obj.ikg ^ 7
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 26, test_suite , "xor with int" )
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.i = 7
|
|
test_so.obj.ikg = test_so.obj.ikg ^ test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 26, test_suite , "xor with unitless swig_int" )
|
|
|
|
# or
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.ikg = test_so.obj.ikg | 7
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 31, test_suite , "or with int" )
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.i = 7
|
|
test_so.obj.ikg = test_so.obj.ikg | test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 31, test_suite , "or with unitless swig_int" )
|
|
|
|
# reverse addition
|
|
|
|
test_so.obj.ikg = 20 + test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 31, test_suite , "reverse addition with integer" )
|
|
|
|
test_so.obj.ikg = 20.9 + test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 32, test_suite , "reverse addition with float" )
|
|
|
|
# reverse subtraction
|
|
|
|
test_so.obj.ikg = 120 - test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 31, test_suite , "reverse subtraction with integer" )
|
|
|
|
test_so.obj.ikg = 120.9 - test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 32, test_suite , "reverse subtraction with float" )
|
|
|
|
# reverse multiplication
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.ikg = 3 * test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 68, test_suite , "reverse multiplication with int" )
|
|
|
|
test_so.obj.ikg = 2.9 * test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 65, test_suite , "reverse multiplication with float" )
|
|
|
|
# reverse division
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i = 62 / test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 12, test_suite , "reverse division with int" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i = 62.5 / test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 12, test_suite , "reverse division with float" )
|
|
|
|
# reverse mod
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i = 62 % test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 2, test_suite , "reverse mod with int" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i = 62.5 % test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 2, test_suite , "reverse mod with float" )
|
|
|
|
# pow
|
|
|
|
test_so.obj.i = 4
|
|
test_so.obj.i = pow(4 , test_so.obj.i)
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 256, test_suite , "reverse pow with int" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i = pow(2.1 , test_so.obj.i)
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 40, test_suite , "reverse pow with float" )
|
|
|
|
# reverse lshift
|
|
test_so.obj.i = 3
|
|
test_so.obj.i = 8 << test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 64, test_suite , "reverse lshift with int" )
|
|
|
|
# reverse rshift
|
|
test_so.obj.i = 2
|
|
test_so.obj.i = 8 >> test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 2, test_suite , "reverse rshift with int" )
|
|
|
|
# reverse and
|
|
|
|
test_so.obj.ikg = 12
|
|
test_so.obj.ikg = 5 & test_so.obj.ikg
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 4, test_suite , "reverse and with int" )
|
|
|
|
# reverse xor
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.ikg = 7 ^ test_so.obj.ikg
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 26, test_suite , "reverse xor with int" )
|
|
|
|
# reverse or
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.ikg = 7 | test_so.obj.ikg
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 31, test_suite , "reverse or with int" )
|
|
|
|
# in-place addition
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.ikg += 20
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 30, test_suite , "in-place addition with integer" )
|
|
|
|
test_so.obj.ikg += 20.9
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 51, test_suite , "in-place addition with float" )
|
|
|
|
test_so.obj.ilbm = 10
|
|
test_so.obj.ikg += test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 55, test_suite , "in-place addition with swig_int" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.ikg += test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 65, test_suite , "in-place addition with swig_double and unit conversion" )
|
|
|
|
# in-place subtraction
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.ikg -= 2
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 8, test_suite , "in-place subtraction with integer" )
|
|
|
|
test_so.obj.ikg -= 2.9
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 5, test_suite , "in-place subtraction with float" )
|
|
|
|
test_so.obj.ilbm = 10
|
|
test_so.obj.ikg -= test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 1, test_suite , "in-place subtraction with swig_int" )
|
|
|
|
test_so.obj.dkg = 1
|
|
test_so.obj.ikg -= test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 0, test_suite , "in-place subtraction with swig_double and unit conversion" )
|
|
|
|
# in-place multiplication
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.ikg *= 2
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 20, test_suite , "in-place multiplication with integer" )
|
|
|
|
test_so.obj.ikg *= 3.9
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 78, test_suite , "in-place multiplication with float" )
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.i = 2
|
|
test_so.obj.ikg *= test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 20, test_suite , "in-place multiplication with unitless swig_int" )
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.dno_units = 3.9
|
|
test_so.obj.ikg *= test_so.obj.dno_units
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 39, test_suite , "in-place multiplication with unitless swig_double" )
|
|
# in-place division
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.ikg /= 2
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 5, test_suite , "in-place division with integer" )
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.ikg /= 3.9
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 3, test_suite , "in-place division with float" )
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.i = 2
|
|
test_so.obj.ikg /= test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 5, test_suite , "in-place division with unitless swig_int" )
|
|
|
|
# in-place mod
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.ikg %= 3
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 1, test_suite , "in-place mod with integer" )
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.ikg %= 3.9
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 2, test_suite , "in-place mod with float" )
|
|
|
|
test_so.obj.ikg = 10
|
|
test_so.obj.i = 3
|
|
test_so.obj.ikg %= test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 1, test_suite , "in-place mod with unitless swig_int" )
|
|
|
|
# in-place pow
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i **= 4
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 625, test_suite , "in-place pow with int" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i **= 2.5
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 56, test_suite , "in-place pow with float" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.i **= test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 3125, test_suite , "in-place pow with unitless swig_int" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.dno_units = 5.0
|
|
test_so.obj.i **= test_so.obj.dno_units
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 3125, test_suite , "in-place pow with unitless swig_double" )
|
|
|
|
# in-place left shift
|
|
|
|
test_so.obj.ikg = 16
|
|
test_so.obj.ikg <<= 2
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 64, test_suite , "left shift with int" )
|
|
|
|
test_so.obj.i = 16
|
|
test_so.obj.ia[0] = 1
|
|
test_so.obj.i <<= test_so.obj.ia[0]
|
|
TRICK_EXPECT_EQ( test_so.obj.i , 32, test_suite , "left shift with unitless swig_int" )
|
|
|
|
# in-place right shift
|
|
|
|
test_so.obj.ikg = 16
|
|
test_so.obj.ikg >>= 2
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 4, test_suite , "right shift with int" )
|
|
|
|
test_so.obj.ikg = 16
|
|
test_so.obj.i = 1
|
|
test_so.obj.ikg >>= test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 8, test_suite , "left shift with unitless swig_int" )
|
|
|
|
# in-place and
|
|
|
|
test_so.obj.ikg = 12
|
|
test_so.obj.ikg &= 5
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 4, test_suite , "and with int" )
|
|
|
|
test_so.obj.ikg = 12
|
|
test_so.obj.i = 5
|
|
test_so.obj.ikg &= test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 4, test_suite , "and with unitless swig_int" )
|
|
|
|
# in-place xor
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.ikg ^= 7
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 26, test_suite , "xor with int" )
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.i = 7
|
|
test_so.obj.ikg ^= test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 26, test_suite , "xor with unitless swig_int" )
|
|
|
|
# in-place or
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.ikg |= 7
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 31, test_suite , "or with int" )
|
|
|
|
test_so.obj.ikg = 29
|
|
test_so.obj.i = 7
|
|
test_so.obj.ikg |= test_so.obj.i
|
|
TRICK_EXPECT_EQ( test_so.obj.ikg , 31, test_suite , "or with unitless swig_int" )
|
|
|
|
# less than
|
|
|
|
test_so.obj.ikg = 20
|
|
test_so.obj.ilbm = 20
|
|
|
|
test = test_so.obj.ikg < 21
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "lt with integer" )
|
|
|
|
test = test_so.obj.ikg < 20.5
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "lt with float" )
|
|
|
|
test = test_so.obj.ikg < test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "lt with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.ikg < test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "lt with swig_double and unit conversion" )
|
|
|
|
# less than or equal
|
|
|
|
test_so.obj.ikg = 20
|
|
test_so.obj.ilbm = 20
|
|
|
|
test = test_so.obj.ikg <= 21
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "le with integer" )
|
|
|
|
test = test_so.obj.ikg <= 20.5
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "le with float" )
|
|
|
|
test = test_so.obj.ikg <= test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "le with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.ikg <= test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "le with swig_double and unit conversion" )
|
|
|
|
# equal
|
|
|
|
test = test_so.obj.ikg == 21
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "eq with integer" )
|
|
|
|
test = test_so.obj.ikg == 20.5
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "eq with float" )
|
|
|
|
test = test_so.obj.ikg == test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "eq with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.ikg == test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "eq with swig_double and unit conversion" )
|
|
|
|
# not equal
|
|
|
|
test = test_so.obj.ikg != 21
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "ne with integer" )
|
|
|
|
test = test_so.obj.ikg != 20.5
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "ne with float" )
|
|
|
|
test = test_so.obj.ikg != test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "ne with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.ikg != test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "ne with swig_double and unit conversion" )
|
|
|
|
# greater than
|
|
|
|
test_so.obj.ikg = 20
|
|
test_so.obj.ilbm = 20
|
|
|
|
test = test_so.obj.ikg > 21
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "gt with integer" )
|
|
|
|
test = test_so.obj.ikg > 20.5
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "gt with float" )
|
|
|
|
test = test_so.obj.ikg > test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "gt with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.ikg > test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "gt with swig_double and unit conversion" )
|
|
|
|
# greater than or equal
|
|
|
|
test_so.obj.ikg = 20
|
|
test_so.obj.ilbm = 20
|
|
|
|
test = test_so.obj.ikg >= 21
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "ge with integer" )
|
|
|
|
test = test_so.obj.ikg >= 20.5
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "ge with float" )
|
|
|
|
test = test_so.obj.ikg >= test_so.obj.ilbm
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "ge with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.ikg >= test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "ge with swig_double and unit conversion" )
|
|
|
|
# unary operators
|
|
|
|
test_so.obj.ikg = 20
|
|
test = -test_so.obj.ikg
|
|
TRICK_EXPECT_EQ( test , -20, test_suite , "unary neg" )
|
|
|
|
test = +test_so.obj.ikg
|
|
TRICK_EXPECT_EQ( test , 20, test_suite , "unary pos" )
|
|
|
|
test_so.obj.ikg = -20
|
|
test = abs(test_so.obj.ikg)
|
|
TRICK_EXPECT_EQ( test , 20, test_suite , "unary abs" )
|
|
|
|
test_so.obj.ikg = 20
|
|
test = ~test_so.obj.ikg
|
|
TRICK_EXPECT_EQ( test , -21, test_suite , "unary invert" )
|
|
|
|
# conversion
|
|
test_so.obj.ikg = 20
|
|
test = int(test_so.obj.ikg)
|
|
TRICK_EXPECT_EQ( test , 20, test_suite , "int" )
|
|
|
|
if sys.version_info < (3,0):
|
|
test_so.obj.ikg = 20
|
|
test = long(test_so.obj.ikg)
|
|
TRICK_EXPECT_EQ( test , 20, test_suite , "long" )
|
|
|
|
test_so.obj.ikg = 20
|
|
test = float(test_so.obj.ikg)
|
|
TRICK_EXPECT_EQ( test , 20, test_suite , "float" )
|
|
|
|
test_so.obj.ikg = 20
|
|
test = oct(test_so.obj.ikg)
|
|
if sys.version_info >= (3,0):
|
|
TRICK_EXPECT_EQ( test , "0o24", test_suite , "oct" )
|
|
else:
|
|
TRICK_EXPECT_EQ( test , "024", test_suite , "oct" )
|
|
|
|
test_so.obj.ikg = 20
|
|
test = hex(test_so.obj.ikg)
|
|
TRICK_EXPECT_EQ( test , "0x14", test_suite , "hex" )
|
|
|
|
######################################################################################################################
|
|
|
|
# swig_integer to swig_double assignment
|
|
test_suite = "swig_double"
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.dlbm = test_so.obj.ilbm
|
|
|
|
# swig_double unitless to swig_double assignment
|
|
|
|
test_so.obj.dno_units = trick.attach_units("--" , 60.6)
|
|
TRICK_EXPECT_EQ( test_so.obj.dno_units , 60.6, test_suite , "assignment from unitless swig_double" )
|
|
trick.trick_test_add_parent( test_suite , "assignment from unitless swig_double" , "1164062396")
|
|
|
|
# addition
|
|
|
|
test_so.obj.dlbm = 50
|
|
test_so.obj.dkg = test_so.obj.dlbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 22.6796, 0.0001, test_suite , "units conversion" )
|
|
|
|
test_so.obj.dkg = test_so.obj.dlbm + 20
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 31.7515, 0.0001, test_suite , "addition with integer" )
|
|
|
|
test_so.obj.dkg = test_so.obj.dlbm + 20.9
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 32.1597, 0.0001, test_suite , "addition with float" )
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.dkg = test_so.obj.dlbm + test_so.obj.ilbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 45.3592, 0.0001, test_suite , "addition with swig_int" )
|
|
|
|
test_so.obj.dkg = 50
|
|
test_so.obj.ikg = 50
|
|
test_so.obj.dkg = test_so.obj.dlbm + test_so.obj.ikg
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 72.6796, 0.0001, test_suite , "addition with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dlbm = 10
|
|
test_so.obj.dkg = test_so.obj.dlbm + test_so.obj.dlbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 9.07185, 0.0001, test_suite , "addition with swig_double" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.dkg = test_so.obj.dlbm + test_so.obj.dkg
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 14.5359, 0.0001, test_suite , "addition with swig_double and unit conversion" )
|
|
|
|
# subtraction
|
|
|
|
test_so.obj.dlbm = 50
|
|
test_so.obj.dkg = test_so.obj.dlbm - 20
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 13.6078, 0.0001, test_suite , "subtraction with integer" )
|
|
|
|
test_so.obj.dkg = test_so.obj.dlbm - 20.9
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 13.1995, 0.0001, test_suite , "subtraction with float" )
|
|
|
|
test_so.obj.ilbm = 50
|
|
test_so.obj.dkg = test_so.obj.dlbm - test_so.obj.ilbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 0, 0.0001, test_suite , "subtraction with swig_int" )
|
|
|
|
test_so.obj.dkg = 50
|
|
test_so.obj.ikg = 50
|
|
test_so.obj.dkg = test_so.obj.dlbm - test_so.obj.ikg
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , -27.3204, 0.0001, test_suite , "subtraction with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dlbm = 10
|
|
test_so.obj.dkg = test_so.obj.dlbm - test_so.obj.dlbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 0, 0.0001, test_suite , "subtraction with swig_double" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.dkg = test_so.obj.dlbm - test_so.obj.dkg
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , -5.46408, 0.0001, test_suite , "subtraction with swig_double and unit conversion" )
|
|
|
|
# multiplication
|
|
|
|
test_so.obj.dlbm = 50
|
|
test_so.obj.dkg = test_so.obj.dlbm * 3
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 68.0389, 0.0001, test_suite , "multiplication with int" )
|
|
|
|
test_so.obj.dkg = test_so.obj.ilbm * 2.9
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 65.7709, 0.0001, test_suite , "multiplication with float" )
|
|
|
|
test_so.obj.dlbm = 50
|
|
test_so.obj.i = 2
|
|
test_so.obj.dkg = test_so.obj.dlbm * test_so.obj.i
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 45.3592, 0.0001, test_suite , "multiplication with unitless swig_int" )
|
|
|
|
test_so.obj.dlbm = 50
|
|
test_so.obj.dno_units = 2.2
|
|
test_so.obj.dkg = test_so.obj.dlbm * test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 49.8952, 0.0001, test_suite , "multiplication with unitless swig_double" )
|
|
|
|
# division
|
|
|
|
test_so.obj.dlbm = 50
|
|
test_so.obj.dkg = test_so.obj.dlbm / 3
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 7.55987, 0.0001, test_suite , "division with int" )
|
|
|
|
test_so.obj.dkg = test_so.obj.dlbm / 2.9
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 7.82056, 0.0001, test_suite , "division with float" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.dkg = test_so.obj.dlbm / test_so.obj.i
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 4.53592, 0.0001, test_suite , "division with unitless swig_int" )
|
|
|
|
test_so.obj.dno_units = 5.1
|
|
test_so.obj.dkg = test_so.obj.dlbm / test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 4.44698, 0.0001, test_suite , "division with unitless swig_double" )
|
|
|
|
# floor division
|
|
|
|
test_so.obj.dkg = 29
|
|
test_so.obj.dkg = test_so.obj.dkg // 4
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 7, 0.0001, test_suite , "floor division with int" )
|
|
|
|
test_so.obj.dkg = 29
|
|
test_so.obj.dkg = test_so.obj.dkg // 4.5
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 6, 0.0001, test_suite , "floor division with float" )
|
|
|
|
test_so.obj.dkg = 29
|
|
test_so.obj.i = 4
|
|
test_so.obj.dkg = test_so.obj.dkg // test_so.obj.i
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 7, 0.0001, test_suite , "floor division with unitless swig_int" )
|
|
|
|
test_so.obj.dkg = 29
|
|
test_so.obj.dno_units = 4.5
|
|
test_so.obj.dkg = test_so.obj.dkg // test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 6, 0.0001, test_suite , "floor division with unitless swig_double" )
|
|
|
|
|
|
# mod
|
|
|
|
test_so.obj.dkg = 29
|
|
test_so.obj.dkg = test_so.obj.dkg % 4
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 1, 0.0001, test_suite , "mod with int" )
|
|
|
|
test_so.obj.dkg = 29
|
|
test_so.obj.dkg = test_so.obj.dkg % 4.5
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 2, 0.0001, test_suite , "mod with float" )
|
|
|
|
test_so.obj.dlbm = 50
|
|
test_so.obj.i = 13
|
|
test_so.obj.dlbm = test_so.obj.dlbm % test_so.obj.i
|
|
TRICK_EXPECT_NEAR( test_so.obj.dlbm , 11, 0.0001, test_suite , "mod with unitless swig_int" )
|
|
|
|
test_so.obj.dlbm = 50
|
|
test_so.obj.dno_units = 13.5
|
|
test_so.obj.dlbm = test_so.obj.dlbm % test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dlbm , 9.5, 0.0001, test_suite , "mod with unitless swig_double" )
|
|
|
|
# pow
|
|
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units = pow(test_so.obj.dno_units , 4)
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 625, 0.0001, test_suite , "pow with int" )
|
|
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units = pow(test_so.obj.dno_units , 2.5)
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 55.9017, 0.0001, test_suite , "pow with float" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.dno_units = 5.0
|
|
test_so.obj.dno_units = pow(test_so.obj.dno_units , test_so.obj.i)
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 3125, 0.0001, test_suite , "pow with unitless swig_int" )
|
|
|
|
test_so.obj.dno_units = 5.0
|
|
test_so.obj.dno_units = pow(test_so.obj.dno_units , test_so.obj.dno_units)
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 3125, 0.0001, test_suite , "pow with unitless swig_double" )
|
|
|
|
# reverse addition
|
|
|
|
test_so.obj.dlbm = 10
|
|
test_so.obj.dkg = 20 + test_so.obj.dlbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 13.6078, 0.0001, test_suite , "reverse addition with integer" )
|
|
|
|
test_so.obj.dkg = 20.9 + test_so.obj.dlbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 14.016, 0.0001, test_suite , "reverse addition with float" )
|
|
|
|
# reverse subtraction
|
|
|
|
test_so.obj.dkg = 120 - test_so.obj.dlbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 49.8952, 0.0001, test_suite , "reverse subtraction with integer" )
|
|
|
|
test_so.obj.dkg = 120.9 - test_so.obj.dlbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 50.3034, 0.0001, test_suite , "reverse subtraction with float" )
|
|
|
|
# reverse multiplication
|
|
|
|
test_so.obj.dlbm = 50
|
|
test_so.obj.dkg = 3 * test_so.obj.dlbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 68.0389, 0.0001, test_suite , "reverse multiplication with int" )
|
|
|
|
test_so.obj.dkg = 2.9 * test_so.obj.dlbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 65.7709, 0.0001, test_suite , "reverse multiplication with float" )
|
|
|
|
|
|
# reverse division
|
|
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units = 62 / test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 12.4, 0.0001, test_suite , "reverse division with int" )
|
|
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units = 62.5 / test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 12.5, 0.0001, test_suite , "reverse division with float" )
|
|
|
|
# reverse floor division
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units = 62 // test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 12, 0.0001, test_suite , "reverse floor division with int" )
|
|
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units = 62.5 // test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 12, 0.0001, test_suite , "reverse floor division with float" )
|
|
|
|
|
|
# reverse mod
|
|
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units = 62 % test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 2, 0.0001, test_suite , "reverse mod with int" )
|
|
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units = 62.5 % test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 2.5, 0.0001, test_suite , "reverse mod with float" )
|
|
|
|
# reverse pow
|
|
|
|
test_so.obj.dno_units = 4
|
|
test_so.obj.dno_units = pow(4 , test_so.obj.dno_units)
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 256, 0.0001, test_suite , "reverse pow with int" )
|
|
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units = pow(2.1 , test_so.obj.dno_units)
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 40.841 , 0.0001, test_suite , "reverse pow with float" )
|
|
|
|
# in-place addition
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.dkg += 20
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 30, 0.0001, test_suite , "in-place addition with integer" )
|
|
|
|
test_so.obj.dkg += 20.9
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 50.9, 0.0001, test_suite , "in-place addition with float" )
|
|
|
|
test_so.obj.ilbm = 10
|
|
test_so.obj.dkg += test_so.obj.ilbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 55.4359, 0.0001, test_suite , "in-place addition with swig_int" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.dkg += test_so.obj.dkg
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 20, 0.0001, test_suite , "in-place addition with swig_double and unit conversion" )
|
|
|
|
# in-place subtraction
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.dkg -= 2
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 8, 0.0001, test_suite , "in-place subtraction with integer" )
|
|
|
|
test_so.obj.dkg -= 2.9
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 5.1, 0.0001, test_suite , "in-place subtraction with float" )
|
|
|
|
test_so.obj.dlbm = 10
|
|
test_so.obj.dkg -= test_so.obj.dlbm
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 0.564076, 0.0001, test_suite , "in-place subtraction with swig_int" )
|
|
|
|
test_so.obj.dkg = 1
|
|
test_so.obj.dkg -= test_so.obj.dkg
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 0, 0.0001, test_suite , "in-place subtraction with swig_double and unit conversion" )
|
|
|
|
# in-place multiplication
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.dkg *= 2
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 20, 0.0001, test_suite , "in-place multiplication with integer" )
|
|
|
|
test_so.obj.dkg *= 3.9
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 78, 0.0001, test_suite , "in-place multiplication with float" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.i = 2
|
|
test_so.obj.dkg *= test_so.obj.i
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 20, 0.0001, test_suite , "in-place multiplication with unitless swig_int" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.dno_units = 2
|
|
test_so.obj.dkg *= test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 20, 0.0001, test_suite , "in-place multiplication with unitless swig_int" )
|
|
|
|
# in-place division
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.dkg /= 2
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 5, 0.0001, test_suite , "in-place division with integer" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.dkg /= 3.9
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 2.5641, 0.0001, test_suite , "in-place division with float" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.i = 2
|
|
test_so.obj.dkg /= test_so.obj.i
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 5, 0.0001, test_suite , "in-place division with unitless swig_int" )
|
|
|
|
test_so.obj.dkg = 10
|
|
test_so.obj.dno_units = 2
|
|
test_so.obj.dkg /= test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 5, 0.0001, test_suite , "in-place division with unitless swig_int" )
|
|
|
|
# in-place floor division
|
|
|
|
test_so.obj.dkg = 10.1
|
|
test_so.obj.dkg //= 2
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 5, 0.0001, test_suite , "in-place division with integer" )
|
|
|
|
test_so.obj.dkg = 10.1
|
|
test_so.obj.dkg //= 3.9
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 2, 0.0001, test_suite , "in-place division with float" )
|
|
|
|
test_so.obj.dkg = 10.1
|
|
test_so.obj.i = 2
|
|
test_so.obj.dkg //= test_so.obj.i
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 5, 0.0001, test_suite , "in-place division with unitless swig_int" )
|
|
|
|
test_so.obj.dkg = 10.1
|
|
test_so.obj.dno_units = 2
|
|
test_so.obj.dkg //= test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 5, 0.0001, test_suite , "in-place division with unitless swig_int" )
|
|
|
|
# in-place mod
|
|
|
|
test_so.obj.dkg = 10.1
|
|
test_so.obj.dkg %= 3
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 1.1, 0.0001, test_suite , "in-place mod with integer" )
|
|
|
|
test_so.obj.dkg = 10.1
|
|
test_so.obj.dkg %= 3.9
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 2.3, 0.0001, test_suite , "in-place mod with float" )
|
|
|
|
test_so.obj.dkg = 10.1
|
|
test_so.obj.i = 3
|
|
test_so.obj.dkg %= test_so.obj.i
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 1.1, 0.0001, test_suite , "in-place mod with unitless swig_int" )
|
|
|
|
test_so.obj.dkg = 10.1
|
|
test_so.obj.dno_units = 4
|
|
test_so.obj.dkg %= test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dkg , 2.1, 0.0001, test_suite , "in-place mod with unitless swig_double" )
|
|
|
|
# in-place pow
|
|
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units **= 4
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 625, 0.0001, test_suite , "in-place pow with int" )
|
|
|
|
test_so.obj.dno_units = 5
|
|
test_so.obj.dno_units **= 2.5
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 55.9017, 0.0001, test_suite , "in-place pow with float" )
|
|
|
|
test_so.obj.i = 5
|
|
test_so.obj.dno_units = 5.0
|
|
test_so.obj.dno_units **= test_so.obj.i
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 3125, 0.0001, test_suite , "in-place pow with unitless swig_int" )
|
|
|
|
test_so.obj.dno_units = 5.0
|
|
test_so.obj.dno_units **= test_so.obj.dno_units
|
|
TRICK_EXPECT_NEAR( test_so.obj.dno_units , 3125, 0.0001, test_suite , "in-place pow with unitless swig_double" )
|
|
|
|
# less than
|
|
|
|
test_so.obj.dkg = 20
|
|
test_so.obj.dlbm = 20
|
|
|
|
test = test_so.obj.dkg < 21
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "lt with integer" )
|
|
|
|
test = test_so.obj.dkg < 20.5
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "lt with float" )
|
|
|
|
test = test_so.obj.dkg < test_so.obj.dlbm
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "lt with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.dkg < test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "lt with swig_double and unit conversion" )
|
|
|
|
# less than or equal
|
|
|
|
test_so.obj.dkg = 20
|
|
test_so.obj.dlbm = 20
|
|
|
|
test = test_so.obj.dkg <= 21
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "le with integer" )
|
|
|
|
test = test_so.obj.dkg <= 20.5
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "le with float" )
|
|
|
|
test = test_so.obj.dkg <= test_so.obj.dlbm
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "le with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.dkg <= test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "le with swig_double and unit conversion" )
|
|
|
|
# equal
|
|
|
|
test = test_so.obj.dkg == 21
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "eq with integer" )
|
|
|
|
test = test_so.obj.dkg == 20.5
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "eq with float" )
|
|
|
|
test = test_so.obj.dkg == test_so.obj.dlbm
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "eq with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.dkg == test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "eq with swig_double and unit conversion" )
|
|
|
|
# not equal
|
|
|
|
test = test_so.obj.dkg != 21
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "ne with integer" )
|
|
|
|
test = test_so.obj.dkg != 20.5
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "ne with float" )
|
|
|
|
test = test_so.obj.dkg != test_so.obj.dlbm
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "ne with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.dkg != test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "ne with swig_double and unit conversion" )
|
|
|
|
# greater than
|
|
|
|
test_so.obj.dkg = 20
|
|
test_so.obj.dlbm = 20
|
|
|
|
test = test_so.obj.dkg > 21
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "gt with integer" )
|
|
|
|
test = test_so.obj.dkg > 20.5
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "gt with float" )
|
|
|
|
test = test_so.obj.dkg > test_so.obj.dlbm
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "gt with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.dkg > test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "gt with swig_double and unit conversion" )
|
|
|
|
# greater than or equal
|
|
|
|
test_so.obj.dkg = 20
|
|
test_so.obj.dlbm = 20
|
|
|
|
test = test_so.obj.dkg >= 21
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "ge with integer" )
|
|
|
|
test = test_so.obj.dkg >= 20.5
|
|
TRICK_EXPECT_EQ( test , False, test_suite , "ge with float" )
|
|
|
|
test = test_so.obj.dkg >= test_so.obj.dlbm
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "ge with swig_int and unit conversion" )
|
|
|
|
test_so.obj.dkg = 20.1
|
|
test = test_so.obj.dkg >= test_so.obj.dkg
|
|
TRICK_EXPECT_EQ( test , True, test_suite , "ge with swig_double and unit conversion" )
|
|
|
|
# unary operators
|
|
|
|
test_so.obj.dkg = 20
|
|
test = -test_so.obj.dkg
|
|
TRICK_EXPECT_NEAR( test , -20, 0.0001, test_suite , "unary neg" )
|
|
|
|
test = +test_so.obj.dkg
|
|
TRICK_EXPECT_NEAR( test , 20, 0.0001, test_suite , "unary pos" )
|
|
|
|
test_so.obj.dkg = -20
|
|
test = abs(test_so.obj.dkg)
|
|
TRICK_EXPECT_NEAR( test , 20, 0.0001, test_suite , "unary abs" )
|
|
|
|
# conversion
|
|
test_so.obj.dkg = 20
|
|
test = int(test_so.obj.dkg)
|
|
TRICK_EXPECT_NEAR( test , 20, 0.0001, test_suite , "int" )
|
|
|
|
if sys.version_info < (3,0):
|
|
test_so.obj.dkg = 20
|
|
test = long(test_so.obj.dkg)
|
|
TRICK_EXPECT_NEAR( test , 20, 0.0001, test_suite , "long" )
|
|
|
|
test_so.obj.dkg = 20
|
|
test = float(test_so.obj.dkg)
|
|
TRICK_EXPECT_NEAR( test , 20, 0.0001, test_suite , "float" )
|
|
|
|
######################################################################################################################
|
|
|
|
# Typedefed integers
|
|
test_suite = "typedef"
|
|
|
|
test_so.obj.i = 40
|
|
test_so.obj.iii = test_so.obj.i
|
|
test_so.obj.aiii = test_so.obj.iii
|
|
|
|
TRICK_EXPECT_EQ( test_so.obj.iii , 40, test_suite , "integer from integer" )
|
|
trick.trick_test_add_parent( test_suite , "integer from integer" , "1011083320")
|
|
TRICK_EXPECT_EQ( test_so.obj.aiii , 40, test_suite , "integer from another typedefed integer" )
|
|
trick.trick_test_add_parent( test_suite , "integer from another typedefed integer" , "1011083320")
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "structure"
|
|
|
|
# Structs with more than one name
|
|
test_so.t.i = 300
|
|
TRICK_EXPECT_EQ( test_so.t.i , 300, test_suite , "multi named structure no unit assignment" )
|
|
|
|
test_so.t.i = trick.attach_units("in", 300)
|
|
TRICK_EXPECT_EQ( test_so.t.i , 7, test_suite , "multi named structure with unit assignment" )
|
|
|
|
test_so.t.d = 300
|
|
TRICK_EXPECT_NEAR( test_so.t.d , 300, 0.0001 , test_suite , "multi named structure no unit assignment" )
|
|
|
|
test_so.t.d = trick.attach_units("in", 300)
|
|
TRICK_EXPECT_NEAR( test_so.t.d , 7.62 , 0.0001 , test_suite , "multi named structure with unit assignment" )
|
|
|
|
######################################################################################################################
|
|
|
|
# Templates
|
|
test_suite = "template"
|
|
|
|
# simple template
|
|
test_so.obj.my_template_var.var1 = 30.0
|
|
test_so.obj.my_template_var.var2 = 40
|
|
test_so.obj.my_template_var.var3 = 50
|
|
TRICK_EXPECT_NEAR( test_so.obj.my_template_var.var1 , 30.0 , 0.000001 , test_suite , "double assignment" )
|
|
TRICK_EXPECT_EQ( test_so.obj.my_template_var.var2 , 40 , test_suite , "int assignment" )
|
|
TRICK_EXPECT_EQ( test_so.obj.my_template_var.var3 , 50 , test_suite , "short assignment" )
|
|
trick.trick_test_add_parent( test_suite , "double assignment" , "2642836719")
|
|
trick.trick_test_add_parent( test_suite , "int assignment" , "2642836719")
|
|
trick.trick_test_add_parent( test_suite , "short assignment" , "2642836719")
|
|
|
|
|
|
# using typedef from within template
|
|
test_so.obj.my_template_var_int = 66
|
|
TRICK_EXPECT_EQ( test_so.obj.my_template_var_int , 66, test_suite , "use typedef from within a template" )
|
|
|
|
# a more convoluted template
|
|
test_so.obj.TTT_var.aa = 1000
|
|
TRICK_EXPECT_EQ( test_so.obj.TTT_var.aa , 1000, test_suite , "class complicated integer" )
|
|
|
|
test_so.obj.TTT_var.bb = 2000.0
|
|
TRICK_EXPECT_NEAR( test_so.obj.TTT_var.bb , 2000, 0.0001, test_suite , "class complicated double" )
|
|
|
|
######################################################################################################################
|
|
|
|
# Namespace
|
|
test_suite = "namespace"
|
|
|
|
test_so.ns_test.mass = trick.attach_units("lb", 10)
|
|
TRICK_EXPECT_NEAR( test_so.ns_test.mass , 4.53592, 0.0001, test_suite , "Class variable with units" )
|
|
trick.trick_test_add_parent( test_suite , "Class variable with units" , "2546878004")
|
|
|
|
test_so.ns_test.bbp = trick.alloc_type(2, "my_ns::BB")
|
|
test_so.ns_test.bbp[0].str = "hello"
|
|
test_so.ns_test.bbp[1].str = "there"
|
|
temp = test_so.ns_test.bbp[0].str + " " + test_so.ns_test.bbp[1].str
|
|
TRICK_EXPECT_EQ( str(temp) , "hello there", test_suite , "1D Class allocation" )
|
|
trick.trick_test_add_parent( test_suite , "1D Class allocation" , "2546878004")
|
|
|
|
test_so.ns_test.bbpp = trick.alloc_type(4, "my_ns::BB *")
|
|
test_so.ns_test.bbpp[0] = trick.alloc_type(3, "my_ns::BB")
|
|
test_so.ns_test.bbpp[0][0].str = "bark"
|
|
test_so.ns_test.bbpp[0][1].str = "meow"
|
|
test_so.ns_test.bbpp[0][2].str = "quack"
|
|
temp = test_so.ns_test.bbpp[0][0].str + " " + test_so.ns_test.bbpp[0][1].str + " " + test_so.ns_test.bbpp[0][2].str
|
|
TRICK_EXPECT_EQ( str(temp) , "bark meow quack", test_suite , "2D Class allocation" )
|
|
trick.trick_test_add_parent( test_suite , "2D Class allocation" , "2546878004")
|
|
|
|
######################################################################################################################
|
|
|
|
# Miscellaneous
|
|
test_suite = "misc"
|
|
|
|
test_so.obj.d = 10
|
|
test_so.obj.ds = 15
|
|
temp = test_so.obj.d + float(test_so.obj.ds)
|
|
TRICK_EXPECT_NEAR( temp , 25 , 0.0001 , test_suite , "Forced remove units" )
|
|
trick.trick_test_add_parent( test_suite , "Forced remove units" , "3339258059")
|
|
|
|
temp = [ test_so.obj.d , test_so.obj.ds ]
|
|
TRICK_EXPECT_EQ( str(temp) , "[10 kg, 15 s]", test_suite , "List with different objects" )
|
|
|
|
test_so.obj.dp = trick.get_address("test_so.obj.d")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dp) , "[10 kg]", test_suite , "Get address" )
|
|
|
|
test_so.obj.d += 1
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dp) , "[11 kg]", test_suite , "Get address verification" )
|
|
|
|
test_so.obj.da[2] = 45
|
|
test_so.obj.dp = trick.get_address("test_so.obj.da[2]")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dp) , "[45 kg]", test_suite , "Get address mid-array" )
|
|
|
|
test_so.obj.dp = trick.get_address("test_so.obj.daa[1][1]")
|
|
TRICK_EXPECT_EQ( str(test_so.obj.dp) , "[60 kg]", test_suite , "Get address multi-dimensional mid-array" )
|
|
|
|
temp_array = test_so.obj.daa[1]
|
|
TRICK_EXPECT_EQ( str(temp_array) , "[50.1 kg, 60 kg, 52.3 kg]", test_suite , "Local variable reference to array" )
|
|
|
|
# "const int & cir" and "int const & icr" are pointed to i in the Ball_alex constructor
|
|
test_so.obj.i = 55
|
|
TRICK_EXPECT_EQ( test_so.obj.cir , 55, test_suite , "Const reference" )
|
|
TRICK_EXPECT_EQ( test_so.obj.icr , 55, test_suite , "Const reference" )
|
|
|
|
#test_so.obj.cir = 99
|
|
#TRICK_EXPECT_EQ( test_so.obj.cir , 55, test_suite , "Const reference immutable test 1" )
|
|
#TRICK_EXPECT_EQ( test_so.obj.icr , 55, test_suite , "Const reference immutable test 1" )
|
|
|
|
#test_so.obj.icr = 98
|
|
#TRICK_EXPECT_EQ( test_so.obj.cir , 55, test_suite , "Const reference immutable test 2" )
|
|
#TRICK_EXPECT_EQ( test_so.obj.icr , 55, test_suite , "Const reference immutable test 2" )
|
|
|
|
test_so.obj.iiia = [ 300 , 400 , 500 , 600 , 700 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.iiia) , "[300, 400, 500, 600, 700, 0]", test_suite , "Typedeffed integer type" )
|
|
|
|
# scd = static const double, csd = const static double, sdc = static double const
|
|
TRICK_EXPECT_NEAR( test_so.obj.scd , 1.2345 , 0.0001 , test_suite , "Static const access" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.csd , 6.7890 , 0.0001 , test_suite , "Static const access" )
|
|
TRICK_EXPECT_NEAR( test_so.obj.sdc , 9.8765 , 0.0001 , test_suite , "Static const access" )
|
|
|
|
# Attempt to change a static const double
|
|
#test_so.obj.scd = 90.0 ;
|
|
#TRICK_EXPECT_NEAR( test_so.obj.scd , 1.2345 , 0.0001 , test_suite , "Static const immutable test 1" )
|
|
#trick_mm.mmw.mm.read_checkpoint_from_string("test_so.obj.scd = 2.2222 ;")
|
|
#TRICK_EXPECT_NEAR( test_so.obj.scd , 1.2345 , 0.0001 , test_suite , "Static const immutable test 2" )
|
|
#test_so.obj.csd = 90.0 ;
|
|
#TRICK_EXPECT_NEAR( test_so.obj.csd , 6.7890 , 0.0001 , test_suite , "Static const immutable test 3" )
|
|
#trick_mm.mmw.mm.read_checkpoint_from_string("test_so.obj.csd = 2.2222 ;")
|
|
#TRICK_EXPECT_NEAR( test_so.obj.csd , 6.7890 , 0.0001 , test_suite , "Static const immutable test 4" )
|
|
#test_so.obj.sdc = 90.0 ;
|
|
#TRICK_EXPECT_NEAR( test_so.obj.sdc , 9.8765 , 0.0001 , test_suite , "Static const immutable test 5" )
|
|
#trick_mm.mmw.mm.read_checkpoint_from_string("test_so.obj.sdc = 2.2222 ;")
|
|
#TRICK_EXPECT_NEAR( test_so.obj.sdc , 9.8765 , 0.0001 , test_suite , "Static const immutable test 6" )
|
|
|
|
tester = trick.Test()
|
|
output = tester.foo()
|
|
TRICK_EXPECT_EQ( output , "called foo", test_suite , "Instantiate class and capture return value" )
|
|
|
|
tester.t = trick.Test()
|
|
output = tester.t.foo()
|
|
TRICK_EXPECT_EQ( output , "called foo", test_suite , "Instantiate class pointer within class and capture return value" )
|
|
|
|
######################################################################################################################
|
|
|
|
# Standard typedeffed integer types
|
|
test_suite = "typedef_ints"
|
|
|
|
test_so.obj.i8t = 70 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.i8t , 70, test_suite , "int8_t" )
|
|
trick.trick_test_add_parent( test_suite , "int8_t" , "2939597198")
|
|
|
|
test_so.obj.ui8t = 71 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.ui8t , 71, test_suite , "uint8_t" )
|
|
|
|
test_so.obj.i16t = 80 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.i16t , 80, test_suite , "int16_t" )
|
|
|
|
test_so.obj.ui16t = 81 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.ui16t , 81, test_suite , "uint16_t" )
|
|
|
|
test_so.obj.i32t = 90 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.i32t , 90, test_suite , "int32_t" )
|
|
|
|
test_so.obj.ui32t = 91 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.ui32t , 91, test_suite , "uint32_t" )
|
|
|
|
test_so.obj.i64t = 100 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.i64t , 100, test_suite , "int64_t" )
|
|
|
|
test_so.obj.ui64t = 101 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.ui64t , 101, test_suite , "uint64_t" )
|
|
|
|
test_so.obj.sizet = 111 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.sizet , 111, test_suite , "size_t" )
|
|
|
|
test_so.obj.u_c = 121 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.u_c , 121, test_suite , "u_char" )
|
|
|
|
test_so.obj.u_s = 131 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.u_s , 131, test_suite , "u_short" )
|
|
|
|
test_so.obj.u_i = 141 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.u_i , 141, test_suite , "u_int" )
|
|
|
|
test_so.obj.u_l = 151 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.u_l , 151, test_suite , "u_long" )
|
|
|
|
test_so.obj.q = 161 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.q , 161, test_suite , "quad_t" )
|
|
|
|
test_so.obj.uq = 171 ;
|
|
TRICK_EXPECT_EQ( test_so.obj.uq , 171, test_suite , "u_quad_t" )
|
|
|
|
######################################################################################################################
|
|
|
|
# Exceptions
|
|
|
|
test_suite = "exception"
|
|
|
|
test_case = "Array index out of bounds"
|
|
try:
|
|
test_so.obj.da[5] = 2.0
|
|
trick.add_test_result( test_suite , test_case , "TRICK_EXPECT_EXCEPTION not tripped")
|
|
except:
|
|
trick.add_test_result( test_suite , test_case , "")
|
|
|
|
test_case = "Double dimension array first index out of bounds"
|
|
try:
|
|
test_so.obj.daa[20][0] = 2.0
|
|
trick.add_test_result( test_suite , test_case , "TRICK_EXPECT_EXCEPTION not tripped")
|
|
except:
|
|
trick.add_test_result( test_suite , test_case , "")
|
|
|
|
test_case = "Double dimension array second index out of bounds"
|
|
try:
|
|
test_so.obj.daa[0][20] = 2.0
|
|
trick.add_test_result( test_suite , test_case , "TRICK_EXPECT_EXCEPTION not tripped")
|
|
except:
|
|
trick.add_test_result( test_suite , test_case , "")
|
|
|
|
test_case = "String too long"
|
|
try:
|
|
test_so.obj.ca = "dfjdslfjdsajfldjalfjdslafjdlsajfdsd"
|
|
trick.add_test_result( test_suite , test_case , "TRICK_EXPECT_EXCEPTION not tripped")
|
|
except:
|
|
trick.add_test_result( test_suite , test_case , "")
|
|
|
|
test_case = "Units mismatch"
|
|
try:
|
|
test_so.obj.da[2] = trick.attach_units("s" , 2.0)
|
|
trick.add_test_result( test_suite , test_case , "TRICK_EXPECT_EXCEPTION not tripped")
|
|
except:
|
|
trick.add_test_result( test_suite , test_case , "")
|
|
|
|
test_case = "unit-ed value assigned to unitless variable"
|
|
try:
|
|
test_so.obj.dno_units = trick.attach_units("in" , 60.6)
|
|
trick.add_test_result( test_suite , test_case , "TRICK_EXPECT_EXCEPTION not tripped")
|
|
except:
|
|
trick.add_test_result( test_suite , test_case , "")
|
|
|
|
test_case = "unit-ed value assigned to unitless integer array variable"
|
|
try:
|
|
test_so.obj.ia = trick.attach_units("in" , [60, 70])
|
|
trick.add_test_result( test_suite , test_case , "TRICK_EXPECT_EXCEPTION not tripped")
|
|
except:
|
|
trick.add_test_result( test_suite , test_case , "")
|
|
|
|
test_case = "unit-ed value assigned to unitless integer pointer variable"
|
|
try:
|
|
test_so.obj.ip = trick.attach_units("in" , [60, 70])
|
|
trick.add_test_result( test_suite , test_case , "TRICK_EXPECT_EXCEPTION not tripped")
|
|
except:
|
|
trick.add_test_result( test_suite , test_case , "")
|
|
|
|
######################################################################################################################
|
|
|
|
# Polymorphic assignments and access
|
|
test_suite = "polymorphism"
|
|
|
|
#test_so.a = trick.Cat()
|
|
# use MM to allocate memory for a pointer declared in S_define
|
|
test_so.a = trick.TMM_declare_var_s("Cat")
|
|
TRICK_EXPECT_EQ( test_so.a.id , 1, test_suite , "single abstract ptr" )
|
|
trick.trick_test_add_parent( test_suite , "single abstract ptr" , "1770735610")
|
|
#test_so.a.speak()
|
|
#test_so.a[0].speak()
|
|
#test_so.a = trick.Dog()
|
|
# use MM to allocate memory for a pointer declared in S_define
|
|
test_so.a = trick.TMM_declare_var_s("Dog")
|
|
TRICK_EXPECT_EQ( test_so.a.id , 2, test_suite , "single abstract ptr" )
|
|
|
|
test_so.aarray[0] = trick.Cat()
|
|
test_so.aarray[1] = trick.Dog()
|
|
ids = [ test_so.aarray[0].id , test_so.aarray[1].id ]
|
|
TRICK_EXPECT_EQ( str(ids), "[1, 2]", test_suite , "fixed array of abstract ptrs" )
|
|
#test_so.aarray[0].speak()
|
|
#test_so.aarray[1].speak()
|
|
|
|
test_so.alist = trick.TMM_declare_var_1d("Abstract *", 4)
|
|
|
|
test_so.alist[0] = trick.TMM_declare_var_s("Cat")
|
|
test_so.alist[1] = trick.TMM_declare_var_s("Dog")
|
|
test_so.alist[2] = trick.Cat()
|
|
test_so.alist[3] = trick.Dog()
|
|
ids = [ test_so.alist[0].id , test_so.alist[1].id , test_so.alist[2].id , test_so.alist[3].id ]
|
|
TRICK_EXPECT_EQ( str(ids), "[1, 2, 1, 2]", test_suite , "fixed array of abstract ptrs" )
|
|
#test_so.alist[0].speak()
|
|
#test_so.alist[1].speak()
|
|
#test_so.alist[2].speak()
|
|
#test_so.alist[3].speak()
|
|
|
|
# test vector of abstract pointers
|
|
new_cat = trick.TMM_declare_var(trick.TRICK_STRUCTURED,"Cat",0,"my_cat",0,None)
|
|
test_so.vap.push_back(new_cat)
|
|
TRICK_EXPECT_EQ( test_so.vap[0].id , 1, test_suite , "std::vector of abstract ptrs" )
|
|
|
|
new_dog = trick.TMM_declare_var(trick.TRICK_STRUCTURED,"Dog",0,"my_dog",0,None)
|
|
test_so.vap.push_back(new_dog)
|
|
TRICK_EXPECT_EQ( test_so.vap[1].id , 2, test_suite , "std::vector of abstract ptrs" )
|
|
|
|
#test_so.vap[0].speak()
|
|
#test_so.vap[1].speak()
|
|
|
|
#drg0 = trick.DRAscii("cat_stuff")
|
|
#drg0.add_variable("my_cat.id")
|
|
#drg0.add_variable("my_dog.id")
|
|
#drg0.set_cycle(0.1)
|
|
#drg0.freq = trick.DR_Always
|
|
#drg0.thisown = 0
|
|
#trick.add_data_record_group(drg0, trick.DR_Buffer)
|
|
|
|
test_so.vap2.push_back(new_dog)
|
|
test_so.vap2.push_back(new_cat)
|
|
|
|
# vector of vectors (experimental. It does work!)
|
|
test_so.vvap.push_back(test_so.vap)
|
|
test_so.vvap.push_back(test_so.vap2)
|
|
#test_so.vvap[0][0].speak()
|
|
#test_so.vvap[0][1].speak()
|
|
#test_so.vvap[1][0].speak()
|
|
#test_so.vvap[1][1].speak()
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "array_sclicing"
|
|
|
|
# fixed array
|
|
test_so.obj.ia = [ 10 , 20 , 30 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia[:]), "[10, 20, 30]", test_suite , "full slice, fixed array" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia[1:]), "[20, 30]", test_suite , "slice with start value, fixed array" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia[:2]), "[10, 20]", test_suite , "slice with end value, fixed array" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia[::2]), "[10, 30]", test_suite , "sclice with step value, fixed array" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia[-3:-1]), "[10, 20]", test_suite , "slice with negative start and end value, fixed array" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia[::-2]), "[30, 10]", test_suite , "slice with negative step, fixed array" )
|
|
|
|
test_so.obj.ia = [ 10 , 20 , 30]
|
|
test_so.obj.ia[1:1] = 400
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia), "[10, 400, 20]", test_suite , "slice insertion with scalar value, fixed array" )
|
|
|
|
test_so.obj.ia = [ 10 , 20 , 30]
|
|
test_so.obj.ia[1:1] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia), "[10, 400, 500]", test_suite , "slice insertion of list, fixed array" )
|
|
|
|
test_so.obj.ia = [ 10 , 20 , 30]
|
|
test_so.obj.ia[1:2] = 400
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia), "[10, 400, 30]", test_suite , "slice replacement with scalar value, fixed array" )
|
|
|
|
test_so.obj.ia = [ 10 , 20 , 30]
|
|
test_so.obj.ia[0:1] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia), "[400, 500, 20]", test_suite , "slice replacement list larger than sclice, fixed array" )
|
|
|
|
test_so.obj.ia = [ 10 , 20 , 30]
|
|
test_so.obj.ia[0:2] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia), "[400, 500, 30]", test_suite , "slice replacement list same size as sclice, fixed array" )
|
|
|
|
test_so.obj.ia = [ 10 , 20 , 30]
|
|
test_so.obj.ia[0:3] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia), "[400, 500, 0]", test_suite , "slice replacement list smaller than slice, fixed array" )
|
|
|
|
test_so.obj.ia = [ 10 , 20 , 30]
|
|
test_so.obj.ia[:] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia), "[400, 500, 0]", test_suite , "slice replacement full array, fixed array" )
|
|
|
|
test_so.obj.ia = [ 10 , 20 , 30]
|
|
test_so.obj.ia[0:2:2] = 400
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia), "[400, 20, 30]", test_suite , "slice replacement with scalar and step, fixed array" )
|
|
|
|
test_so.obj.ia = [ 10 , 20 , 30]
|
|
test_so.obj.ia[0:3:2] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ia), "[400, 20, 500]", test_suite , "slice replacement with list and step, fixed array" )
|
|
|
|
# pointer
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 ]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip[:]), "[10, 20, 30, 40]", test_suite , "full slice, pointer" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip[1:]), "[20, 30, 40]", test_suite , "slice with start value, pointer" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip[:2]), "[10, 20]", test_suite , "slice with end value, pointer" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip[::2]), "[10, 30]", test_suite , "sclice with step value, pointer" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip[-3:-1]), "[20, 30]", test_suite , "slice with negative start and end value, pointer" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip[::-2]), "[40, 20]", test_suite , "slice with negative step, pointer" )
|
|
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 , 50]
|
|
test_so.obj.ip[1:1] = 400
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip), "[10, 400, 20, 30, 40]", test_suite , "slice insertion with scalar value, pointer" )
|
|
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 , 50]
|
|
test_so.obj.ip[1:1] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip), "[10, 400, 500, 20, 30]", test_suite , "slice insertion of list, pointer" )
|
|
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 , 50]
|
|
test_so.obj.ip[1:2] = 400
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip), "[10, 400, 30, 40, 50]", test_suite , "slice replacement with scalar value, pointer" )
|
|
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 , 50]
|
|
test_so.obj.ip[1:2] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip), "[10, 400, 500, 30, 40]", test_suite , "slice replacement list larger than sclice, pointer" )
|
|
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 , 50]
|
|
test_so.obj.ip[1:3] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip), "[10, 400, 500, 40, 50]", test_suite , "slice replacement list same size as sclice, pointer" )
|
|
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 , 50]
|
|
test_so.obj.ip[1:4] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip), "[10, 400, 500, 50, 0]", test_suite , "slice replacement list smaller than slice, pointer" )
|
|
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 , 50]
|
|
test_so.obj.ip[:] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip), "[400, 500, 0, 0, 0]", test_suite , "slice replacement full array, pointer" )
|
|
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 , 50]
|
|
test_so.obj.ip[1:3:2] = 400
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip), "[10, 400, 30, 40, 50]", test_suite , "slice replacement with scalar and step, pointer" )
|
|
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 , 50]
|
|
test_so.obj.ip[1:4:2] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip), "[10, 400, 30, 500, 50]", test_suite , "slice replacement with list and step, pointer" )
|
|
|
|
test_so.obj.ip = [ 10 , 20 , 30 , 40 , 50]
|
|
test_so.obj.ip[1:5:2] = [400 , 500]
|
|
TRICK_EXPECT_EQ( str(test_so.obj.ip), "[10, 400, 30, 500, 50]", test_suite , "slice replacement with list and step, pointer" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "STL list support"
|
|
|
|
#print dir(test_so.obj.ls)
|
|
|
|
TRICK_EXPECT_EQ( test_so.obj.ls.empty(), 1, test_suite , "STL list empty true" )
|
|
test_so.obj.ls.push_back('string 1')
|
|
test_so.obj.ls.push_front('string 2')
|
|
test_so.obj.ls.push_back('string 3')
|
|
TRICK_EXPECT_EQ( test_so.obj.ls.empty(), 0, test_suite , "STL list empty false" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ls.front(), "string 2", test_suite , "STL list front access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ls.back(), "string 3", test_suite , "STL list back access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.ls.size(), 3, test_suite , "STL list size command" )
|
|
|
|
#test_so.obj.ls.insert(test_so.obj.ls.begin(), 'string 4')
|
|
#test_so.obj.ls.pop_front()
|
|
#test_so.obj.ls.erase(test_so.obj.ls.begin())
|
|
#for l in test_so.obj.ls:
|
|
# print l
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "STL map support"
|
|
|
|
TRICK_EXPECT_EQ( test_so.obj.msi.empty(), 1, test_suite , "STL map empty true" )
|
|
|
|
test_so.obj.msi['key1'] = 50
|
|
test_so.obj.msi['key2'] = 60
|
|
test_so.obj.msi['key3'] = 70
|
|
|
|
TRICK_EXPECT_EQ( test_so.obj.msi.empty(), 0, test_suite , "STL map empty false" )
|
|
TRICK_EXPECT_EQ( test_so.obj.msi['key1'], 50, test_suite , "STL map key/data insertion/access" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.msi.keys()), "['key1', 'key2', 'key3']", test_suite , "STL map keys command" )
|
|
TRICK_EXPECT_EQ( str(test_so.obj.msi.values()), "[50, 60, 70]", test_suite , "STL map values command" )
|
|
TRICK_EXPECT_EQ( test_so.obj.msi.has_key('key1'), 1, test_suite , "STL map has_key true" )
|
|
TRICK_EXPECT_EQ( test_so.obj.msi.has_key('key4'), 0, test_suite , "STL map has_key false" )
|
|
TRICK_EXPECT_EQ( test_so.obj.msi.size(), 3, test_suite , "STL map size command" )
|
|
#print dict(test_so.obj.msi)
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "Templated SimObject"
|
|
|
|
TRICK_EXPECT_EQ( tso.t, 25, test_suite , "templated sim_object access member" )
|
|
TRICK_EXPECT_EQ( iftso.t, 25, test_suite , "inherit from templated sim_object access member" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "Templated SimObject"
|
|
TRICK_EXPECT_TRUE( test_so.test_true(), test_suite , "boolean function return" )
|
|
TRICK_EXPECT_FALSE( test_so.test_false(), test_suite , "boolean function return" )
|
|
|
|
######################################################################################################################
|
|
|
|
test_suite = "SWIG Templates"
|
|
|
|
test_so.obj.class_no_ns.tnns.x = 1
|
|
test_so.obj.class_no_ns.tns.y = 2
|
|
test_so.obj.class_ns.tnns.x = 3
|
|
test_so.obj.class_ns.tns.y = 4
|
|
test_so.obj.foo1.bar.z = 5
|
|
test_so.obj.foo2.bar.z = 6
|
|
|
|
TRICK_EXPECT_EQ( test_so.obj.class_no_ns.tnns.x, 1, test_suite , "template member access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.class_no_ns.tns.y, 2, test_suite , "template member access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.class_ns.tnns.x, 3, test_suite , "template member access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.class_ns.tns.y, 4, test_suite , "template member access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.foo1.bar.z, 5, test_suite , "template member access" )
|
|
TRICK_EXPECT_EQ( test_so.obj.foo2.bar.z, 6, test_suite , "template member access" )
|
|
|
|
######################################################################################################################
|
|
|
|
if __name__ == "__main__":
|
|
main()
|
|
|