#
# -------------------------------------------------------------------------------------------------
#
#
#
#
#
# -------------------------------------------------------------------------------------------------
# -------------------------------------------------------------------------------------------------
# Public API
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# Standard Imports
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# Scope4Xi imports
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# Multiprocessing Imports
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# DragonXi imports
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
# Global constants
# ------------------------------------------------------------------------------------------------
#
# ----------------------------------------------------------------------------------------------------------
#
# ----------------------------------------------------------------------------------------------------------
def set2trace4xi():
global t2xi
global trace_object_count
global PickleKB4Xi
# print("(Step 0A/33) OF SET2TRACE4XI - STARTING SETTING TRACE BASED ON TRACE SETTINGS IN MODULES PICKLE2x4XI.PY (x=a,b...) ", time4xi())
# print("(Step 0B/33) OF SET2TRACE4XI - USING T2XI: ", t2xi)
#
# ---------------------------------------------------------------------------------------------
# A, B .... _
# ---------------------------------------------------------------------------------------------
keys2pickledb = sorted(PickleKB4Xi.keys())
for key2pickledb in keys2pickledb:
# -----------------------------------------------------------------------------------------
# LETTERS
# -----------------------------------------------------------------------------------------
# print('=' *33)
# print("STARTING LETTER : ", key2pickledb)
# print('=' *33)
dictionary2pickle = PickleKB4Xi[key2pickledb]
# print("STARTING DICTIONARY: ", dictionary2pickle)
# print('~' *33)
#
keys2dictionary = sorted(dictionary2pickle.keys())
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
for key2dictionary in keys2dictionary:
# -------------------------------------------------------------------------------------
# DICTIONARY
# -------------------------------------------------------------------------------------
# print('~' *33)
object2pickle = key2dictionary
# print("STARTING OBJECT: ", object2pickle)
# print('~' *33)
# pickle4xi(object2pickle)
# print('~' *33)
# print("PICKLED object: ", object2pickle)
# PICKLED object: _C4Xi,
# ---------------------------------------------------------------------------------
# Mark those with NACK4XI to be traced !
# ---------------------------------------------------------------------------------
if dictionary2pickle[key2dictionary] == 'NACK4XI':
set_param2xi = True
key_param = object2pickle
t2xi.set_print_permission(key_param, set_param2xi)
# print("(Step 2A/33) OF SET2TRACE4XI - MARKED TO BE TRACED OBJECT: ", object2pickle)
#
else:
pass
# ---------------------------------------------------------------------------------
# END OF DICTIONARY
# ---------------------------------------------------------------------------------
# -----------------------------------------------------------------------------------------
# END OF LETTERS
# -----------------------------------------------------------------------------------------
# print('~' *33)
# print("COMPLETED DICTIONARY: ", dictionary2pickle)
# print('~' *33)
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
# print('=' *33)
# print("COMPLETED LETTER : ", key2pickledb)
# print('=' *33)
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
print('=' *33)
print("(Step 33/33) OF SET2TRACE4XI - COMPLETED SETTING TRACE BASED ON NACK4XI/ACK4XI SETTINGS IN MODULES PICKLE2x4XI.PY (x=a,b...) ", time4xi())
print('=' *33)
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def deny2trace4xi():
global t2xi
global trace_object_count
global PickleKB4Xi
print("(Step 01A/33) of DENY2TRACE4XI: STARTING DENYING TRACE IN MODULES PICKLE2x4XI.PY (x=a,b...) ", time4xi())
print("(Step 01B/33) OF DENY2TRACE4XI - USING T2XI: ", t2xi)
#
# ---------------------------------------------------------------------------------------------
# A, B .... _
# ---------------------------------------------------------------------------------------------
keys2pickledb = sorted(PickleKB4Xi.keys())
for key2pickledb in keys2pickledb:
# -----------------------------------------------------------------------------------------
# LETTERS
# -----------------------------------------------------------------------------------------
# print("(Step 02A/33) OF DENY2TRACE4XI - STARTING LETTER : ", key2pickledb)
dictionary2pickle = PickleKB4Xi[key2pickledb]
# print("(Step 02B/33) OF DENY2TRACE4XI - STARTING DICTIONARY: ", dictionary2pickle)
keys2dictionary = sorted(dictionary2pickle.keys())
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
for key2dictionary in keys2dictionary:
# -------------------------------------------------------------------------------------
# DICTIONARY
object2pickle = key2dictionary
# print("(Step 02C/33) OF DENY2TRACE4XI - STARTING OBJECT: ", object2pickle)
# pickle4xi(object2pickle)
# print("STEP: PICKLED object: ", object2pickle)
# PICKLED object: _C4Xi,
# ---------------------------------------------------------------------------------
# ACK4XI = tested .i.e. NOT to be traced!
# ---------------------------------------------------------------------------------
set_param2xi = 'ACK4XI'
key_param = object2pickle
t2xi.set_print_permission(key_param, set_param2xi)
# print("(Step 02D/33) OF DENY2TRACE4XI - MARKED TESTED AND NOT to be traced: ", object2pickle)
dictionary2pickle[key2dictionary] = 'ACK4XI'
# ---------------------------------------------------------------------------------
# END OF DICTIONARY
# ---------------------------------------------------------------------------------
# print('~' *33)
# print("(Step 02Z/33) OF DENY2TRACE4XI *** FAILED - ERROR IN PICKLING OBJECT - NOT TO BE TRACED: ", object2pickle)
# print('~' *33)
# -----------------------------------------------------------------------------------------
# END OF LETTERS
# -----------------------------------------------------------------------------------------
# print("(Step 02E/33) OF DENY2TRACE4XI - COMPLETED DICTIONARY: ", dictionary2pickle)
#
# -----------------------------------------------------------------------------------------
#
# -----------------------------------------------------------------------------------------
# print("(Step 02F/33) OF DENY2TRACE4XI - COMPLETED LETTER : ", key2pickledb)
# _, a ... z
print("(Step 033/33) OF SET2TRACE4XI - COMPLETED DENYING TRACE IN MODULES PICKLE2x4XI.PY (x=a,b...) ", time4xi())
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def tailor2trace4xi():
global trace_object_count
global PickleKB4Xi
global t2xi
print("(Step 001A/33) OF TAILOR2TRACE4XI - USING T2XI: ", t2xi)
#
# ---------------------------------------------------------------------------------------------
# Settings to tailor trace
# ---------------------------------------------------------------------------------------------
#
# ---------------------------------------------------------------------------------------------
# PROCESS KB4Tailoring
# ---------------------------------------------------------------------------------------------
keys2tailor = sorted(KB4Tailoring.keys())
for key2tailor in keys2tailor:
# ---------------------------------------------------------------------------------
# NACK4XI = NOT TESTED .I.E. TO BE TRACED!
# ---------------------------------------------------------------------------------
set_param2xi = 'NACK4XI'
key_param = key2tailor
t2xi.set_print_permission(key_param, set_param2xi)
print("(Step 002A/33) OF TAILOR_TRACE4XI - MARKED TO BE TESTED: ", key2tailor)
#
# -----------------------------------------------------------------------------------------
# EOF KEYS
# -----------------------------------------------------------------------------------------
print("(Step 0033/33) OF TAILOR_TRACE4XI - COMPLETED TAILORING: ", time4xi())
#
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def print2trace4xi(t2xi):
# -------------------------------------------------------------------------------------------------
# SENSE
# -------------------------------------------------------------------------------------------------
context2sense = {
'file_path4xi': 'E:\\scope4xi\\041721\\zap\\web\\xml\\sense-ppu3image4xi5test.xml',
'name_space4xi': ' xmlns="http://www.yourppuxi.org/sw4xi/python33/owl/multiprocessing4ppu.owl#"\n',
'xml_base4xi': ' xml:base="http://www.yourppuxi.org/web/lib/owl/scope4xi.owl">\n',
'ontology_about4xi': ' \n',
'ontology_comment4xi': ' Classes, methods and messages with context.\n',
'class0_id4xi': ' \n',
'class0_comment4xi': ' Sensing 3D Image of PPU.\n',
'object_property_rdf4xi': ' \n',
'object_property_comment4xi': ' Image of PPU sensed.\n',
'debug4xi': True}
xml_trace_sense4xi(t2xi, context2sense)
# -------------------------------------------------------------------------------------------------
# REASON
# -------------------------------------------------------------------------------------------------
context2reason = {
'file_path4xi': 'E:\\scope4xi\\041721\\zap\\web\\xml\\reason-ppu3image4xi5test.xml',
'name_space4xi': ' xmlns="http://www.yourppuxi.org/sw4xi/python33/owl/multiprocessing4ppu.owl#"\n',
'xml_base4xi': ' xml:base="http://www.yourppuxi.org/web/lib/owl/scope4xi.owl">\n',
'ontology_about4xi': ' \n',
'ontology_comment4xi': ' Operations\n',
'operation_comment4xi': ' Operations for 3D Image of PPU.\n',
'class0_id4xi': ' \n',
'class0_comment4xi': ' Operations with context.\n',
'object_property_rdf4xi': ' \n',
'object_property_comment4xi': ' reason\n',
'debug4xi': True}
xml_trace_reason4xi(t2xi, context2reason)
# -------------------------------------------------------------------------------------------------
# ACE
# -------------------------------------------------------------------------------------------------
context2ace = {
'file_path4xi': 'E:\\scope4xi\\041721\\zap\\web\\xml\\ace-ppu3image4xi5test.xml',
'name_space4xi': ' xmlns="http://www.yourppuxi.org/sw4xi/python33/owl/multiprocessing4ppu.owl#"\n',
'xml_base4xi': ' xml:base="http://www.yourppuxi.org/web/lib/owl/scope4xi.owl">\n',
'ontology_about4xi': ' \n',
'ontology_comment4xi': ' Objects and values for 3D Image of PPU.\n',
'class0_id4xi': ' \n',
'class0_comment4xi': ' Objects and values of 3D Image of PPU.\n',
'object_property_rdf4xi': ' \n',
'object_property_comment4xi': ' 000000\n',
'debug4xi': True}
xml_trace_ace4xi(t2xi, context2ace)
# -------------------------------------------------------------------------------------------------
# end of print2trace4xi
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def ppu3image4xi5test():
global t2xi
global trace_object_count
# ---------------------------------------------------------------------------------------------
# INITIALIZE TRACE
# ---------------------------------------------------------------------------------------------
t2xi = Print4Xi()
print("(Step 0A/33) OF TEST_RESOURCESHARER4XI - SET T2XI TO: ", t2xi)
#
set2trace4xi() # trace all classes and functions in the system
deny2trace4xi() # deny trace for all classes and functions in the system
tailor2trace4xi() # tailor trace for this test
try:
# ---------------------------------------------------------------------------------------------
# START TESTING
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 1A/700) OF PPU3IMAGE4XI5TEST - STARTED ', time4xi())
print('=' *33)
#
# ---------------------------------------------------------------------------------------------
# PHASE I: FUNCTION TESTS - CREATE 3D IMAGE WITH FUNCTION
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 2C/700) OF PPU3IMAGE4XI5TEST - TRYING TO CREATE 3D IMAGE4PPU ', time4xi())
print('=' *33)
#
try:
response4create3Dimage = create3image4ppu() # NO PARAMETERS - THE SYSTEM CREATES
print('(Step 2B/700) OF PPU3IMAGE4XI5TEST - CREATED 3D IMAGE4PPU ', time4xi())
keys3response = response4create3Dimage.keys()
for key3response in sorted(keys3response):
print(key3response, ' : ', response4create3Dimage[key3response])
# ACK2RETURN : 1D-1E-2C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-12B-14B-15B-16B-17B-19B-19D-20B-20C-21A1-22B1-22C1-23B-24B-25B-26B-27B-28B-29B-30B-31B-32H-34H-35H-36B-37B-38B-39B-
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 05:18:11 10/10/ ...
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 05: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 05:18:11 10/10/11 Pacific Dayl ...
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 05:18:11 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4ppu', 'METHOD': 'create3image4ppu'}
# DEPTH : 800
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 05:18:11 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FUNCTION3CALLBACK :
# HEIGHT : 800
# NACK2RETURN :
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 800
# SLICEPITCH : 800
# WIDTH : 800
except:
print('(Step 2Z2/700) OF PPU3IMAGE4XI5TEST *** FAILED TO CREATE 3D IMAGE4PPU *** ', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE I: FUNCTION TESTS - GET SUPPORTED 3D IMAGE FORMATS WITH FUNCTION
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 3A1/700) OF PPU3IMAGE4XI5TEST - TRYING TO GET SUPPORTED 3D IMAGE FORMATS FOR PPU ', time4xi())
print('=' *33)
try:
task4supportedimageformats3ppu = {}
task4supportedimageformats3ppu['DIMENSION'] = 3
imageformats3ppu = get3supportedimageformats4ppu(task4supportedimageformats3ppu)
print('(Step 3A3/700) OF PPU3IMAGE4XI5TEST - GOT SUPPORTED 3D IMAGE FORMATS FOR PPU: ', imageformats3ppu)
# {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
except:
print('(Step 3Z3/700) OF PPU3IMAGE4XI5TEST *** FAILED TO GET SUPPORTED 3D IMAGE FORMATS FOR PPU', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE I: FUNCTION TESTS - GET SOME 3D IMAGE INFO WITH FUNCTION
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 3A3/700) OF PPU3IMAGE4XI5TEST - TRYING TO GET SOME 3D IMAGE INFO FOR PPU ', time4xi())
print('=' *33)
task4getinfo3image = {}
task4getinfo3image ['DIMENSION'] = 3
task4getinfo3image ['WIDTH'] = 0
task4getinfo3image ['HEIGHT'] = 0
task4getinfo3image ['DEPTH'] = 0
try:
response4getinfo3Dimage = get3imageinfo4ppu(task4getinfo3image)
keys3response = response4getinfo3Dimage.keys()
print('(Step 3A3/700) OF PPU3IMAGE4XI5TEST - GOT SOME 3D IMAGE INFO FOR PPU ', time4xi())
for key3response in sorted(keys3response):
print(key3response, ' : ', response4getinfo3Dimage[key3response])
# DEPTH : 800
# HEIGHT : 800
# WIDTH : 800
except:
print('(Step 3Z3/700) OF PPU3IMAGE4XI5TEST *** FAILED TO GET SOME 3D IMAGE INFO FOR PPU ***', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE I: FUNCTION TESTS - GET ALL 3D IMAGE INFO WITH FUNCTION
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 3A4/700) OF PPU3IMAGE4XI5TEST - TRYING TO GET ALL 3D IMAGE INFO FOR PPU ', time4xi())
print('=' *33)
try:
task4getinfo3image = {}
task4getinfo3image ['DIMENSION'] = 3
task4getinfo3image ['DOMAIN'] = 'ALL'
response4getinfo3Dimage = get3imageinfo4ppu(task4getinfo3image)
print('(Step 3A5/700) OF PPU3IMAGE4XI5TEST - GOT ALL 3D IMAGE INFO FOR PPU ', time4xi())
keys3response = response4getinfo3Dimage.keys()
for key3response in sorted(keys3response):
print(key3response, ' : ', response4getinfo3Dimage[key3response])
# ACK2RETURN : 1D-1E-2C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-12B-14B-15B-16B-17B-19B-19D-20B-20C-21A1-22B1-22C1-23B-24B-25B-26B-27B-28B-29B-30B-31B-32H-34H-35H-36B-37B-38B-39B-
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 05:18:11 10/10/ ...
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 05: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 05:18:11 10/10/11 Pacific Dayl ...
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 05:18:11 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 800
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 05:18:11 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FUNCTION3CALLBACK :
# HEIGHT : 800
# NACK2RETURN :
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 800
# SLICEPITCH : 800
# WIDTH : 800
except:
print('(Step 3Z4/700) OF PPU3IMAGE4XI5TEST *** FAILED TO GET ALL 3D IMAGE INFO FOR PPU ***', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE I: FUNCTION TESTS - SET 3D IMAGE WITH FUNCTION - ALL ATTRIBUTES
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 4A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET IMAGE WITH FUNCTION ', time4xi())
print('=' *33)
# ---------------------------------------------------------------------------------------------
# (1) GET PLATFORM IDs TO SET CONTEXT
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 4B/700) OF PPU3IMAGE4XI5TEST - TRYING TO GET PLATFORMIDS4XI', time4xi())
print('=' *33)
platform3xi = {}
try:
platform3xi = get2platformids4xi()
print('(Step 4B/33) OF PPU3IMAGE4XI5TEST - GOT PLATFORMIDS4XI', platform3xi)
# {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
except:
print('(Step 4Z/33) OF PPU3IMAGE4XI5TEST *** FAILED TO GET PLATFORMIDS4XI', time4xi())
# ---------------------------------------------------------------------------------------------
# (2) INITIALIZE DEVICE
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 2A/33) OF PPU3IMAGE4XI5TEST - TRYING TO INITIALIZE DEVICE4PPU ', time4xi())
print('=' *33)
try:
device2ppu = init2ppu4xi() # NO PARAMETERS - THE SYSTEM SHOULD INITIALIZE
print('(Step 2B/33) OF PPU3IMAGE4XI5TEST - INITIALIZED DEVICE4PPU TO: ', device2ppu)
# {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHLONG4VECTOR' ...
except:
print('(Step 2Z/33) OF PPU3IMAGE4XI5TEST *** FAILED TO INITIALIZE DEVICE4PPU', time4xi())
# ---------------------------------------------------------------------------------------------
# (3) CREATE CONTEXT
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 3A/700) OF PPU3IMAGE4XI5TEST - TRYING TO CREATE CONTEXT4PPU ', time4xi())
print('=' *33)
try:
context2ppu = create2context4ppu() # NO PARAMETERS - THE SYSTEM CREATES
print('(Step 3B/700) OF PPU3IMAGE4XI5TEST - CREATED CONTEXT4PPU: ', context2ppu)
# {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 05:35:43 10/10/11 Pacific Daylight Time}', ...
except:
print('(Step 3Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO CREATE CONTEXT4PPU', time4xi())
# ---------------------------------------------------------------------------------------------
# (4) INITIALIZE TASK DICTIONARY
# ---------------------------------------------------------------------------------------------
task4set3image = {}
# ---------------------------------------------------------------------------------------------
# (5) DEFINE CONTEXT - REQUIRED
# ---------------------------------------------------------------------------------------------
task4set3image ['CONTEXT'] = context2ppu
# ---------------------------------------------------------------------------------------------
# (6) DEFINE DEVICE - EXTRA
# ---------------------------------------------------------------------------------------------
task4set3image ['DEVICE'] = device2ppu
# ---------------------------------------------------------------------------------------------
# (7) DEFINE PROPERTIES - NONE
# ---------------------------------------------------------------------------------------------
task4set3image ['PROPERTIES'] = None
# ---------------------------------------------------------------------------------------------
# (8) DEFINE ERROR CODE - REQUIRED
# ---------------------------------------------------------------------------------------------
task4set3image ['CODE3ERROR'] = 0
# ---------------------------------------------------------------------------------------------
# (9) SET QUEUE - EXTRA
# ---------------------------------------------------------------------------------------------
task4set3image ['QUEUE'] = None
print('(Step 9A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET QUEUE FOR IMAGE4PPU ', time4xi())
try:
task4set3image ['QUEUE'] = Queue4Xi()
print('(Step 9B/700) OF PPU3IMAGE4XI5TEST - QUEUE OF IMAGE4PPU: ', task4set3image ['QUEUE'])
#
except:
print('(Step 9Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SET QUEUE FOR IMAGE4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------
# (10) SET PIPE - EXTRA
# ---------------------------------------------------------------------------------------------
task4set3image ['PIPE'] = None
print('(Step 10A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET PIPE FOR IMAGE4PPU ', time4xi())
try:
task4set3image ['PIPE'] = Pipe4Xi()
print('(Step 10B/700) OF PPU3IMAGE4XI5TEST - PIPE OF IMAGE4PPU: ', task4set3image ['PIPE'])
# (, )
except:
print('(Step 10Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SET PIPE FOR IMAGE4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------
# (11) SET COMMAND QUEUE - EXTRA
# ---------------------------------------------------------------------------------------------
task4set3image ['COMMANDQUEUE'] = None
print('(Step 11A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET COMMAND QUEUEFOR IMAGE4PPU ', time4xi())
try:
task4set3image ['COMMANDQUEUE'] = create2commandqueue4ppu()
print('(Step 11B/700) OF PPU3IMAGE4XI5TEST - COMMAND QUEUE OF IMAGE4PPU: ', task4set3image ['COMMANDQUEUE'])
# {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 05:35:43 10/10/11 Pa ...
except:
print('(Step 11Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SET COMMAND QUEUE FOR IMAGE4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------
# (11) SET 3D IMAGE - FINALLY!
# ---------------------------------------------------------------------------------------------
response4set3Dimage = {}
print('(Step 11A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET 3D IMAGE4PPU ', time4xi())
try:
response4set3Dimage = set3image4ppu(task4set3image)
print('(Step 11B/700) OF PPU3IMAGE4XI5TEST - SET 3D IMAGE4PPU ', time4xi())
keys3response = response4set3Dimage.keys()
for key3response in sorted(keys3response):
print(key3response, ' : ', response4set3Dimage[key3response])
#
except:
print('(Step 11Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SET 3D IMAGE4PPU *** ', time4xi())
task4set3image = {}
task4set3image ['DIMENSION'] = 3
task4set3image ['DEPTH'] = 900
task4set3image ['HEIGHT'] = 1000
task4set3image ['WIDTH'] = 1100
task4set3image ['ROWPITCH'] = 901 # NOTE: YOU HAVE TO GIVE THIS !
task4set3image ['SLICEPITCH'] = 902 # NOTE: YOU HAVE TO GIVE THIS !
response4set3Dimage = {}
print('(Step 11C/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET 3D IMAGE4PPU ', time4xi())
try:
response4set3Dimage = set3image4ppu(task4set3image)
print('(Step 11D/700) OF PPU3IMAGE4XI5TEST - SET 3D IMAGE4PPU ', time4xi())
keys3response = response4set3Dimage.keys()
for key3response in sorted(keys3response):
print(key3response, ' : ', response4set3Dimage[key3response])
# ACK2RETURN : 32H-34H-35H-36B-37B-
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 06:24:23 10/10/ ...
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 06: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 06:24:23 10/10/11 Pacific Dayl ...
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 06:24:23 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 900
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 06:24:23 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FUNCTION3CALLBACK :
# HEIGHT : 1000
# NACK2RETURN : 21Z1-22Z2-22Z3-23Z1-24Z1-25Z1-26Z1-27Z1-28Z1-29Z1-30Z1-31Z1-38Z1-39Z1-
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 901
# SLICEPITCH : 902
# WIDTH : 1100
except:
print('(Step 11Z2/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SET 3D IMAGE4PPU *** ', time4xi())
# ---------------------------------------------------------------------------------------------
# (12) REFERENCE COUNT FOR EACH PROCESSING UNIT RELEASED BY DECREMENTING COUNT WITH 1
# ---------------------------------------------------------------------------------------------
task4release3image = {}
task4release3image ['COUNT3REFERENCE'] = 1
response4release3image = {}
print('(Step 12A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RELEASE 3D IMAGE OF PPU DEVICE ', time4xi())
#
try:
response4release3Dimage = release3image4ppu(task4release3image)
print('(Step 12B/700) OF PPU3IMAGE4XI5TEST - RELEASED 3D IMAGE OF PPU DEVICE ', time4xi())
keys3response = response4release3Dimage.keys()
for key3response in sorted(keys3response):
print(key3response, ' : ', response4release3Dimage[key3response])
# ACK2RETURN :
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 06:24:23 10/10/ ...
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 06: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 06:24:23 10/10/11 Pacific Dayl ...
# COUNT3REFERENCE : 0
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 06:24:23 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 900
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 06:24:23 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FUNCTION3CALLBACK :
# HEIGHT : 1000
# NACK2RETURN : 8Z1-
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 901
# SLICEPITCH : 902
# WIDTH : 1100
except:
print('(Step 12Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RELEASE IMAGE OF PPU DEVICE ', time4xi())
task4getinfo3image = {}
task4getinfo3image ['HEIGHT'] = 0
task4getinfo3image ['WIDTH'] = 0
task4getinfo3image ['DEPTH'] = 0
response4getinfo3image = {}
print('(Step 12C/700) OF PPU3IMAGE4XI5TEST - TRYING TO GET SELECTED 3D IMAGE INFO OF PPU DEVICE ', time4xi())
#
try:
response4getinfo3Dimage = get3imageinfo4ppu (task4getinfo3image)
keys3response = response4getinfo3Dimage.keys()
print('(Step 12D/700) OF PPU3IMAGE4XI5TEST - GOT SELECTED 3D IMAGE INFO OF PPU DEVICE ', time4xi())
for key3response in sorted(keys3response):
print(key3response, ' : ', response4getinfo3Dimage[key3response])
# DEPTH : 900
# HEIGHT : 1000
# WIDTH : 1100
#
except:
print('(Step 12Z2/700) OF PPU3IMAGE4XI5TEST *** FAILED TO GET SELECTED 3D IMAGE INFO OF PPU DEVICE ', time4xi())
# ---------------------------------------------------------------------------------------------
# (13) REFERENCE COUNT FOR EACH PROCESSING UNIT RETAINED BY INCREMENTING COUNT WITH 1
# ---------------------------------------------------------------------------------------------
task4retain3image = {}
task4retain3image ['DIMENSION'] = 3
task4retain3image ['COUNT3REFERENCE'] = 1
response4retain3Dimage = {}
print('(Step 13C/700) OF PPU3IMAGE4XI5TEST - TRYING TO RETAIN 3D IMAGE OF PPU DEVICE ', time4xi())
try:
response4retain3Dimage = retain3image4ppu(task4retain3image)
print('(Step 13D/700) OF PPU3IMAGE4XI5TEST - RESPONSE4RETAIN3DIMAGE : ', time4xi())
keys3response = response4retain3Dimage.keys()
for key3response in sorted(keys3response):
print(key3response, ' : ', response4retain3Dimage[key3response])
# ACK2RETURN : 6D-
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 06:24:23 10/10/ ...
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 06: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 06:24:23 10/10/11 Pacific Dayl ...
# COUNT3REFERENCE : 1
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 06:24:23 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 900
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 06:24:23 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FUNCTION3CALLBACK :
# HEIGHT : 1000
# NACK2RETURN :
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 901
# SLICEPITCH : 902
# WIDTH : 1100
except:
print('(Step 13Z2/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RETAIN 3D IMAGE OF PPU DEVICE ', time4xi())
# ---------------------------------------------------------------------------------------------
# (14) IMAGE CALLBACK
# ---------------------------------------------------------------------------------------------
print('(Step 14A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET 3D IMAGE CALLBACK OF PPU DEVICE ', time4xi())
try:
response4setcallback3image = set3imagecallback4ppu()
print('(Step 14B/700) OF PPU3IMAGE4XI5TEST - SET 3D IMAGE CALLBACK OF PPU DEVICE TO: ', response4setcallback3image)
#
except:
print('(Step 14Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SET 3D IMAGE CALLBACK OF PPU DEVICE ', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE I: TRACE FUNCTION TESTS
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 15A/25) OF PPU3IMAGE4XI5TEST - TRYING TO SET TRACE FOR 3D IMAGE OF PPU: ', time4xi())
print('=' *33)
trace3ppu = None
try:
trace3ppu = trace3image4ppu()
print('(Step 15B/25) OF PPU3IMAGE4XI5TEST - SET TRACE FOR 3D IMAGE OF PPU: ', trace3ppu)
# {'MESSAGE': '{(Step 2Z0/33) failed; trace3image4ppu-failed {}; time: 06:24:23 10/10/11 Pacific Daylight Time}',
# 'CLASS': 'trace3image4ppu',
# 'METHOD': 'trace3image4ppu'}
except:
print('(Step 15Z1/25) OF PPU3IMAGE4XI5TEST *** FAILED TO SET TRACE FOR 3D IMAGE OF PPU: ', trace3ppu)
# ---------------------------------------------------------------------------------------------
# PHASE I: WAIT FUNCTION TESTS
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 16A/700) OF PPU3IMAGE4XI5TEST - TRYING TO WAIT 3D IMAGE FOR PPU ', time4xi())
print('=' *33)
try:
response4wait3ppu = wait3image4ppu()
keys3response = response4wait3ppu.keys()
print('(Step 16B/700) OF PPU3IMAGE4XI5TEST - WAITED 3D IMAGE FOR PPU ', time4xi())
for key3response in sorted(keys3response):
print(key3response, ' : ', response4wait3ppu[key3response])
# ACK2RETURN : 6D-
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 06:24:23 10/10/ ...
# CALLBACK :
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 06: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 06:24:23 10/10/11 Pacific Dayl ...
# COUNT3REFERENCE : 1
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 06:24:23 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 900
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EMPTY2QUEUE : True
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 06:24:23 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FULL2QUEUE : False
# FUNCTION3CALLBACK :
# HEIGHT : 1000
# NACK2RETURN :
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 901
# SIZE2QUEUE : 2147483646
# SLICEPITCH : 902
except:
print('(Step 16Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO WAIT 3D IMAGE FOR PPU: ', wait2ppu)
# ---------------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - ESTABLISH CONTROL & COMMAND
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 16C/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL & COMMAND WITH READ3IMAGE4PPU ', time4xi())
print('=' *33)
#
response4read3image = {}
task4read3image = None
try:
response4read3image = read3image4ppu(task4read3image)
print('(Step 16D/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL & COMMAND WITH READ3IMAGE4PPU : ', response4read3image)
# option 1 (in use):
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }
queue3read4ppu = response4read3image['QUEUE']
channel3readpublish4ppu = response4read3image['PUBLISHERCHANNEL']
channel3readconsume4ppu = response4read3image['CONSUMERCHANNEL']
except:
print('(Step 16Z2/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL & COMMAND WITH READ3IMAGE4PPU ', time4xi())
# ----------------------------------------------------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - SET SIMULATION FOR MANOEUVRE3READIMAGE4PPU FUNCTION TO CALL IT DIRECTLY INSTEAD OF TRUSTING THREAD
# ----------------------------------------------------------------------------------------------------------------------------------
ack3simulate4ppu = True
nack3simulate4ppu = False
# -----------------------------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - SEND CONTROL & COMMAND COPY VIA PIPE FOR MANOEUVRE3READIMAGE4PPU TO RECEIVE
# -----------------------------------------------------------------------------------------------------------
print('(Step 17A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH READ3IMAGE4PPU ', time4xi())
#
try:
message3send4ppu = "copy3read4ppu"
channel3readpublish4ppu = response4read3image['PUBLISHERCHANNEL']
channel3readpublish4ppu.send(message3send4ppu)
print("(Step 17B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel3readpublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
# copy3read4ppu
except:
print('(Step 17Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH READ3IMAGE4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - SIMULATE MANOEUVRE3READIMAGE4PPU THREAD - LET IT TO RECEIVE COPY AND TO SEND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 18C/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", time4xi())
try:
response3manoeuvre4read = manoeuvre3readimage4ppu(queue3read4ppu, channel3readconsume4ppu, channel3readpublish4ppu)
print("(Step 18D/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", manoeuvre3readimage4ppu)
#
except:
print("(Step 18Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------
print('(Step 19A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ3IMAGE4PPU ', time4xi())
#
try:
channel3readconsume4ppu = response4read3image['CONSUMERCHANNEL']
message3receive4ppu = channel3readconsume4ppu.recv()
print("(Step 19B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel3readconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# roger3read4ppu
except:
print('(Step 19Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ3IMAGE4PPU ', time4xi())
# ------------------------------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE3READIMAGE4PPU TO RECEIVE
# ------------------------------------------------------------------------------------------------------------
print('(Step 20A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH READ3IMAGE4PPU ', time4xi())
#
try:
message3send4ppu = "ready3read4ppu"
channel3readpublish4ppu = response4read3image['PUBLISHERCHANNEL']
channel3readpublish4ppu.send(message3send4ppu)
print("(Step 20B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel3readpublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
# ready3read4ppu
except:
print('(Step 20Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH READ3IMAGE4PPU ', time4xi())
# -------------------------------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - SIMULATE MANOEUVRE3READIMAGE4PPU THREAD - LET IT RECEIVE READY AND SEND READY
# -------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 21A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", time4xi())
try:
response3manoeuvre4read = manoeuvre3readimage4ppu(queue3read4ppu, channel3readconsume4ppu, channel3readpublish4ppu)
print("(Step 21B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", manoeuvre3readimage4ppu)
#
except:
print("(Step 21Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - RECEIVE CONTROL & COMMAND READY VIA PIPE
# ---------------------------------------------------------------------------------------
print('(Step 22A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ3IMAGE4PPU ', time4xi())
#
try:
channel3readconsume4ppu = response4read3image['CONSUMERCHANNEL']
message3receive4ppu = channel3readconsume4ppu.recv()
print("(Step 22B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel3readconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ready3read4ppu
except:
print('(Step 22Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH READ3IMAGE4PPU ', time4xi())
# -----------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - IMAGE PPUXI
# -----------------------------------------------------------------------------------------
print('(Step 23A/700) OF PPU3IMAGE4XI5TEST - TRYING FILE OPERATIONS WITH 3D IMAGE PPUXI ', time4xi())
try:
path3image = '..//..//..//..//..//web//images//png//dragonxi.png'
file3image = open(path3image)
print("(Step 23B/700) OF PPU3IMAGE4XI5TEST - FILENO: ", file3image.fileno( ))
print("(Step 23C/700) OF PPU3IMAGE4XI5TEST - MODE: ", file3image.mode)
print("(Step 23D/700) OF PPU3IMAGE4XI5TEST - NAME: ", file3image.name)
offset3ppu = 10
file3image.seek(offset3ppu)
print("(Step 23E/700) OF PPU3IMAGE4XI5TEST - PERFORMED SEEK WITH OFFSET: ", offset3ppu)
file3image.close()
print("(Step 23F/700) OF PPU3IMAGE4XI5TEST - CLOSED IMAGE FILE: ", path3image)
# FILENO: 3
# MODE: r
# NAME: ..//..//..//..//..//web//images//png//dragonxi.png
# PERFORMED SEEK WITH OFFSET: 10
# CLOSED IMAGE FILE: ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 23Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM FILE OPERATIONS WITH 3D IMAGE: ", path3image)
# -----------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - PUT IMAGE PATH TO QUEUE
# -----------------------------------------------------------------------------------------
print("(Step 24A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
try:
queue3read4ppu.put(path3image)
print("(Step 24B/700) OF PPU3IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path3image)
# ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 24Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
#
# -------------------------------------------------------------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - SIMULATE MANOEUVRE3READIMAGE4PPU THREAD - STATE III - GETS FROM QUEUE AND SENDS EITHER ACK OR NACK VIA PIPE
# -------------------------------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 25A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", time4xi())
try:
response3manoeuvre4read = manoeuvre3readimage4ppu(queue3read4ppu, channel3readconsume4ppu, channel3readpublish4ppu)
print("(Step 25B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", manoeuvre3readimage4ppu)
#
except:
print("(Step 25Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ------------------------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - RECEIVE ACK OR NACK ABOUT IMAGE OPERATION CONTROL & COMMAND VIA PIPE
# ------------------------------------------------------------------------------------------------------
print('(Step 26A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
#
try:
message3receive4ppu = channel3readconsume4ppu.recv()
print("(Step 26D/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel3readconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ack3imageinfo4ppu
except:
print('(Step 26Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# ----------------------------------------------------------------------------------------------------------------------
# PHASE I: READ FUNCTION TESTS - SIMULATE MANOEUVRE3READIMAGE4PPU THREAD - LET MANOEUVRE3READIMAGE4PPU TO GO TO STATE 0
# ----------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 27A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", time4xi())
try:
response3manoeuvre4read = manoeuvre3readimage4ppu(queue3read4ppu, channel3readconsume4ppu, channel3readpublish4ppu)
print("(Step 27B/700) OF PPU3IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4PPU ", response3manoeuvre4read)
# {'CODE3NACK4PPU': ' ',
# 'STATE3MANOEUVRE4PPU': 0,
# 'MESSAGE3PUT4PPU': 'default3read4ppu',
# 'MESSAGE3SEND4PPU': 'default3read4ppu',
# 'MESSAGE3RECEIVE4PPU': 'default3read4ppu',
# 'ACK3INFO4PPU': False,
# 'MESSAGE3GET4PPU': 'default3read4ppu',
# 'CODE3ACK4PPU': ' 0D-'}
except:
print("(Step 27Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3READIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - ESTABLISH CONTROL & COMMAND
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 28A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL & COMMAND WITH WRITE2IMAGE4PPU ', time4xi())
print('=' *33)
#
respon4write3image = {}
task4write3image = None # WE ONLY WANT TO ESTABLISH CONTROL AND CONTROL FIRST
try:
response4write3image = write3image4ppu(task4write3image)
print('(Step 28B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL & COMMAND WITH WRITE2IMAGE4PPU : ', response4write3image)
# {'QUEUE': , 'PUBLISHERCHANNEL': , 'CONSUMERCHANNEL': }
queue3write4ppu = response4write3image['QUEUE']
channel3writepublish4ppu = response4write3image['PUBLISHERCHANNEL']
channel3writeconsume4ppu = response4write3image['CONSUMERCHANNEL']
except:
print('(Step 28Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL & COMMAND WITH WRITE2IMAGE4PPU ', time4xi())
# -------------------------------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - SEND CONTROL & COMMAND COPY VIA PIPE FOR MANOEUVRE3WRITEIMAGE4PPU TO RECEIVE
# -------------------------------------------------------------------------------------------------------------
print('(Step 29A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH WRITE2IMAGE4PPU ', time4xi())
#
try:
message3send4ppu = "copy3write4ppu"
channel3writepublish4ppu = response4write3image['PUBLISHERCHANNEL']
channel3writepublish4ppu.send(message3send4ppu)
print("(Step 29B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel3writepublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
# copy3write4ppu
except:
print('(Step 29Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH WRITE2IMAGE4PPU ', time4xi())
# -----------------------------------------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - SIMULATE MANOEUVRE3WRITEIMAGE4PPU - LET IT TO RECEIVE COPY AND TO SEND ROGER VIA PIPE
# -----------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 30A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", time4xi())
try:
response3manoeuvre4write = manoeuvre3writeimage4ppu(queue3write4ppu, channel3writeconsume4ppu, channel3writepublish4ppu)
print("(Step 30B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", manoeuvre3writeimage4ppu)
#
except:
print("(Step 30Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------
print('(Step 31A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH WRITE2IMAGE4PPU ', time4xi())
#
try:
channel3writeconsume4ppu = response4write3image['CONSUMERCHANNEL']
message3receive4ppu = channel3writeconsume4ppu.recv()
print("(Step 31B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel3writeconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# roger3write4ppu
except:
print('(Step 31Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH WRITE2IMAGE4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE3WRITEIMAGE4PPU TO RECEIVE
# ---------------------------------------------------------------------------------------------------------------
print('(Step 32A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH WRITE2IMAGE4PPU ', time4xi())
#
try:
message3send4ppu = "ready3write4ppu"
channel3writepublish4ppu = response4write3image['PUBLISHERCHANNEL']
channel3writepublish4ppu.send(message3send4ppu)
print("(Step 32B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel3writepublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
# ready3write4ppu
except:
print('(Step 32Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH WRITE2IMAGE4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - SIMULATE MANOEUVRE3WRITEIMAGE4PPU - LET IT RECEIVE READY AND SEND READY
# ---------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 33A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", time4xi())
try:
response3manoeuvre4write = manoeuvre3writeimage4ppu(queue3write4ppu, channel3writeconsume4ppu, channel3writepublish4ppu)
print("(Step 33B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", manoeuvre3writeimage4ppu)
#
except:
print("(Step 33Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - RECEIVE CONTROL & COMMAND READY VIA PIPE
# ---------------------------------------------------------------------------------------
print('(Step 34A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH WRITE2IMAGE4PPU ', time4xi())
#
try:
channel3writeconsume4ppu = response4write3image['CONSUMERCHANNEL']
message3receive4ppu = channel3writeconsume4ppu.recv()
print("(Step 34B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel3writeconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ready3write4ppu
except:
print('(Step 34Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH WRITE2IMAGE4PPU ', time4xi())
# -----------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - IMAGE PPUXI
# -----------------------------------------------------------------------------------------
print('(Step 35A/700) OF PPU3IMAGE4XI5TEST - TRYING FILE OPERATIONS WITH IMAGE PPUXI ', time4xi())
try:
path3image = '..//..//..//..//..//web//images//png//dragonxi.png'
file3image = open(path3image)
print("(Step 35B/700) OF PPU3IMAGE4XI5TEST - FILENO: ", file3image.fileno( ))
print("(Step 35C/700) OF PPU3IMAGE4XI5TEST - MODE: ", file3image.mode)
print("(Step 35D/700) OF PPU3IMAGE4XI5TEST - NAME: ", file3image.name)
offset3ppu = 10
file3image.seek(offset3ppu)
print("(Step 35E/700) OF PPU3IMAGE4XI5TEST - PERFORMED SEEK WITH OFFSET: ", offset3ppu)
file3image.close()
print("(Step 35F/700) OF PPU3IMAGE4XI5TEST - CLOSED IMAGE FILE: ", path3image)
# FILENO: 3
# MODE: r
# NAME: ..//..//..//..//..//web//images//png//dragonxi.png
# PERFORMED SEEK WITH OFFSET: 10
# CLOSED IMAGE FILE: ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 35Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM FILE OPERATIONS WITH IMAGE: ", path3image)
# -----------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - PUT IMAGE PATH TO QUEUE
# -----------------------------------------------------------------------------------------
print("(Step 36A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PUT 3D IMAGE PATH TO QUEUE ", time4xi())
try:
queue3write4ppu.put(path3image)
print("(Step 36B/700) OF PPU3IMAGE4XI5TEST - PUT TO QUEUE 3D IMAGE PATH: ", path3image)
# ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 36Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PUT 3D IMAGE PATH TO QUEUE ", time4xi())
#
# ---------------------------------------------------------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - SIMULATE MANOEUVRE3WRITEIMAGE4PPU - STATE III - GETS FROM QUEUE AND SENDS EITHER ACK OR NACK VIA PIPE
# ---------------------------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 37A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", time4xi())
try:
response3manoeuvre4write = manoeuvre3writeimage4ppu(queue3write4ppu, channel3writeconsume4ppu, channel3writepublish4ppu)
print("(Step 37B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", manoeuvre3writeimage4ppu)
#
except:
print("(Step 37Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# -----------------------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - RECEIVE ACK OR NACK ABOUT IMAGE OPERATION CONTROL & COMMAND VIA PIPE
# ------------------------------------------------------------------------------------------------------
print('(Step 38A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
#
try:
message3receive4ppu = channel3writeconsume4ppu.recv()
print("(Step 38D/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel3writeconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ack3imageinfo4ppu
except:
print('(Step 38Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# -------------------------------------------------------------------------------------------------------------------
# PHASE I: WRITE FUNCTION TESTS - SIMULATE MANOEUVRE3WRITEIMAGE4PPU - LET MANOEUVRE3WRITEIMAGE4PPU TO GO TO STATE 0
# -------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 39A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", time4xi())
try:
response3manoeuvre4write = manoeuvre3writeimage4ppu(queue3write4ppu, channel3writeconsume4ppu, channel3writepublish4ppu)
print("(Step 39B/700) OF PPU3IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4PPU ", response3manoeuvre4write)
# {'CODE3NACK4PPU': ' ',
# 'STATE3MANOEUVRE4PPU': 0,
# 'MESSAGE3PUT4PPU': 'default3write4ppu',
# 'MESSAGE3SEND4PPU': 'default3write4ppu',
# 'MESSAGE3RECEIVE4PPU': 'default3write4ppu',
# 'ACK3INFO4PPU': False,
# 'MESSAGE3GET4PPU': 'default3write4ppu',
# 'CODE3ACK4PPU': ' 0D-'}
except:
print("(Step 39Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3WRITEIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - ESTABLISH CONTROL & COMMAND
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 40A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL & COMMAND WITH COPY3IMAGE4PPU ', time4xi())
print('=' *33)
#
response4copy3image = {}
task4copy3image = None # WE ONLY WANT TO ESTABLISH CONTROL AND CONTROL FIRST
try:
response4copy3image = copy3image4ppu(task4copy3image)
print('(Step 40B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL & COMMAND WITH COPY3IMAGE4PPU : ', response4copy3image)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }
queue3copy4ppu = response4copy3image['QUEUE']
channel3copypublish4ppu = response4copy3image['PUBLISHERCHANNEL']
channel3copyconsume4ppu = response4copy3image['CONSUMERCHANNEL']
except:
print('(Step 40Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL & COMMAND WITH COPY3IMAGE4PPU ', time4xi())
# -----------------------------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - SEND CONTROL & COMMAND COPY VIA PIPE FOR MANOEUVRE3COPYIMAGE4PPU TO RECEIVE
# -----------------------------------------------------------------------------------------------------------
print('(Step 41A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3IMAGE4PPU ', time4xi())
#
try:
message3send4ppu = "copy3copy4ppu"
channel3copypublish4ppu.send(message3send4ppu)
print("(Step 41B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel3copypublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
# copy3copy4ppu
except:
print('(Step 41Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3IMAGE4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET IT TO RECEIVE COPY AND TO SEND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 42A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copyimage4ppu(queue3copy4ppu, channel3copyconsume4ppu, channel3copypublish4ppu)
print("(Step 42B/700) OF PPU3IMAGE4XI5TEST - PERFORMED MANOEUVRE3COPYIMAGE4PPU, RESPONSE2MANOEUVRE4COPY: ", response3manoeuvre4copy)
#
except:
print("(Step 42Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------
print('(Step 43A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3IMAGE4PPU ', time4xi())
#
try:
message3receive4ppu = channel3copyconsume4ppu.recv()
print("(Step 43B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel3copyconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# roger3copy4ppu
except:
print('(Step 43Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3IMAGE4PPU ', time4xi())
# ------------------------------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE3COPYIMAGE4PPU TO RECEIVE
# ------------------------------------------------------------------------------------------------------------
print('(Step 44A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3IMAGE4PPU ', time4xi())
#
try:
message3send4ppu = "ready3copy4ppu"
channel3copypublish4ppu.send(message3send4ppu)
print("(Step 44B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel3copypublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
#
except:
print('(Step 44Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3IMAGE4PPU ', time4xi())
# -------------------------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET IT RECEIVE READY AND SEND READY
# -------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 45A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copyimage4ppu(queue3copy4ppu, channel3copyconsume4ppu, channel3copypublish4ppu)
print("(Step 45B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", manoeuvre3copyimage4ppu)
#
except:
print("(Step 45Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - RECEIVE CONTROL & COMMAND READY VIA PIPE
# ---------------------------------------------------------------------------------------
print('(Step 46A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3IMAGE4PPU ', time4xi())
#
try:
message3receive4ppu = channel3copyconsume4ppu.recv()
print("(Step 46B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel3copyconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ready3copy4ppu
except:
print('(Step 46Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3IMAGE4PPU ', time4xi())
# -----------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - IMAGE PPUXI COPY OPERATIONS
# -----------------------------------------------------------------------------------------
print('(Step 47A/700) OF PPU3IMAGE4XI5TEST - TRYING FILE OPERATIONS WITH IMAGE PPUXI ', time4xi())
try:
path3image = '..//..//..//..//..//web//images//png//dragonxi.png'
file3image = open(path3image)
print("(Step 47B/700) OF PPU3IMAGE4XI5TEST - FILENO: ", file3image.fileno( ))
print("(Step 47C/700) OF PPU3IMAGE4XI5TEST - MODE: ", file3image.mode)
print("(Step 47D/700) OF PPU3IMAGE4XI5TEST - NAME: ", file3image.name)
offset3ppu = 10
file3image.seek(offset3ppu)
print("(Step 47E/700) OF PPU3IMAGE4XI5TEST - PERFORMED SEEK WITH OFFSET: ", offset3ppu)
file3image.close()
print("(Step 47F/700) OF PPU3IMAGE4XI5TEST - CLOSED IMAGE FILE: ", path3image)
# FILENO: 3
# MODE: r
# NAME: ..//..//..//..//..//web//images//png//dragonxi.png
# PERFORMED SEEK WITH OFFSET: 10
# CLOSED IMAGE FILE: ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 47Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM FILE OPERATIONS WITH IMAGE: ", path3image)
# -----------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - PUT IMAGE PATH TO QUEUE
# -----------------------------------------------------------------------------------------
print("(Step 48A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
try:
queue3copy4ppu.put(path3image)
print("(Step 48B/700) OF PPU3IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path3image)
# ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 48Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
# -------------------------------------------------------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - STATE III - GETS FROM QUEUE AND SENDS EITHER ACK OR NACK VIA PIPE
# -------------------------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 49A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copyimage4ppu(queue3copy4ppu, channel3copyconsume4ppu, channel3copypublish4ppu)
print("(Step 49B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", manoeuvre3copyimage4ppu)
#
except:
print("(Step 49Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ----------------------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - RECEIVE ACK OR NACK ABOUT IMAGE OPERATION CONTROL & COMMAND VIA PIPE
# ----------------------------------------------------------------------------------------------------
print('(Step 50A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
#
try:
message3receive4ppu = channel3copyconsume4ppu.recv()
print("(Step 50B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel3copyconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ack3imageinfo4ppu
except:
print('(Step 50Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# ----------------------------------------------------------------------------------------------------------------
# PHASE I: COPY FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET MANOEUVRE3COPYIMAGE4PPU TO GO TO STATE 0
# ----------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 51A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copyimage4ppu(queue3copy4ppu, channel3copyconsume4ppu, channel3copypublish4ppu)
print("(Step 51B/700) OF PPU3IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4PPU ", response3manoeuvre4copy)
# GOT RESPONSE2MANOEUVRE4PPU {'CODE3NACK4PPU': ' ',
# 'STATE3MANOEUVRE4PPU': 0,
# 'MESSAGE3PUT4PPU': 'default3copy4ppu',
# 'MESSAGE3SEND4PPU': 'default3copy4ppu',
# 'MESSAGE3RECEIVE4PPU': 'default3copy4ppu',
# 'ACK3INFO4PPU': False,
# 'MESSAGE3GET4PPU': 'default3copy4ppu',
# 'CODE3ACK4PPU': ' 0D-'}
except:
print("(Step 51Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - ESTABLISH CONTROL & COMMAND
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 60A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL & COMMAND WITH COPY3IMAGETOBUFFER4PPU ', time4xi())
print('=' *33)
#
response4copy3imagetobuffer = {}
task4copy3imagetobuffer = None # WE ONLY WANT TO ESTABLISH CONTROL AND CONTROL FIRST
try:
response4copy3imagetobuffer = copy3imagetobuffer4ppu(task4copy3imagetobuffer)
print('(Step 60B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL & COMMAND WITH COPY3IMAGETOBUFFER4PPU : ', response4copy3imagetobuffer)
#
queue4copy3imagetobuffer4ppu = response4copy3imagetobuffer['QUEUE']
channel4copy3imagetobufferpublish4ppu = response4copy3imagetobuffer['PUBLISHERCHANNEL']
channel4copy3imagetobufferconsume4ppu = response4copy3imagetobuffer['CONSUMERCHANNEL']
except:
print('(Step 60Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL & COMMAND WITH COPY3IMAGETOBUFFER4PPU ', time4xi())
# -----------------------------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - SEND CONTROL & COMMAND COPY VIA PIPE FOR MANOEUVRE3COPYIMAGE4PPU TO RECEIVE
# -----------------------------------------------------------------------------------------------------------
print('(Step 61A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3IMAGETOBUFFER4PPU ', time4xi())
#
try:
message3send4ppu = "copy3copyimagetobuffer4ppu"
channel4copy3imagetobufferpublish4ppu.send(message3send4ppu)
print("(Step 61B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel4copy3imagetobufferpublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
# copy3copyimagetobuffer4ppu
except:
print('(Step 61Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3IMAGETOBUFFER4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET IT TO RECEIVE COPY AND TO SEND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 62A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copyimagetobuffer4ppu(queue4copy3imagetobuffer4ppu, channel4copy3imagetobufferconsume4ppu, channel4copy3imagetobufferpublish4ppu)
print("(Step 62B/700) OF PPU3IMAGE4XI5TEST - PERFORMED MANOEUVRE3COPYIMAGE4PPU, RESPONSE2MANOEUVRE4COPY: ", response3manoeuvre4copy)
#
except:
print("(Step 62Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------
print('(Step 63A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3IMAGETOBUFFER4PPU ', time4xi())
#
try:
message3receive4ppu = channel4copy3imagetobufferconsume4ppu.recv()
print("(Step 63B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel4copy3imagetobufferconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# roger3copyimagetobuffer4ppu
except:
print('(Step 63Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3IMAGETOBUFFER4PPU ', time4xi())
# ------------------------------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE3COPYIMAGE4PPU TO RECEIVE
# ------------------------------------------------------------------------------------------------------------
print('(Step 64A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3IMAGETOBUFFER4PPU ', time4xi())
#
try:
message3send4ppu = "ready3copyimagetobuffer4ppu"
channel4copy3imagetobufferpublish4ppu.send(message3send4ppu)
print("(Step 64B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel4copy3imagetobufferpublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
#
except:
print('(Step 64Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3IMAGETOBUFFER4PPU ', time4xi())
# -------------------------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET IT RECEIVE READY AND SEND READY
# -------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 65A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copyimagetobuffer4ppu(queue4copy3imagetobuffer4ppu, channel4copy3imagetobufferconsume4ppu, channel4copy3imagetobufferpublish4ppu)
print("(Step 65B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", manoeuvre3copyimage4ppu)
#
except:
print("(Step 65Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - RECEIVE CONTROL & COMMAND READY VIA PIPE
# ---------------------------------------------------------------------------------------
print('(Step 66A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3IMAGETOBUFFER4PPU ', time4xi())
#
try:
message3receive4ppu = channel4copy3imagetobufferconsume4ppu.recv()
print("(Step 66B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel4copy3imagetobufferconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ready3copyimagetobuffer4ppu
except:
print('(Step 66Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3IMAGETOBUFFER4PPU ', time4xi())
# -----------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - IMAGE PPUXI COPY OPERATIONS
# -----------------------------------------------------------------------------------------
print('(Step 67A/700) OF PPU3IMAGE4XI5TEST - TRYING FILE OPERATIONS WITH IMAGE PPUXI ', time4xi())
try:
path3image = '..//..//..//..//..//web//images//png//dragonxi.png'
file3image = open(path3image)
print("(Step 67B/700) OF PPU3IMAGE4XI5TEST - FILENO: ", file3image.fileno( ))
print("(Step 67C/700) OF PPU3IMAGE4XI5TEST - MODE: ", file3image.mode)
print("(Step 67D/700) OF PPU3IMAGE4XI5TEST - NAME: ", file3image.name)
offset3ppu = 10
file3image.seek(offset3ppu)
print("(Step 67E/700) OF PPU3IMAGE4XI5TEST - PERFORMED SEEK WITH OFFSET: ", offset3ppu)
file3image.close()
print("(Step 67F/700) OF PPU3IMAGE4XI5TEST - CLOSED IMAGE FILE: ", path3image)
# FILENO: 3
# MODE: r
# NAME: ..//..//..//..//..//web//images//png//dragonxi.png
# PERFORMED SEEK WITH OFFSET: 10
# CLOSED IMAGE FILE: ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 67Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM FILE OPERATIONS WITH IMAGE: ", path3image)
# -----------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - PUT IMAGE PATH TO QUEUE
# -----------------------------------------------------------------------------------------
print("(Step 68A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
try:
queue4copy3imagetobuffer4ppu.put(path3image)
print("(Step 68B/700) OF PPU3IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path3image)
# ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 68Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
# -------------------------------------------------------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - STATE III - GETS FROM QUEUE AND SENDS EITHER ACK OR NACK VIA PIPE
# -------------------------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 69A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copyimagetobuffer4ppu(queue4copy3imagetobuffer4ppu, channel4copy3imagetobufferconsume4ppu, channel4copy3imagetobufferpublish4ppu)
print("(Step 69B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", manoeuvre3copyimage4ppu)
#
except:
print("(Step 69Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ----------------------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - RECEIVE ACK OR NACK ABOUT IMAGE OPERATION CONTROL & COMMAND VIA PIPE
# ----------------------------------------------------------------------------------------------------
print('(Step 70A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
#
try:
message3receive4ppu = channel4copy3imagetobufferconsume4ppu.recv()
print("(Step 70B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel4copy3imagetobufferconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ack3imageinfo4ppu
except:
print('(Step 70Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# ----------------------------------------------------------------------------------------------------------------
# PHASE I: COPY3IMAGETOBUFFER FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET MANOEUVRE3COPYIMAGE4PPU TO GO TO STATE 0
# ----------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 71A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copyimagetobuffer4ppu(queue4copy3imagetobuffer4ppu, channel4copy3imagetobufferconsume4ppu, channel4copy3imagetobufferpublish4ppu)
print("(Step 71B/700) OF PPU3IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4PPU ", response3manoeuvre4copy)
# {'CODE3NACK4PPU': ' ',
# 'STATE3MANOEUVRE4PPU': 0,
# 'MESSAGE3PUT4PPU': 'default3copyimagetobuffer4ppu',
# 'MESSAGE3SEND4PPU': 'default3copyimagetobuffer4ppu',
# 'MESSAGE3RECEIVE4PPU': 'default3copyimagetobuffer4ppu',
# 'ACK3INFO4PPU': False,
# 'MESSAGE3GET4PPU': 'default3copyimagetobuffer4ppu',
# 'CODE3ACK4PPU': ' 0D-'}
except:
print("(Step 71Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - ESTABLISH CONTROL & COMMAND
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 80A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL & COMMAND WITH COPY3BUFFERTOIMAGE4PPU ', time4xi())
print('=' *33)
#
response4copybuffertoimage = {}
task4copybuffertoimage = None # WE ONLY WANT TO ESTABLISH CONTROL AND CONTROL FIRST
try:
response4copybuffertoimage = copy3buffertoimage4ppu(task4copybuffertoimage)
print('(Step 80B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL & COMMAND WITH COPY3BUFFERTOIMAGE4PPU : ', response4copybuffertoimage)
#
queue4copybuffertoimage4ppu = response4copybuffertoimage['QUEUE']
channel4copybuffertoimagepublish4ppu = response4copybuffertoimage['PUBLISHERCHANNEL']
channel4copybuffertoimageconsume4ppu = response4copybuffertoimage['CONSUMERCHANNEL']
except:
print('(Step 80Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL & COMMAND WITH COPY3BUFFERTOIMAGE4PPU ', time4xi())
# -----------------------------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - SEND CONTROL & COMMAND COPY VIA PIPE FOR MANOEUVRE3COPYIMAGE4PPU TO RECEIVE
# -----------------------------------------------------------------------------------------------------------
print('(Step 81A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3BUFFERTOIMAGE4PPU ', time4xi())
#
try:
message3send4ppu = "copy3copybuffertoimage4ppu"
channel4copybuffertoimagepublish4ppu.send(message3send4ppu)
print("(Step 81B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel4copybuffertoimagepublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
# copy3copybuffertoimage4ppu
except:
print('(Step 81Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3BUFFERTOIMAGE4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET IT TO RECEIVE COPY AND TO SEND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 82A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copybuffertoimage4ppu(queue4copybuffertoimage4ppu, channel4copybuffertoimageconsume4ppu, channel4copybuffertoimagepublish4ppu)
print("(Step 82B/700) OF PPU3IMAGE4XI5TEST - PERFORMED MANOEUVRE3COPYIMAGE4PPU, RESPONSE2MANOEUVRE4COPY: ", response3manoeuvre4copy)
#
except:
print("(Step 82Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------
print('(Step 83A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3BUFFERTOIMAGE4PPU ', time4xi())
#
try:
message3receive4ppu = channel4copybuffertoimageconsume4ppu.recv()
print("(Step 83B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel4copybuffertoimageconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# roger3copybuffertoimage4ppu
except:
print('(Step 83Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3BUFFERTOIMAGE4PPU ', time4xi())
# ------------------------------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE3COPYIMAGE4PPU TO RECEIVE
# ------------------------------------------------------------------------------------------------------------
print('(Step 84A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3BUFFERTOIMAGE4PPU ', time4xi())
#
try:
message3send4ppu = "ready3copybuffertoimage4ppu"
channel4copybuffertoimagepublish4ppu.send(message3send4ppu)
print("(Step 84B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel4copybuffertoimagepublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
# ready3copybuffertoimage4ppu
except:
print('(Step 84Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH COPY3BUFFERTOIMAGE4PPU ', time4xi())
# -------------------------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET IT RECEIVE READY AND SEND READY
# -------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 85A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copybuffertoimage4ppu(queue4copybuffertoimage4ppu, channel4copybuffertoimageconsume4ppu, channel4copybuffertoimagepublish4ppu)
print("(Step 85B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", manoeuvre3copyimage4ppu)
#
except:
print("(Step 85Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - RECEIVE CONTROL & COMMAND READY VIA PIPE
# ---------------------------------------------------------------------------------------
print('(Step 86A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3BUFFERTOIMAGE4PPU ', time4xi())
#
try:
message3receive4ppu = channel4copybuffertoimageconsume4ppu.recv()
print("(Step 86B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel4copybuffertoimageconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ready3copybuffertoimage4ppu
except:
print('(Step 86Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH COPY3BUFFERTOIMAGE4PPU ', time4xi())
# -----------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - IMAGE PPUXI COPY OPERATIONS
# -----------------------------------------------------------------------------------------
print('(Step 87A/700) OF PPU3IMAGE4XI5TEST - TRYING FILE OPERATIONS WITH IMAGE PPUXI ', time4xi())
try:
path3image = '..//..//..//..//..//web//images//png//dragonxi.png'
file3image = open(path3image)
print("(Step 87B/700) OF PPU3IMAGE4XI5TEST - FILENO: ", file3image.fileno( ))
print("(Step 87C/700) OF PPU3IMAGE4XI5TEST - MODE: ", file3image.mode)
print("(Step 87D/700) OF PPU3IMAGE4XI5TEST - NAME: ", file3image.name)
offset3ppu = 10
file3image.seek(offset3ppu)
print("(Step 87E/700) OF PPU3IMAGE4XI5TEST - PERFORMED SEEK WITH OFFSET: ", offset3ppu)
file3image.close()
print("(Step 87F/700) OF PPU3IMAGE4XI5TEST - CLOSED IMAGE FILE: ", path3image)
# FILENO: 3
# MODE: r
# NAME: ..//..//..//..//..//web//images//png//dragonxi.png
# PERFORMED SEEK WITH OFFSET: 10
# CLOSED IMAGE FILE: ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 87Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM FILE OPERATIONS WITH IMAGE: ", path3image)
# -----------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - PUT IMAGE PATH TO QUEUE
# -----------------------------------------------------------------------------------------
print("(Step 88A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
try:
queue4copybuffertoimage4ppu.put(path3image)
print("(Step 88B/700) OF PPU3IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path3image)
# ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 88Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
# -------------------------------------------------------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - STATE III - GETS FROM QUEUE AND SENDS EITHER ACK OR NACK VIA PIPE
# -------------------------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 89A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copybuffertoimage4ppu(queue4copybuffertoimage4ppu, channel4copybuffertoimageconsume4ppu, channel4copybuffertoimagepublish4ppu)
print("(Step 89B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", manoeuvre3copyimage4ppu)
#
except:
print("(Step 89Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ----------------------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - RECEIVE ACK OR NACK ABOUT IMAGE OPERATION CONTROL & COMMAND VIA PIPE
# ----------------------------------------------------------------------------------------------------
print('(Step 90A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
#
try:
message3receive4ppu = channel4copybuffertoimageconsume4ppu.recv()
print("(Step 90B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel4copybuffertoimageconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ack3imageinfo4ppu
except:
print('(Step 90Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# ----------------------------------------------------------------------------------------------------------------
# PHASE I: COPY3BUFFERTOIMAGE FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET MANOEUVRE3COPYIMAGE4PPU TO GO TO STATE 0
# ----------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 91A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3copybuffertoimage4ppu(queue4copybuffertoimage4ppu, channel4copybuffertoimageconsume4ppu, channel4copybuffertoimagepublish4ppu)
print("(Step 91B/700) OF PPU3IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4PPU ", response3manoeuvre4copy)
# {'CODE3NACK4PPU': ' ',
# 'STATE3MANOEUVRE4PPU': 0,
# 'MESSAGE3PUT4PPU': 'default3copybuffertoimage4ppu',
# 'MESSAGE3SEND4PPU': 'default3copybuffertoimage4ppu',
# 'MESSAGE3RECEIVE4PPU': 'default3copybuffertoimage4ppu',
# 'ACK3INFO4PPU': False,
# 'MESSAGE3GET4PPU': 'default3copybuffertoimage4ppu',
# 'CODE3ACK4PPU': ' 0D-'}
except:
print("(Step 91Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - ESTABLISH CONTROL & COMMAND
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 92A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL & COMMAND WITH MAP3IMAGE4PPU ', time4xi())
print('=' *33)
#
response4map3image = {}
task4map3image = None # WE ONLY WANT TO ESTABLISH CONTROL AND CONTROL FIRST
try:
response4map3image = map3image4ppu(task4map3image)
print('(Step 92B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL & COMMAND WITH MAP3IMAGE4PPU : ', response4map3image)
# {'QUEUE': , 'PUBLISHERCHANNEL': , 'CONSUMERCHANNEL': }
queue4map3image4ppu = response4map3image['QUEUE']
channel4map3imagepublish4ppu = response4map3image['PUBLISHERCHANNEL']
channel4map3imageconsume4ppu = response4map3image['CONSUMERCHANNEL']
except:
print('(Step 92Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL & COMMAND WITH MAP3IMAGE4PPU ', time4xi())
# -----------------------------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - SEND CONTROL & COMMAND COPY VIA PIPE FOR MANOEUVRE3COPYIMAGE4PPU TO RECEIVE
# -----------------------------------------------------------------------------------------------------------
print('(Step 93A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH MAP3IMAGE4PPU ', time4xi())
#
try:
message3send4ppu = "copy3mapimage4ppu"
channel4map3imagepublish4ppu.send(message3send4ppu)
print("(Step 93B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel4map3imagepublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
# copy3mapimage4ppu
except:
print('(Step 93Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH MAP3IMAGE4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET IT TO RECEIVE COPY AND TO SEND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 94A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3mapimage4ppu(queue4map3image4ppu, channel4map3imageconsume4ppu, channel4map3imagepublish4ppu)
print("(Step 94B/700) OF PPU3IMAGE4XI5TEST - PERFORMED MANOEUVRE3COPYIMAGE4PPU, RESPONSE2MANOEUVRE4COPY: ", response3manoeuvre4copy)
#
except:
print("(Step 94Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - RECEIVE CONTROL & COMMAND ROGER VIA PIPE
# ---------------------------------------------------------------------------------------------
print('(Step 95A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH MAP3IMAGE4PPU ', time4xi())
#
try:
message3receive4ppu = channel4map3imageconsume4ppu.recv()
print("(Step 95B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel4map3imageconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# roger3mapimage4ppu
except:
print('(Step 95Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH MAP3IMAGE4PPU ', time4xi())
# ------------------------------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - SEND CONTROL & COMMAND READY VIA PIPE FOR MANOEUVRE3COPYIMAGE4PPU TO RECEIVE
# ------------------------------------------------------------------------------------------------------------
print('(Step 96A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SEND CONTROL & COMMAND VIA PIPE WITH MAP3IMAGE4PPU ', time4xi())
#
try:
message3send4ppu = "ready3mapimage4ppu"
channel4map3imagepublish4ppu.send(message3send4ppu)
print("(Step 96B/700) OF PPU3IMAGE4XI5TEST - SENT TO CHANNEL3PUBLISH4PPU: ", channel4map3imagepublish4ppu, " MESSAGE3SEND4PPU: " , message3send4ppu)
# ready3mapimage4ppu
except:
print('(Step 84Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SEND CONTROL & COMMAND VIA PIPE WITH MAP3IMAGE4PPU ', time4xi())
# -------------------------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET IT RECEIVE READY AND SEND READY
# -------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 97A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3mapimage4ppu(queue4map3image4ppu, channel4map3imageconsume4ppu, channel4map3imagepublish4ppu)
print("(Step 97B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", manoeuvre3copyimage4ppu)
#
except:
print("(Step 97Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - RECEIVE CONTROL & COMMAND READY VIA PIPE
# ---------------------------------------------------------------------------------------
print('(Step 98A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND VIA PIPE WITH MAP3IMAGE4PPU ', time4xi())
#
try:
message3receive4ppu = channel4map3imageconsume4ppu.recv()
print("(Step 98B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel4map3imageconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ready3mapimage4ppu
except:
print('(Step 86Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND VIA PIPE WITH MAP3IMAGE4PPU ', time4xi())
# -----------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - IMAGE PPUXI COPY OPERATIONS
# -----------------------------------------------------------------------------------------
print('(Step 99A/700) OF PPU3IMAGE4XI5TEST - TRYING FILE OPERATIONS WITH IMAGE PPUXI ', time4xi())
try:
path3image = '..//..//..//..//..//web//images//png//dragonxi.png'
file3image = open(path3image)
print("(Step 99B/700) OF PPU3IMAGE4XI5TEST - FILENO: ", file3image.fileno( ))
print("(Step 99C/700) OF PPU3IMAGE4XI5TEST - MODE: ", file3image.mode)
print("(Step 99D/700) OF PPU3IMAGE4XI5TEST - NAME: ", file3image.name)
offset3ppu = 10
file3image.seek(offset3ppu)
print("(Step 99E/700) OF PPU3IMAGE4XI5TEST - PERFORMED SEEK WITH OFFSET: ", offset3ppu)
file3image.close()
print("(Step 99F/700) OF PPU3IMAGE4XI5TEST - CLOSED IMAGE FILE: ", path3image)
# FILENO: 3
# MODE: r
# NAME: ..//..//..//..//..//web//images//png//dragonxi.png
# PERFORMED SEEK WITH OFFSET: 10
# CLOSED IMAGE FILE: ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 87Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM FILE OPERATIONS WITH IMAGE: ", path3image)
# -----------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - PUT IMAGE PATH TO QUEUE
# -----------------------------------------------------------------------------------------
print("(Step 100A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PUT IMAGE PATH TO QUEUE ", time4xi())
try:
queue4map3image4ppu.put(path3image)
print("(Step 100B/700) OF PPU3IMAGE4XI5TEST - PUT TO QUEUE IMAGE PATH: ", path3image)
# ..//..//..//..//..//web//images//png//dragonxi.png
except:
print("(Step 88Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PUT IMAGE PATH TO QUEUE ", time4xi())
# -------------------------------------------------------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - STATE III - GETS FROM QUEUE AND SENDS EITHER ACK OR NACK VIA PIPE
# -------------------------------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 101A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3mapimage4ppu(queue4map3image4ppu, channel4map3imageconsume4ppu, channel4map3imagepublish4ppu)
print("(Step 101B/700) OF PPU3IMAGE4XI5TEST - PERFORMED TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", manoeuvre3copyimage4ppu)
#
except:
print("(Step 101Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ----------------------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - RECEIVE ACK OR NACK ABOUT IMAGE OPERATION CONTROL & COMMAND VIA PIPE
# ----------------------------------------------------------------------------------------------------
print('(Step 102A/700) OF PPU3IMAGE4XI5TEST - TRYING TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
#
try:
message3receive4ppu = channel4map3imageconsume4ppu.recv()
print("(Step 102B/700) OF PPU3IMAGE4XI5TEST - RECEIVED FROM CHANNEL3CONSUME4PPU: ", channel4map3imageconsume4ppu, " CONTROL & COMMAND: ", message3receive4ppu)
# ack3imageinfo4ppu
except:
print('(Step 90Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RECEIVE CONTROL & COMMAND ABOUT IMAGE OPERTION VIA PIPE ', time4xi())
# ----------------------------------------------------------------------------------------------------------------
# PHASE I: MAP2IMAGE FUNCTION TESTS - SIMULATE MANOEUVRE3COPYIMAGE4PPU - LET MANOEUVRE3COPYIMAGE4PPU TO GO TO STATE 0
# ----------------------------------------------------------------------------------------------------------------
if ack3simulate4ppu is True:
print("(Step 103A/700) OF PPU3IMAGE4XI5TEST - TRYING TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
try:
response3manoeuvre4copy = manoeuvre3mapimage4ppu(queue4map3image4ppu, channel4map3imageconsume4ppu, channel4map3imagepublish4ppu)
print("(Step 103B/700) OF PPU3IMAGE4XI5TEST - GOT RESPONSE2MANOEUVRE4PPU ", response3manoeuvre4copy)
# {'CODE3NACK4PPU': ' ',
# 'STATE3MANOEUVRE4PPU': 0,
# 'MESSAGE3PUT4PPU': 'default3map4ppu',
# 'MESSAGE3SEND4PPU': 'default3map4ppu',
# 'MESSAGE3RECEIVE4PPU': 'default3map4ppu',
# 'ACK3INFO4PPU': False,
# 'MESSAGE3GET4PPU': 'default3map4ppu',
# 'CODE3ACK4PPU': ' 0D-'}
except:
print("(Step 103Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO PERFORM TARGET FUNCTION MANOEUVRE3COPYIMAGE4PPU ", time4xi())
else:
pass # trust activated thread
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 105A/700) OF PPU3IMAGE4XI5TEST - CREATING IMAGE4PPU OBJECT ', time4xi())
print('=' *33)
#
try:
# ---------------------------------------------------------------------------------------------
# CREATE WITH OBJECT
# ---------------------------------------------------------------------------------------------
imageobject3ppu = PPU3Image4Xi()
print('(Step 105B/700) OF PPU3IMAGE4XI5TEST - CREATED IMAGE4PPU OBJECT: ', imageobject3ppu)
#
except:
print('(Step 105Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO CREATE IMAGE4PPU OBJECT')
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - GET METHOD
# ---------------------------------------------------------------------------------------------
print('(Step 106A1/700) OF PPU3IMAGE4XI5TEST - TRYING TO GET 3D IMAGE INFO ', time4xi())
try:
response4get3imageinfo = imageobject3ppu.get3imageinfo()
print('(Step 106A2/700) OF PPU3IMAGE4XI5TEST - GOT 3D IMAGE INFO ', time4xi())
keys3response = response4get3imageinfo.keys()
for key3response in sorted(keys3response):
print(key3response, ' : ', response4get3imageinfo[key3response])
# ACK2RETURN : 1D-1E-2C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-12B-14B-15B-16B-17B-19B-19D-20B-20C-21A1-22B1-22C1-23B-24B-25B-26B-27B-28B-29B-30B-31B-32H-34H-35H-36B-37B-38B-39B-
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 08:00:17 10/10/ ...
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 08: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 08:00:16 10/10/11 Pacific Dayl ...
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 08:00:17 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 800
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 08:00:16 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FUNCTION3CALLBACK :
# HEIGHT : 800
# NACK2RETURN :
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 800
# SLICEPITCH : 800
# WIDTH : 800
except:
print('(Step 106Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO GET 3D IMAGE INFO ', time4xi())
task4getinfo3image = {}
task4getinfo3image ['HEIGHT'] = 0
task4getinfo3image ['WIDTH'] = 0
task4getinfo3image ['DEPTH'] = 0
response4getinfo3image = {}
print('(Step 106A2/700) OF PPU3IMAGE4XI5TEST - TRYING TO GET SELECTED 3D IMAGE INFO OF PPU DEVICE ', time4xi())
#
try:
response4getinfo3Dimage = imageobject3ppu.get3imageinfo(task4getinfo3image)
keys3response = response4getinfo3Dimage.keys()
print('(Step 106A3/700) OF PPU3IMAGE4XI5TEST - GOT SELECTED 3D IMAGE INFO OF PPU DEVICE ', time4xi())
for key3response in sorted(keys3response):
print(key3response, ' : ', response4getinfo3Dimage[key3response])
# DEPTH : 800
# HEIGHT : 800
# WIDTH : 800
except:
print('(Step 106Z2/700) OF PPU3IMAGE4XI5TEST *** FAILED TO GET SELECTED 3D IMAGE INFO OF PPU DEVICE ', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - GET SUPPORTED 3D IMAGE FORMATS FOR PPU
# ---------------------------------------------------------------------------------------------
print('(Step 106B1/700) OF PPU3IMAGE4XI5TEST - TRYING TO GET SUPPORTED IMAGE FORMATS FOR PPU')
try:
cc3xi = PPU3Image4Xi()
supportedimageformats3ppu = cc3xi.get3supportedimageformats()
print('(Step 106B2/33) OF PPU4XI5TEST - GOT SUPPORTED 3D IMAGE FORMATS FOR PPU: ', supportedimageformats3ppu)
#
except:
print('(Step 102Z/33) OF PPU4XI5TEST *** FAILED TO GET SUPPORTED 3D IMAGE FORMATS FOR PPU***')
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - SET METHOD
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 107A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET 3D IMAGE ', time4xi())
print('=' *33)
#
# ---------------------------------------------------------------------------------------------
# (4) INITIALIZE TASK DICTIONARY
# ---------------------------------------------------------------------------------------------
task4set3image = {}
# ---------------------------------------------------------------------------------------------
# (5) DEFINE CONTEXT - REQUIRED
# ---------------------------------------------------------------------------------------------
task4set3image ['CONTEXT'] = context2ppu
# ---------------------------------------------------------------------------------------------
# (6) DEFINE DEVICE - EXTRA
# ---------------------------------------------------------------------------------------------
task4set3image ['DEVICE'] = device2ppu
# ---------------------------------------------------------------------------------------------
# (7) DEFINE ERROR CODE - REQUIRED
# ---------------------------------------------------------------------------------------------
task4set3image ['CODE3ERROR'] = 0
# ---------------------------------------------------------------------------------------------
# (8) QUEUE - EXTRA
# ---------------------------------------------------------------------------------------------
print('(Step 108A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET QUEUE4XI ', time4xi())
task4set3image ['QUEUE'] = None
try:
task4set3image ['QUEUE'] = Queue4Xi()
print('(Step 108B/700) OF PPU3IMAGE4XI5TEST - QUEUE : ', task4set3image ['QUEUE'])
#
except:
print('(Step 108Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO CREATE QUEUE4XI ', time4xi())
# ---------------------------------------------------------------------------------------------
# (9) PIPE
# ---------------------------------------------------------------------------------------------
print('(Step 109A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET PIPE4XI ', time4xi())
task4set3image ['PIPE'] = None
try:
task4set3image ['PIPE'] = Pipe4Xi()
print('(Step 109B/700) OF PPU3IMAGE4XI5TEST - PIPE : ', task4set3image ['PIPE'])
#
except:
print('(Step 109Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SET PIPE4XI ', time4xi())
# ---------------------------------------------------------------------------------------------
# (10) SET COMMAND QUEUE - EXTRA
# ---------------------------------------------------------------------------------------------
task4set3image ['COMMANDQUEUE'] = None
print('(Step 110A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET COMMAND QUEUEFOR IMAGE4PPU ', time4xi())
try:
task4set3image ['COMMANDQUEUE'] = create2commandqueue4ppu()
print('(Step 110B/700) OF PPU3IMAGE4XI5TEST - COMMAND QUEUE OF IMAGE4PPU: ', task4set3image ['COMMANDQUEUE'])
#
except:
print('(Step 110Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SET COMMAND QUEUE FOR IMAGE4PPU ', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - SET IMAGE WITH METHOD
# ---------------------------------------------------------------------------------------------
print('(Step 111A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET 3D IMAGE FOR PPU: ', time4xi())
try:
response4set3Dimage = imageobject3ppu.set3image(task4set3image)
keys3response = response4set3Dimage.keys()
print('(Step 111B/700) OF PPU3IMAGE4XI5TEST - SET 3D IMAGE FOR PPU: ', time4xi())
for key3response in sorted(keys3response):
print(key3response, ' : ', response4set3Dimage[key3response])
# ACK2RETURN : 23B-24B-25B-26B-27B-28B-
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 08:00:17 10/10/ ...
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 08: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 08:00:16 10/10/11 Pacific Dayl ...
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 08:00:17 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 800
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 08:00:16 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FUNCTION3CALLBACK :
# HEIGHT : 800
# NACK2RETURN : 21Z1-22Z2-22Z3-29Z1-30Z1-31Z1-32Z1-34Z1-35Z1-36Z1-37Z1-38Z1-39Z1-
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 800
# SLICEPITCH : 800
# WIDTH : 800
except:
print('(Step 111Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SET 3D IMAGE FOR PPU: ', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - RELEASE 3D IMAGE
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 121A/700) OF PPU3IMAGE4XI5TEST - RELEASING 3D IMAGE', time4xi())
print('=' *33)
#
task4release3image = {}
task4release3image ['COUNT3REFERENCE'] = 1
try:
response4release3Dimage = imageobject3ppu.release3image(task4release3image)
keys3response = response4release3Dimage.keys()
print('(Step 111B/700) OF PPU3IMAGE4XI5TEST - RELEASED 3D IMAGE', time4xi())
for key3response in sorted(keys3response):
print(key3response, ' : ', response4release3Dimage[key3response])
# ACK2RETURN :
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 08:00:17 10/10/ ...
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 08: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 08:00:16 10/10/11 Pacific Dayl ...
# COUNT3REFERENCE : 0
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 08:00:17 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 800
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 08:00:16 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FUNCTION3CALLBACK :
# HEIGHT : 800
# NACK2RETURN : 8Z1-
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 800
# SLICEPITCH : 800
# WIDTH : 800
except:
print('(Step 121Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RELEASE 3D IMAGE', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - RETAIN IMAGE
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 122A/700) OF PPU3IMAGE4XI5TEST - RETAINING 3D IMAGE ', time4xi())
print('=' *33)
task4retain3image = {}
task4retain3image ['COUNT3REFERENCE'] = 1
try:
response4retain3Dimage = imageobject3ppu.retain3image(task4retain3image)
keys3response = response4retain3Dimage.keys()
print('(Step 122B/700) OF PPU3IMAGE4XI5TEST - RETAINED 3D IMAGE ', time4xi())
for key3response in sorted(keys3response):
print(key3response, ' : ', response4retain3Dimage[key3response])
# ACK2RETURN : 6D-
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 08:00:17 10/10/ ...
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 08: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 08:00:16 10/10/11 Pacific Dayl ...
# COUNT3REFERENCE : 1
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 08:00:17 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 800
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 08:00:16 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FUNCTION3CALLBACK :
# HEIGHT : 800
# NACK2RETURN :
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 800
# SLICEPITCH : 800
# WIDTH : 800
except:
print('(Step 122Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO RETAIN 3D IMAGE ', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - CREATE AGAIN IMAGE OBJECT AND USE ITS CREATE METHOD
# ---------------------------------------------------------------------------------------------
print('(Step 123A/700) OF PPU3IMAGE4XI5TEST - TRYING TO CREATE 3D IMAGE for PPU ', time4xi())
#
try:
xi3ppu = PPU3Image4Xi()
response4create3Dimage = xi3ppu.create3image()
keys3response = response4create3Dimage.keys()
print('(Step 122B/700) OF PPU3IMAGE4XI5TEST - CREATED 3D IMAGE ', time4xi())
for key3response in sorted(keys3response):
print(key3response, ' : ', response4create3Dimage[key3response])
# ACK2RETURN : 1D-1E-2C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-12B-14B-15B-16B-17B-19B-19D-20B-20C-21A1-22B1-22C1-23B-24B-25B-26B-27B-28B-29B-30B-31B-32H-34H-35H-36B-37B-38B-39B-
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 08:00:17 10/10/ ...
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 08: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 08:00:16 10/10/11 Pacific Dayl ...
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 08:00:17 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 800
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 08:00:16 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FUNCTION3CALLBACK :
# HEIGHT : 800
# NACK2RETURN :
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 800
# SLICEPITCH : 800
# WIDTH : 800
except:
print('(Step 123Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO CREATE 3D IMAGE for PPU ', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - SET IMAGE CALLBACK WITH METHOD
# ---------------------------------------------------------------------------------------------
print('(Step 124A/700) OF PPU3IMAGE4XI5TEST - TRYING TO SET IMAGE CALLBACK WITH METHOD OF OBJECT XI2PPU: ', xi3ppu)
#
try:
callback2ppu = xi3ppu.set3imagecallback()
print('(Step 124B/700) OF PPU3IMAGE4XI5TEST - SET IMAGE WITH CALLBACK TO: ', callback2ppu)
#
except:
print('(Step 124Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SET IMAGE CALLBACK WITH METHOD ***', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - TRACE IMAGES
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 125A/25) OF PPU3IMAGE4XI5TEST - TRYING TO TRACE PPU: ', time4xi())
print('=' *33)
#
trace3ppu = None
try:
trace3ppu = xi3ppu.trace3image()
print('=' *33)
print('(Step 125B/25) OF PPU3IMAGE4XI5TEST - TRACE2PPU: ', trace3ppu)
# {'MESSAGE': '{(Step 2Z0/33) failed; trace3image4ppu-failed {}; time: 08:00:17 10/10/11 Pacific Daylight Time}',
# 'CLASS': 'trace3image4ppu',
# 'METHOD': 'trace3image4ppu'}
print('=' *33)
except:
print('(Step 125Z1/25) OF PPU3IMAGE4XI5TEST *** FAILED TO TRACE PPU: ', trace3ppu)
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - WAIT IMAGES
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 126A/700) OF PPU3IMAGE4XI5TEST - TRYING TO WAIT 3D IMAGE OPERATION FOR PPU ', time4xi())
print('=' *33)
wait2ppu = {}
try:
response4wait3Dimage = xi3ppu.wait3image()
print('(Step 122B/700) OF PPU3IMAGE4XI5TEST - WAITED 3D IMAGE OPERATION FOR PPU ', time4xi())
keys3response = response4wait3Dimage.keys()
for key3response in sorted(keys3response):
print(key3response, ' : ', response4wait3Dimage[key3response])
# ACK2RETURN : 1D-1E-2C-2B-3B-4B-5B-6B-7B-8B-9B-10B-11B-12B-14B-15B-16B-17B-19B-19D-20B-20C-21A1-22B1-22C1-23B-24B-25B-26B-27B-28B-29B-30B-31B-32H-34H-35H-36B-37B-38B-39B-
# BUFFER : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2buffer4ppu-failed ; time: 08:00:17 10/10/ ...
# CALLBACK :
# CODE3ERROR : 0
# COMMANDQUEUE : {'CODE2ERROR': 0, 'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2commandqueue4ppu-failed ; time: 08: ...
# CONTEXT : {'COUNT2REFERENCE': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2context4ppu-failed ; time: 08:00:16 10/10/11 Pacific Dayl ...
# DATA3CALLBACK : {'MESSAGE': '{(Step 1Z1/33) failed; create3image4ppu-failed ; time: 08:00:17 10/10/11 Pacific Daylight Time}', 'CLASS': 'create3image4 ...
# DEPTH : 800
# DEVICE : {'RESOLUTION2TIMER4PROFILING': 318, 'ID2PLATFORM': '0000000001509568', 'PROFILING2QUEUE': 'ACK', 'EXECUTE2KERNELS4OPENCL': 'ACK', 'NATIVE2WIDTHL ...
# EMPTY2QUEUE : True
# EVENT : {'CODE2ERROR': 0, 'DATA2CALLBACK': {'MESSAGE': '{(Step 1Z1/33) failed; create2event4ppu-failed ; time: 08:00:16 10/10/11 Pacific Daylight Time ...
# FLAGS : 0
# FORMAT : {'TYPE': 'CL_UNORM_INT8', 'ORDER': 'CL_RGBA'}
# FULL2QUEUE : False
# FUNCTION3CALLBACK :
# HEIGHT : 800
# NACK2RETURN :
# PIPE : (, )
# PLATFORM : {'list2platforms': ['DragonXi'], 'ack2return': ' 2C-2E-2F-2G-', 'nack2return': ' ', 'available2platform': 1, 'max2entries': 1}
# POINTER :
# QUEUE :
# ROWPITCH : 800
# SIZE2QUEUE : 2147483646
# SLICEPITCH : 800
except:
print('(Step 126Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO 3D IMAGE OPERATION FOR PPU ', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - READ IMAGE - ESTABLISH CONTROL AND COMMAND ONLY
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 127A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL AND COMMAND WITH READ IMAGE OBJECT ', time4xi())
print('=' *33)
#
response4read2ppu = {}
try:
response4read2ppu = xi3ppu.read3image()
print('=' *33)
print('(Step 127B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL AND COMMAND WITH RESPONSE4READ2PPU: ', response4read2ppu)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }
print('=' *33)
except:
print('(Step 127Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL AND COMMAND WITH READ - READ2PPU: ', wait2ppu)
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - WRITE IMAGE - ESTABLISH CONTROL AND COMMAND ONLY
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 128A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL AND COMMAND WITH WRITE IMAGE OBJECT ', time4xi())
print('=' *33)
#
response4write3ppu = {}
try:
response4write3ppu = xi3ppu.write3image()
print('=' *33)
print('(Step 128B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL AND COMMAND WITH WRITE2PPU, RESPONSE4WRITE2PPU: ', response4write3ppu)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }
print('=' *33)
except:
print('(Step 128Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL AND COMMAND WITH WRITE - RESPONSE4WRITE2PPU: ', response4write3ppu)
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - COPY IMAGE - ESTABLISH CONTROL AND COMMAND ONLY
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 129A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL AND COMMAND WITH COPY IMAGE OBJECT ', time4xi())
print('=' *33)
#
response4copy3ppu = {}
try:
response4copy3ppu = xi3ppu.copy3image()
print('=' *33)
print('(Step 129B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL AND COMMAND WITH COPY3PPU, RESPONSE4COPY3PPU: ', response4copy3ppu)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }
print('=' *33)
except:
print('(Step 129Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL AND COMMAND WITH COPY - RESPONSE4COPY3PPU: ', response4copy3ppu)
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - COPY IMAGE TO BUFFER - ESTABLISH CONTROL AND COMMAND ONLY
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 130A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL AND COMMAND WITH COPY IMAGE TO BUFFER ', time4xi())
print('=' *33)
#
response4copyimagetobuffer3ppu = {}
try:
response4copyimagetobuffer3ppu = xi3ppu.copy3imagetobuffer()
print('=' *33)
print('(Step 130B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL AND COMMAND WITH COPY IMAGE TO BUFFER, RESPONSE4COPY3PPU: ', response4copyimagetobuffer3ppu)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }
print('=' *33)
except:
print('(Step 130Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL AND COMMAND WITH COPY IMAGE TO BUFFER - RESPONSE4COPYIMAGETOBUFFER2PPU: ', response4copyimagetobuffer3ppu)
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - COPY BUFFER TO IMAGE - ESTABLISH CONTROL AND COMMAND ONLY
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 131A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL AND COMMAND WITH COPY BUFFER TO IMAGE OBJECT ', time4xi())
print('=' *33)
#
response4copybuffertoimage3ppu = {}
try:
response4copybuffertoimage3ppu = xi3ppu.copy3buffertoimage()
print('=' *33)
print('(Step 131B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL AND COMMAND WITH COPY BUFFER TO IMAGE, RESPONSE4COPYBUFFERTOIMAGE3PPU: ', response4copybuffertoimage3ppu)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }
print('=' *33)
except:
print('(Step 131Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL AND COMMAND WITH COPY BUFFER TO IMAGE - RESPONSE4COPYBUFFERTOIMAGE3PPU: ', response4copybuffertoimage3ppu)
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - MAP IMAGE - ESTABLISH CONTROL AND COMMAND ONLY
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 132A/700) OF PPU3IMAGE4XI5TEST - TRYING TO ESTABLISH CONTROL AND COMMAND WITH MAP IMAGE OBJECT ', time4xi())
print('=' *33)
#
response4map3ppu = {}
try:
response4map3ppu = xi3ppu.map3image()
print('=' *33)
print('(Step 132B/700) OF PPU3IMAGE4XI5TEST - ESTABLISHED CONTROL AND COMMAND WITH RESPONSE4MAP3PPU: ', response4map3ppu)
# {'QUEUE': ,
# 'PUBLISHERCHANNEL': ,
# 'CONSUMERCHANNEL': }
print('=' *33)
except:
print('(Step 132Z1/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ESTABLISH CONTROL AND COMMAND WITH MAP - RESPONSE4MAP3PPU: ', response4map3ppu)
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - SENSE IMAGE
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 170A/700) OF PPU3IMAGE4XI5TEST - SENSING 3D IMAGE OF PPU ', time4xi())
print('=' *33)
try:
print(xi3ppu.sense())
print('=' *33)
print('(Step 170B/700) OF PPU3IMAGE4XI5TEST - SENSED 3D IMAGE OF PPU ', time4xi())
# {'classvariable3ppu-of-PPU3Image4Xi': 4, 'object': }
print('=' *33)
except:
print('(Step 170Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO SENSE 3D IMAGE OF PPU ', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - REASON IMAGE
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 171A/700) OF PPU3IMAGE4XI5TEST - REASONING 3D IMAGE OF PPU ', time4xi())
print('=' *33)
try:
print(xi3ppu.reason())
print('=' *33)
print('(Step 171B/700) OF PPU3IMAGE4XI5TEST - REASONED 3D IMAGE OF PPU ', time4xi())
# 'time-reason-of-PPU3Image4Xi': '08:12:08 10/10/11 Pacific Daylight Time'}
print('=' *33)
except:
print('(Step 171Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO REASON 3D IMAGE OF PPU ', time4xi())
# ---------------------------------------------------------------------------------------------
# PHASE II: CLASS TESTS - ACE IMAGE
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 172A/700) OF PPU3IMAGE4XI5TEST - ACING 3D IMAGE OF PPU ', time4xi())
print('=' *33)
try:
print(xi3ppu.ace())
print('=' *33)
print('(Step 172B/700) OF PPU3IMAGE4XI5TEST - ACED 3D IMAGE OF PPU ', time4xi())
# {'cores-of-PPU3Image4Xi': 4, 'object8xi': }
print('=' *33)
except:
print('(Step 172Z/700) OF PPU3IMAGE4XI5TEST *** FAILED TO ACE 3D IMAGE OF PPU ', time4xi())
# ---------------------------------------------------------------------------------------------
# DONE - ALL TESTS
# ---------------------------------------------------------------------------------------------
print('=' *33)
print('(Step 174/700) OF PPU3IMAGE4XI5TEST - DONE! ', time4xi())
# 08:12:08 10/10/11 Pacific Daylight Time
print('=' *33)
finally:
# ---------------------------------------------------------------------------------------------
# Print Trace
# ---------------------------------------------------------------------------------------------
print2trace4xi(t2xi)
#
# -------------------------------------------------------------------------------------------------
#
# -------------------------------------------------------------------------------------------------
def main():
print('=' *33)
print("(Step 0A/700) OF PPU3IMAGE4XI5TEST - SENSING 3D IMAGE OPERATIONS WITH YOURPPUXI!", time4xi())
#
print('=' *33)
ppu3image4xi5test()
print('=' *33)
print("(Step 0B/700) OF PPU3IMAGE4XI5TEST - SENSED 3D IMAGE OPERATIONS WITH YOURPPUXI!", time4xi())
# 08:12:11 10/10/11 Pacific Daylight Time
print('=' *33)
#
# -------------------------------------------------------------------------------------------------
# __main__
# -------------------------------------------------------------------------------------------------
if __name__ == '__main__':
main()
#
# -------------------------------------------------------------------------------------------------
# Recorded History
# -------------------------------------------------------------------------------------------------
#
#
# -------------------------------------------------------------------------------------------------
# to-be-done
# -------------------------------------------------------------------------------------------------
#
#
# -------------------------------------------------------------------------------------------------
# Legal Notice
# -------------------------------------------------------------------------------------------------
#
#