import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene


class TestOgn(ogts.OmniGraphTestCase):

    async def test_data_access(self):
        from omni.graph.examples.python.ogn.OgnPyUniversalAddDatabase import OgnPyUniversalAddDatabase
        (_, (test_node,), _, _) = og.Controller.edit("/TestGraph", {
            og.Controller.Keys.CREATE_NODES: ("Template_omni_graph_examples_python_UniversalAdd", "omni.graph.examples.python.UniversalAdd")
        })
        database = OgnPyUniversalAddDatabase(test_node)
        self.assertTrue(test_node.is_valid())
        node_type_name = test_node.get_type_name()
        self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)

        def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
            test_type = "USD Load" if usd_test else "Database Access"
            return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"


        self.assertTrue(test_node.get_attribute_exists("inputs:bool_0"))
        attribute = test_node.get_attribute("inputs:bool_0")
        db_value = database.inputs.bool_0
        expected_value = False
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:bool_1"))
        attribute = test_node.get_attribute("inputs:bool_1")
        db_value = database.inputs.bool_1
        expected_value = False
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:bool_arr_0"))
        attribute = test_node.get_attribute("inputs:bool_arr_0")
        db_value = database.inputs.bool_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:bool_arr_1"))
        attribute = test_node.get_attribute("inputs:bool_arr_1")
        db_value = database.inputs.bool_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colord3_0"))
        attribute = test_node.get_attribute("inputs:colord3_0")
        db_value = database.inputs.colord3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colord3_1"))
        attribute = test_node.get_attribute("inputs:colord3_1")
        db_value = database.inputs.colord3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colord3_arr_0"))
        attribute = test_node.get_attribute("inputs:colord3_arr_0")
        db_value = database.inputs.colord3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colord3_arr_1"))
        attribute = test_node.get_attribute("inputs:colord3_arr_1")
        db_value = database.inputs.colord3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colord4_0"))
        attribute = test_node.get_attribute("inputs:colord4_0")
        db_value = database.inputs.colord4_0
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colord4_1"))
        attribute = test_node.get_attribute("inputs:colord4_1")
        db_value = database.inputs.colord4_1
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colord4_arr_0"))
        attribute = test_node.get_attribute("inputs:colord4_arr_0")
        db_value = database.inputs.colord4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colord4_arr_1"))
        attribute = test_node.get_attribute("inputs:colord4_arr_1")
        db_value = database.inputs.colord4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorf3_0"))
        attribute = test_node.get_attribute("inputs:colorf3_0")
        db_value = database.inputs.colorf3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorf3_1"))
        attribute = test_node.get_attribute("inputs:colorf3_1")
        db_value = database.inputs.colorf3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorf3_arr_0"))
        attribute = test_node.get_attribute("inputs:colorf3_arr_0")
        db_value = database.inputs.colorf3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorf3_arr_1"))
        attribute = test_node.get_attribute("inputs:colorf3_arr_1")
        db_value = database.inputs.colorf3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorf4_0"))
        attribute = test_node.get_attribute("inputs:colorf4_0")
        db_value = database.inputs.colorf4_0
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorf4_1"))
        attribute = test_node.get_attribute("inputs:colorf4_1")
        db_value = database.inputs.colorf4_1
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorf4_arr_0"))
        attribute = test_node.get_attribute("inputs:colorf4_arr_0")
        db_value = database.inputs.colorf4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorf4_arr_1"))
        attribute = test_node.get_attribute("inputs:colorf4_arr_1")
        db_value = database.inputs.colorf4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorh3_0"))
        attribute = test_node.get_attribute("inputs:colorh3_0")
        db_value = database.inputs.colorh3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorh3_1"))
        attribute = test_node.get_attribute("inputs:colorh3_1")
        db_value = database.inputs.colorh3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorh3_arr_0"))
        attribute = test_node.get_attribute("inputs:colorh3_arr_0")
        db_value = database.inputs.colorh3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorh3_arr_1"))
        attribute = test_node.get_attribute("inputs:colorh3_arr_1")
        db_value = database.inputs.colorh3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorh4_0"))
        attribute = test_node.get_attribute("inputs:colorh4_0")
        db_value = database.inputs.colorh4_0
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorh4_1"))
        attribute = test_node.get_attribute("inputs:colorh4_1")
        db_value = database.inputs.colorh4_1
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorh4_arr_0"))
        attribute = test_node.get_attribute("inputs:colorh4_arr_0")
        db_value = database.inputs.colorh4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:colorh4_arr_1"))
        attribute = test_node.get_attribute("inputs:colorh4_arr_1")
        db_value = database.inputs.colorh4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double2_0"))
        attribute = test_node.get_attribute("inputs:double2_0")
        db_value = database.inputs.double2_0
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double2_1"))
        attribute = test_node.get_attribute("inputs:double2_1")
        db_value = database.inputs.double2_1
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double2_arr_0"))
        attribute = test_node.get_attribute("inputs:double2_arr_0")
        db_value = database.inputs.double2_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double2_arr_1"))
        attribute = test_node.get_attribute("inputs:double2_arr_1")
        db_value = database.inputs.double2_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double3_0"))
        attribute = test_node.get_attribute("inputs:double3_0")
        db_value = database.inputs.double3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double3_1"))
        attribute = test_node.get_attribute("inputs:double3_1")
        db_value = database.inputs.double3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double3_arr_0"))
        attribute = test_node.get_attribute("inputs:double3_arr_0")
        db_value = database.inputs.double3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double3_arr_1"))
        attribute = test_node.get_attribute("inputs:double3_arr_1")
        db_value = database.inputs.double3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double4_0"))
        attribute = test_node.get_attribute("inputs:double4_0")
        db_value = database.inputs.double4_0
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double4_1"))
        attribute = test_node.get_attribute("inputs:double4_1")
        db_value = database.inputs.double4_1
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double4_arr_0"))
        attribute = test_node.get_attribute("inputs:double4_arr_0")
        db_value = database.inputs.double4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double4_arr_1"))
        attribute = test_node.get_attribute("inputs:double4_arr_1")
        db_value = database.inputs.double4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double_0"))
        attribute = test_node.get_attribute("inputs:double_0")
        db_value = database.inputs.double_0
        expected_value = 0.0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double_1"))
        attribute = test_node.get_attribute("inputs:double_1")
        db_value = database.inputs.double_1
        expected_value = 0.0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double_arr_0"))
        attribute = test_node.get_attribute("inputs:double_arr_0")
        db_value = database.inputs.double_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:double_arr_1"))
        attribute = test_node.get_attribute("inputs:double_arr_1")
        db_value = database.inputs.double_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float2_0"))
        attribute = test_node.get_attribute("inputs:float2_0")
        db_value = database.inputs.float2_0
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float2_1"))
        attribute = test_node.get_attribute("inputs:float2_1")
        db_value = database.inputs.float2_1
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float2_arr_0"))
        attribute = test_node.get_attribute("inputs:float2_arr_0")
        db_value = database.inputs.float2_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float2_arr_1"))
        attribute = test_node.get_attribute("inputs:float2_arr_1")
        db_value = database.inputs.float2_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float3_0"))
        attribute = test_node.get_attribute("inputs:float3_0")
        db_value = database.inputs.float3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float3_1"))
        attribute = test_node.get_attribute("inputs:float3_1")
        db_value = database.inputs.float3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float3_arr_0"))
        attribute = test_node.get_attribute("inputs:float3_arr_0")
        db_value = database.inputs.float3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float3_arr_1"))
        attribute = test_node.get_attribute("inputs:float3_arr_1")
        db_value = database.inputs.float3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float4_0"))
        attribute = test_node.get_attribute("inputs:float4_0")
        db_value = database.inputs.float4_0
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float4_1"))
        attribute = test_node.get_attribute("inputs:float4_1")
        db_value = database.inputs.float4_1
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float4_arr_0"))
        attribute = test_node.get_attribute("inputs:float4_arr_0")
        db_value = database.inputs.float4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float4_arr_1"))
        attribute = test_node.get_attribute("inputs:float4_arr_1")
        db_value = database.inputs.float4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float_0"))
        attribute = test_node.get_attribute("inputs:float_0")
        db_value = database.inputs.float_0
        expected_value = 0.0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float_1"))
        attribute = test_node.get_attribute("inputs:float_1")
        db_value = database.inputs.float_1
        expected_value = 0.0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float_arr_0"))
        attribute = test_node.get_attribute("inputs:float_arr_0")
        db_value = database.inputs.float_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:float_arr_1"))
        attribute = test_node.get_attribute("inputs:float_arr_1")
        db_value = database.inputs.float_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:frame4_0"))
        attribute = test_node.get_attribute("inputs:frame4_0")
        db_value = database.inputs.frame4_0
        expected_value = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:frame4_1"))
        attribute = test_node.get_attribute("inputs:frame4_1")
        db_value = database.inputs.frame4_1
        expected_value = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:frame4_arr_0"))
        attribute = test_node.get_attribute("inputs:frame4_arr_0")
        db_value = database.inputs.frame4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:frame4_arr_1"))
        attribute = test_node.get_attribute("inputs:frame4_arr_1")
        db_value = database.inputs.frame4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half2_0"))
        attribute = test_node.get_attribute("inputs:half2_0")
        db_value = database.inputs.half2_0
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half2_1"))
        attribute = test_node.get_attribute("inputs:half2_1")
        db_value = database.inputs.half2_1
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half2_arr_0"))
        attribute = test_node.get_attribute("inputs:half2_arr_0")
        db_value = database.inputs.half2_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half2_arr_1"))
        attribute = test_node.get_attribute("inputs:half2_arr_1")
        db_value = database.inputs.half2_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half3_0"))
        attribute = test_node.get_attribute("inputs:half3_0")
        db_value = database.inputs.half3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half3_1"))
        attribute = test_node.get_attribute("inputs:half3_1")
        db_value = database.inputs.half3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half3_arr_0"))
        attribute = test_node.get_attribute("inputs:half3_arr_0")
        db_value = database.inputs.half3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half3_arr_1"))
        attribute = test_node.get_attribute("inputs:half3_arr_1")
        db_value = database.inputs.half3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half4_0"))
        attribute = test_node.get_attribute("inputs:half4_0")
        db_value = database.inputs.half4_0
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half4_1"))
        attribute = test_node.get_attribute("inputs:half4_1")
        db_value = database.inputs.half4_1
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half4_arr_0"))
        attribute = test_node.get_attribute("inputs:half4_arr_0")
        db_value = database.inputs.half4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half4_arr_1"))
        attribute = test_node.get_attribute("inputs:half4_arr_1")
        db_value = database.inputs.half4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half_0"))
        attribute = test_node.get_attribute("inputs:half_0")
        db_value = database.inputs.half_0
        expected_value = 0.0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half_1"))
        attribute = test_node.get_attribute("inputs:half_1")
        db_value = database.inputs.half_1
        expected_value = 0.0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half_arr_0"))
        attribute = test_node.get_attribute("inputs:half_arr_0")
        db_value = database.inputs.half_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:half_arr_1"))
        attribute = test_node.get_attribute("inputs:half_arr_1")
        db_value = database.inputs.half_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int2_0"))
        attribute = test_node.get_attribute("inputs:int2_0")
        db_value = database.inputs.int2_0
        expected_value = [0, 0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int2_1"))
        attribute = test_node.get_attribute("inputs:int2_1")
        db_value = database.inputs.int2_1
        expected_value = [0, 0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int2_arr_0"))
        attribute = test_node.get_attribute("inputs:int2_arr_0")
        db_value = database.inputs.int2_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int2_arr_1"))
        attribute = test_node.get_attribute("inputs:int2_arr_1")
        db_value = database.inputs.int2_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int3_0"))
        attribute = test_node.get_attribute("inputs:int3_0")
        db_value = database.inputs.int3_0
        expected_value = [0, 0, 0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int3_1"))
        attribute = test_node.get_attribute("inputs:int3_1")
        db_value = database.inputs.int3_1
        expected_value = [0, 0, 0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int3_arr_0"))
        attribute = test_node.get_attribute("inputs:int3_arr_0")
        db_value = database.inputs.int3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int3_arr_1"))
        attribute = test_node.get_attribute("inputs:int3_arr_1")
        db_value = database.inputs.int3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int4_0"))
        attribute = test_node.get_attribute("inputs:int4_0")
        db_value = database.inputs.int4_0
        expected_value = [0, 0, 0, 0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int4_1"))
        attribute = test_node.get_attribute("inputs:int4_1")
        db_value = database.inputs.int4_1
        expected_value = [0, 0, 0, 0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int4_arr_0"))
        attribute = test_node.get_attribute("inputs:int4_arr_0")
        db_value = database.inputs.int4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int4_arr_1"))
        attribute = test_node.get_attribute("inputs:int4_arr_1")
        db_value = database.inputs.int4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int64_0"))
        attribute = test_node.get_attribute("inputs:int64_0")
        db_value = database.inputs.int64_0
        expected_value = 0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int64_1"))
        attribute = test_node.get_attribute("inputs:int64_1")
        db_value = database.inputs.int64_1
        expected_value = 0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int64_arr_0"))
        attribute = test_node.get_attribute("inputs:int64_arr_0")
        db_value = database.inputs.int64_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int64_arr_1"))
        attribute = test_node.get_attribute("inputs:int64_arr_1")
        db_value = database.inputs.int64_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int_0"))
        attribute = test_node.get_attribute("inputs:int_0")
        db_value = database.inputs.int_0
        expected_value = 0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int_1"))
        attribute = test_node.get_attribute("inputs:int_1")
        db_value = database.inputs.int_1
        expected_value = 0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int_arr_0"))
        attribute = test_node.get_attribute("inputs:int_arr_0")
        db_value = database.inputs.int_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:int_arr_1"))
        attribute = test_node.get_attribute("inputs:int_arr_1")
        db_value = database.inputs.int_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd2_0"))
        attribute = test_node.get_attribute("inputs:matrixd2_0")
        db_value = database.inputs.matrixd2_0
        expected_value = [[0.0, 0.0], [0.0, 0.0]]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd2_1"))
        attribute = test_node.get_attribute("inputs:matrixd2_1")
        db_value = database.inputs.matrixd2_1
        expected_value = [[0.0, 0.0], [0.0, 0.0]]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd2_arr_0"))
        attribute = test_node.get_attribute("inputs:matrixd2_arr_0")
        db_value = database.inputs.matrixd2_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd2_arr_1"))
        attribute = test_node.get_attribute("inputs:matrixd2_arr_1")
        db_value = database.inputs.matrixd2_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd3_0"))
        attribute = test_node.get_attribute("inputs:matrixd3_0")
        db_value = database.inputs.matrixd3_0
        expected_value = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd3_1"))
        attribute = test_node.get_attribute("inputs:matrixd3_1")
        db_value = database.inputs.matrixd3_1
        expected_value = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd3_arr_0"))
        attribute = test_node.get_attribute("inputs:matrixd3_arr_0")
        db_value = database.inputs.matrixd3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd3_arr_1"))
        attribute = test_node.get_attribute("inputs:matrixd3_arr_1")
        db_value = database.inputs.matrixd3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd4_0"))
        attribute = test_node.get_attribute("inputs:matrixd4_0")
        db_value = database.inputs.matrixd4_0
        expected_value = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd4_1"))
        attribute = test_node.get_attribute("inputs:matrixd4_1")
        db_value = database.inputs.matrixd4_1
        expected_value = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd4_arr_0"))
        attribute = test_node.get_attribute("inputs:matrixd4_arr_0")
        db_value = database.inputs.matrixd4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:matrixd4_arr_1"))
        attribute = test_node.get_attribute("inputs:matrixd4_arr_1")
        db_value = database.inputs.matrixd4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normald3_0"))
        attribute = test_node.get_attribute("inputs:normald3_0")
        db_value = database.inputs.normald3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normald3_1"))
        attribute = test_node.get_attribute("inputs:normald3_1")
        db_value = database.inputs.normald3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normald3_arr_0"))
        attribute = test_node.get_attribute("inputs:normald3_arr_0")
        db_value = database.inputs.normald3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normald3_arr_1"))
        attribute = test_node.get_attribute("inputs:normald3_arr_1")
        db_value = database.inputs.normald3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normalf3_0"))
        attribute = test_node.get_attribute("inputs:normalf3_0")
        db_value = database.inputs.normalf3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normalf3_1"))
        attribute = test_node.get_attribute("inputs:normalf3_1")
        db_value = database.inputs.normalf3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normalf3_arr_0"))
        attribute = test_node.get_attribute("inputs:normalf3_arr_0")
        db_value = database.inputs.normalf3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normalf3_arr_1"))
        attribute = test_node.get_attribute("inputs:normalf3_arr_1")
        db_value = database.inputs.normalf3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normalh3_0"))
        attribute = test_node.get_attribute("inputs:normalh3_0")
        db_value = database.inputs.normalh3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normalh3_1"))
        attribute = test_node.get_attribute("inputs:normalh3_1")
        db_value = database.inputs.normalh3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normalh3_arr_0"))
        attribute = test_node.get_attribute("inputs:normalh3_arr_0")
        db_value = database.inputs.normalh3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:normalh3_arr_1"))
        attribute = test_node.get_attribute("inputs:normalh3_arr_1")
        db_value = database.inputs.normalh3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointd3_0"))
        attribute = test_node.get_attribute("inputs:pointd3_0")
        db_value = database.inputs.pointd3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointd3_1"))
        attribute = test_node.get_attribute("inputs:pointd3_1")
        db_value = database.inputs.pointd3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointd3_arr_0"))
        attribute = test_node.get_attribute("inputs:pointd3_arr_0")
        db_value = database.inputs.pointd3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointd3_arr_1"))
        attribute = test_node.get_attribute("inputs:pointd3_arr_1")
        db_value = database.inputs.pointd3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointf3_0"))
        attribute = test_node.get_attribute("inputs:pointf3_0")
        db_value = database.inputs.pointf3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointf3_1"))
        attribute = test_node.get_attribute("inputs:pointf3_1")
        db_value = database.inputs.pointf3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointf3_arr_0"))
        attribute = test_node.get_attribute("inputs:pointf3_arr_0")
        db_value = database.inputs.pointf3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointf3_arr_1"))
        attribute = test_node.get_attribute("inputs:pointf3_arr_1")
        db_value = database.inputs.pointf3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointh3_0"))
        attribute = test_node.get_attribute("inputs:pointh3_0")
        db_value = database.inputs.pointh3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointh3_1"))
        attribute = test_node.get_attribute("inputs:pointh3_1")
        db_value = database.inputs.pointh3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointh3_arr_0"))
        attribute = test_node.get_attribute("inputs:pointh3_arr_0")
        db_value = database.inputs.pointh3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:pointh3_arr_1"))
        attribute = test_node.get_attribute("inputs:pointh3_arr_1")
        db_value = database.inputs.pointh3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quatd4_0"))
        attribute = test_node.get_attribute("inputs:quatd4_0")
        db_value = database.inputs.quatd4_0
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quatd4_1"))
        attribute = test_node.get_attribute("inputs:quatd4_1")
        db_value = database.inputs.quatd4_1
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quatd4_arr_0"))
        attribute = test_node.get_attribute("inputs:quatd4_arr_0")
        db_value = database.inputs.quatd4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quatd4_arr_1"))
        attribute = test_node.get_attribute("inputs:quatd4_arr_1")
        db_value = database.inputs.quatd4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quatf4_0"))
        attribute = test_node.get_attribute("inputs:quatf4_0")
        db_value = database.inputs.quatf4_0
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quatf4_1"))
        attribute = test_node.get_attribute("inputs:quatf4_1")
        db_value = database.inputs.quatf4_1
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quatf4_arr_0"))
        attribute = test_node.get_attribute("inputs:quatf4_arr_0")
        db_value = database.inputs.quatf4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quatf4_arr_1"))
        attribute = test_node.get_attribute("inputs:quatf4_arr_1")
        db_value = database.inputs.quatf4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quath4_0"))
        attribute = test_node.get_attribute("inputs:quath4_0")
        db_value = database.inputs.quath4_0
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quath4_1"))
        attribute = test_node.get_attribute("inputs:quath4_1")
        db_value = database.inputs.quath4_1
        expected_value = [0.0, 0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quath4_arr_0"))
        attribute = test_node.get_attribute("inputs:quath4_arr_0")
        db_value = database.inputs.quath4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:quath4_arr_1"))
        attribute = test_node.get_attribute("inputs:quath4_arr_1")
        db_value = database.inputs.quath4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordd2_0"))
        attribute = test_node.get_attribute("inputs:texcoordd2_0")
        db_value = database.inputs.texcoordd2_0
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordd2_1"))
        attribute = test_node.get_attribute("inputs:texcoordd2_1")
        db_value = database.inputs.texcoordd2_1
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordd2_arr_0"))
        attribute = test_node.get_attribute("inputs:texcoordd2_arr_0")
        db_value = database.inputs.texcoordd2_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordd2_arr_1"))
        attribute = test_node.get_attribute("inputs:texcoordd2_arr_1")
        db_value = database.inputs.texcoordd2_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordd3_0"))
        attribute = test_node.get_attribute("inputs:texcoordd3_0")
        db_value = database.inputs.texcoordd3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordd3_1"))
        attribute = test_node.get_attribute("inputs:texcoordd3_1")
        db_value = database.inputs.texcoordd3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordd3_arr_0"))
        attribute = test_node.get_attribute("inputs:texcoordd3_arr_0")
        db_value = database.inputs.texcoordd3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordd3_arr_1"))
        attribute = test_node.get_attribute("inputs:texcoordd3_arr_1")
        db_value = database.inputs.texcoordd3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordf2_0"))
        attribute = test_node.get_attribute("inputs:texcoordf2_0")
        db_value = database.inputs.texcoordf2_0
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordf2_1"))
        attribute = test_node.get_attribute("inputs:texcoordf2_1")
        db_value = database.inputs.texcoordf2_1
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordf2_arr_0"))
        attribute = test_node.get_attribute("inputs:texcoordf2_arr_0")
        db_value = database.inputs.texcoordf2_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordf2_arr_1"))
        attribute = test_node.get_attribute("inputs:texcoordf2_arr_1")
        db_value = database.inputs.texcoordf2_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordf3_0"))
        attribute = test_node.get_attribute("inputs:texcoordf3_0")
        db_value = database.inputs.texcoordf3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordf3_1"))
        attribute = test_node.get_attribute("inputs:texcoordf3_1")
        db_value = database.inputs.texcoordf3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordf3_arr_0"))
        attribute = test_node.get_attribute("inputs:texcoordf3_arr_0")
        db_value = database.inputs.texcoordf3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordf3_arr_1"))
        attribute = test_node.get_attribute("inputs:texcoordf3_arr_1")
        db_value = database.inputs.texcoordf3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordh2_0"))
        attribute = test_node.get_attribute("inputs:texcoordh2_0")
        db_value = database.inputs.texcoordh2_0
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordh2_1"))
        attribute = test_node.get_attribute("inputs:texcoordh2_1")
        db_value = database.inputs.texcoordh2_1
        expected_value = [0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordh2_arr_0"))
        attribute = test_node.get_attribute("inputs:texcoordh2_arr_0")
        db_value = database.inputs.texcoordh2_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordh2_arr_1"))
        attribute = test_node.get_attribute("inputs:texcoordh2_arr_1")
        db_value = database.inputs.texcoordh2_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordh3_0"))
        attribute = test_node.get_attribute("inputs:texcoordh3_0")
        db_value = database.inputs.texcoordh3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordh3_1"))
        attribute = test_node.get_attribute("inputs:texcoordh3_1")
        db_value = database.inputs.texcoordh3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordh3_arr_0"))
        attribute = test_node.get_attribute("inputs:texcoordh3_arr_0")
        db_value = database.inputs.texcoordh3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:texcoordh3_arr_1"))
        attribute = test_node.get_attribute("inputs:texcoordh3_arr_1")
        db_value = database.inputs.texcoordh3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:timecode_0"))
        attribute = test_node.get_attribute("inputs:timecode_0")
        db_value = database.inputs.timecode_0
        expected_value = 0.0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:timecode_1"))
        attribute = test_node.get_attribute("inputs:timecode_1")
        db_value = database.inputs.timecode_1
        expected_value = 0.0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:timecode_arr_0"))
        attribute = test_node.get_attribute("inputs:timecode_arr_0")
        db_value = database.inputs.timecode_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:timecode_arr_1"))
        attribute = test_node.get_attribute("inputs:timecode_arr_1")
        db_value = database.inputs.timecode_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:token_0"))
        attribute = test_node.get_attribute("inputs:token_0")
        db_value = database.inputs.token_0
        expected_value = "default_token"
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:token_1"))
        attribute = test_node.get_attribute("inputs:token_1")
        db_value = database.inputs.token_1
        expected_value = "default_token"
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:token_arr_0"))
        attribute = test_node.get_attribute("inputs:token_arr_0")
        db_value = database.inputs.token_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:token_arr_1"))
        attribute = test_node.get_attribute("inputs:token_arr_1")
        db_value = database.inputs.token_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:transform4_0"))
        attribute = test_node.get_attribute("inputs:transform4_0")
        db_value = database.inputs.transform4_0
        expected_value = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:transform4_1"))
        attribute = test_node.get_attribute("inputs:transform4_1")
        db_value = database.inputs.transform4_1
        expected_value = [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:transform4_arr_0"))
        attribute = test_node.get_attribute("inputs:transform4_arr_0")
        db_value = database.inputs.transform4_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:transform4_arr_1"))
        attribute = test_node.get_attribute("inputs:transform4_arr_1")
        db_value = database.inputs.transform4_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uchar_0"))
        attribute = test_node.get_attribute("inputs:uchar_0")
        db_value = database.inputs.uchar_0
        expected_value = 0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uchar_1"))
        attribute = test_node.get_attribute("inputs:uchar_1")
        db_value = database.inputs.uchar_1
        expected_value = 0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uchar_arr_0"))
        attribute = test_node.get_attribute("inputs:uchar_arr_0")
        db_value = database.inputs.uchar_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uchar_arr_1"))
        attribute = test_node.get_attribute("inputs:uchar_arr_1")
        db_value = database.inputs.uchar_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uint64_0"))
        attribute = test_node.get_attribute("inputs:uint64_0")
        db_value = database.inputs.uint64_0
        expected_value = 0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uint64_1"))
        attribute = test_node.get_attribute("inputs:uint64_1")
        db_value = database.inputs.uint64_1
        expected_value = 0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uint64_arr_0"))
        attribute = test_node.get_attribute("inputs:uint64_arr_0")
        db_value = database.inputs.uint64_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uint64_arr_1"))
        attribute = test_node.get_attribute("inputs:uint64_arr_1")
        db_value = database.inputs.uint64_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uint_0"))
        attribute = test_node.get_attribute("inputs:uint_0")
        db_value = database.inputs.uint_0
        expected_value = 0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uint_1"))
        attribute = test_node.get_attribute("inputs:uint_1")
        db_value = database.inputs.uint_1
        expected_value = 0
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uint_arr_0"))
        attribute = test_node.get_attribute("inputs:uint_arr_0")
        db_value = database.inputs.uint_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:uint_arr_1"))
        attribute = test_node.get_attribute("inputs:uint_arr_1")
        db_value = database.inputs.uint_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectord3_0"))
        attribute = test_node.get_attribute("inputs:vectord3_0")
        db_value = database.inputs.vectord3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectord3_1"))
        attribute = test_node.get_attribute("inputs:vectord3_1")
        db_value = database.inputs.vectord3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectord3_arr_0"))
        attribute = test_node.get_attribute("inputs:vectord3_arr_0")
        db_value = database.inputs.vectord3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectord3_arr_1"))
        attribute = test_node.get_attribute("inputs:vectord3_arr_1")
        db_value = database.inputs.vectord3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectorf3_0"))
        attribute = test_node.get_attribute("inputs:vectorf3_0")
        db_value = database.inputs.vectorf3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectorf3_1"))
        attribute = test_node.get_attribute("inputs:vectorf3_1")
        db_value = database.inputs.vectorf3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectorf3_arr_0"))
        attribute = test_node.get_attribute("inputs:vectorf3_arr_0")
        db_value = database.inputs.vectorf3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectorf3_arr_1"))
        attribute = test_node.get_attribute("inputs:vectorf3_arr_1")
        db_value = database.inputs.vectorf3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectorh3_0"))
        attribute = test_node.get_attribute("inputs:vectorh3_0")
        db_value = database.inputs.vectorh3_0
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectorh3_1"))
        attribute = test_node.get_attribute("inputs:vectorh3_1")
        db_value = database.inputs.vectorh3_1
        expected_value = [0.0, 0.0, 0.0]
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectorh3_arr_0"))
        attribute = test_node.get_attribute("inputs:vectorh3_arr_0")
        db_value = database.inputs.vectorh3_arr_0
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("inputs:vectorh3_arr_1"))
        attribute = test_node.get_attribute("inputs:vectorh3_arr_1")
        db_value = database.inputs.vectorh3_arr_1
        expected_value = []
        ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

        self.assertTrue(test_node.get_attribute_exists("outputs:bool_0"))
        attribute = test_node.get_attribute("outputs:bool_0")
        db_value = database.outputs.bool_0

        self.assertTrue(test_node.get_attribute_exists("outputs:bool_arr_0"))
        attribute = test_node.get_attribute("outputs:bool_arr_0")
        db_value = database.outputs.bool_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colord3_0"))
        attribute = test_node.get_attribute("outputs:colord3_0")
        db_value = database.outputs.colord3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colord3_arr_0"))
        attribute = test_node.get_attribute("outputs:colord3_arr_0")
        db_value = database.outputs.colord3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colord4_0"))
        attribute = test_node.get_attribute("outputs:colord4_0")
        db_value = database.outputs.colord4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colord4_arr_0"))
        attribute = test_node.get_attribute("outputs:colord4_arr_0")
        db_value = database.outputs.colord4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colorf3_0"))
        attribute = test_node.get_attribute("outputs:colorf3_0")
        db_value = database.outputs.colorf3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colorf3_arr_0"))
        attribute = test_node.get_attribute("outputs:colorf3_arr_0")
        db_value = database.outputs.colorf3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colorf4_0"))
        attribute = test_node.get_attribute("outputs:colorf4_0")
        db_value = database.outputs.colorf4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colorf4_arr_0"))
        attribute = test_node.get_attribute("outputs:colorf4_arr_0")
        db_value = database.outputs.colorf4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colorh3_0"))
        attribute = test_node.get_attribute("outputs:colorh3_0")
        db_value = database.outputs.colorh3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colorh3_arr_0"))
        attribute = test_node.get_attribute("outputs:colorh3_arr_0")
        db_value = database.outputs.colorh3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colorh4_0"))
        attribute = test_node.get_attribute("outputs:colorh4_0")
        db_value = database.outputs.colorh4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:colorh4_arr_0"))
        attribute = test_node.get_attribute("outputs:colorh4_arr_0")
        db_value = database.outputs.colorh4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:double2_0"))
        attribute = test_node.get_attribute("outputs:double2_0")
        db_value = database.outputs.double2_0

        self.assertTrue(test_node.get_attribute_exists("outputs:double2_arr_0"))
        attribute = test_node.get_attribute("outputs:double2_arr_0")
        db_value = database.outputs.double2_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:double3_0"))
        attribute = test_node.get_attribute("outputs:double3_0")
        db_value = database.outputs.double3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:double3_arr_0"))
        attribute = test_node.get_attribute("outputs:double3_arr_0")
        db_value = database.outputs.double3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:double4_0"))
        attribute = test_node.get_attribute("outputs:double4_0")
        db_value = database.outputs.double4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:double4_arr_0"))
        attribute = test_node.get_attribute("outputs:double4_arr_0")
        db_value = database.outputs.double4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:double_0"))
        attribute = test_node.get_attribute("outputs:double_0")
        db_value = database.outputs.double_0

        self.assertTrue(test_node.get_attribute_exists("outputs:double_arr_0"))
        attribute = test_node.get_attribute("outputs:double_arr_0")
        db_value = database.outputs.double_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:float2_0"))
        attribute = test_node.get_attribute("outputs:float2_0")
        db_value = database.outputs.float2_0

        self.assertTrue(test_node.get_attribute_exists("outputs:float2_arr_0"))
        attribute = test_node.get_attribute("outputs:float2_arr_0")
        db_value = database.outputs.float2_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:float3_0"))
        attribute = test_node.get_attribute("outputs:float3_0")
        db_value = database.outputs.float3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:float3_arr_0"))
        attribute = test_node.get_attribute("outputs:float3_arr_0")
        db_value = database.outputs.float3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:float4_0"))
        attribute = test_node.get_attribute("outputs:float4_0")
        db_value = database.outputs.float4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:float4_arr_0"))
        attribute = test_node.get_attribute("outputs:float4_arr_0")
        db_value = database.outputs.float4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:float_0"))
        attribute = test_node.get_attribute("outputs:float_0")
        db_value = database.outputs.float_0

        self.assertTrue(test_node.get_attribute_exists("outputs:float_arr_0"))
        attribute = test_node.get_attribute("outputs:float_arr_0")
        db_value = database.outputs.float_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:frame4_0"))
        attribute = test_node.get_attribute("outputs:frame4_0")
        db_value = database.outputs.frame4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:frame4_arr_0"))
        attribute = test_node.get_attribute("outputs:frame4_arr_0")
        db_value = database.outputs.frame4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:half2_0"))
        attribute = test_node.get_attribute("outputs:half2_0")
        db_value = database.outputs.half2_0

        self.assertTrue(test_node.get_attribute_exists("outputs:half2_arr_0"))
        attribute = test_node.get_attribute("outputs:half2_arr_0")
        db_value = database.outputs.half2_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:half3_0"))
        attribute = test_node.get_attribute("outputs:half3_0")
        db_value = database.outputs.half3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:half3_arr_0"))
        attribute = test_node.get_attribute("outputs:half3_arr_0")
        db_value = database.outputs.half3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:half4_0"))
        attribute = test_node.get_attribute("outputs:half4_0")
        db_value = database.outputs.half4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:half4_arr_0"))
        attribute = test_node.get_attribute("outputs:half4_arr_0")
        db_value = database.outputs.half4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:half_0"))
        attribute = test_node.get_attribute("outputs:half_0")
        db_value = database.outputs.half_0

        self.assertTrue(test_node.get_attribute_exists("outputs:half_arr_0"))
        attribute = test_node.get_attribute("outputs:half_arr_0")
        db_value = database.outputs.half_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:int2_0"))
        attribute = test_node.get_attribute("outputs:int2_0")
        db_value = database.outputs.int2_0

        self.assertTrue(test_node.get_attribute_exists("outputs:int2_arr_0"))
        attribute = test_node.get_attribute("outputs:int2_arr_0")
        db_value = database.outputs.int2_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:int3_0"))
        attribute = test_node.get_attribute("outputs:int3_0")
        db_value = database.outputs.int3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:int3_arr_0"))
        attribute = test_node.get_attribute("outputs:int3_arr_0")
        db_value = database.outputs.int3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:int4_0"))
        attribute = test_node.get_attribute("outputs:int4_0")
        db_value = database.outputs.int4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:int4_arr_0"))
        attribute = test_node.get_attribute("outputs:int4_arr_0")
        db_value = database.outputs.int4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:int64_0"))
        attribute = test_node.get_attribute("outputs:int64_0")
        db_value = database.outputs.int64_0

        self.assertTrue(test_node.get_attribute_exists("outputs:int64_arr_0"))
        attribute = test_node.get_attribute("outputs:int64_arr_0")
        db_value = database.outputs.int64_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:int_0"))
        attribute = test_node.get_attribute("outputs:int_0")
        db_value = database.outputs.int_0

        self.assertTrue(test_node.get_attribute_exists("outputs:int_arr_0"))
        attribute = test_node.get_attribute("outputs:int_arr_0")
        db_value = database.outputs.int_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:matrixd2_0"))
        attribute = test_node.get_attribute("outputs:matrixd2_0")
        db_value = database.outputs.matrixd2_0

        self.assertTrue(test_node.get_attribute_exists("outputs:matrixd2_arr_0"))
        attribute = test_node.get_attribute("outputs:matrixd2_arr_0")
        db_value = database.outputs.matrixd2_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:matrixd3_0"))
        attribute = test_node.get_attribute("outputs:matrixd3_0")
        db_value = database.outputs.matrixd3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:matrixd3_arr_0"))
        attribute = test_node.get_attribute("outputs:matrixd3_arr_0")
        db_value = database.outputs.matrixd3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:matrixd4_0"))
        attribute = test_node.get_attribute("outputs:matrixd4_0")
        db_value = database.outputs.matrixd4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:matrixd4_arr_0"))
        attribute = test_node.get_attribute("outputs:matrixd4_arr_0")
        db_value = database.outputs.matrixd4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:normald3_0"))
        attribute = test_node.get_attribute("outputs:normald3_0")
        db_value = database.outputs.normald3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:normald3_arr_0"))
        attribute = test_node.get_attribute("outputs:normald3_arr_0")
        db_value = database.outputs.normald3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:normalf3_0"))
        attribute = test_node.get_attribute("outputs:normalf3_0")
        db_value = database.outputs.normalf3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:normalf3_arr_0"))
        attribute = test_node.get_attribute("outputs:normalf3_arr_0")
        db_value = database.outputs.normalf3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:normalh3_0"))
        attribute = test_node.get_attribute("outputs:normalh3_0")
        db_value = database.outputs.normalh3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:normalh3_arr_0"))
        attribute = test_node.get_attribute("outputs:normalh3_arr_0")
        db_value = database.outputs.normalh3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:pointd3_0"))
        attribute = test_node.get_attribute("outputs:pointd3_0")
        db_value = database.outputs.pointd3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:pointd3_arr_0"))
        attribute = test_node.get_attribute("outputs:pointd3_arr_0")
        db_value = database.outputs.pointd3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:pointf3_0"))
        attribute = test_node.get_attribute("outputs:pointf3_0")
        db_value = database.outputs.pointf3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:pointf3_arr_0"))
        attribute = test_node.get_attribute("outputs:pointf3_arr_0")
        db_value = database.outputs.pointf3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:pointh3_0"))
        attribute = test_node.get_attribute("outputs:pointh3_0")
        db_value = database.outputs.pointh3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:pointh3_arr_0"))
        attribute = test_node.get_attribute("outputs:pointh3_arr_0")
        db_value = database.outputs.pointh3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:quatd4_0"))
        attribute = test_node.get_attribute("outputs:quatd4_0")
        db_value = database.outputs.quatd4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:quatd4_arr_0"))
        attribute = test_node.get_attribute("outputs:quatd4_arr_0")
        db_value = database.outputs.quatd4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:quatf4_0"))
        attribute = test_node.get_attribute("outputs:quatf4_0")
        db_value = database.outputs.quatf4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:quatf4_arr_0"))
        attribute = test_node.get_attribute("outputs:quatf4_arr_0")
        db_value = database.outputs.quatf4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:quath4_0"))
        attribute = test_node.get_attribute("outputs:quath4_0")
        db_value = database.outputs.quath4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:quath4_arr_0"))
        attribute = test_node.get_attribute("outputs:quath4_arr_0")
        db_value = database.outputs.quath4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordd2_0"))
        attribute = test_node.get_attribute("outputs:texcoordd2_0")
        db_value = database.outputs.texcoordd2_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordd2_arr_0"))
        attribute = test_node.get_attribute("outputs:texcoordd2_arr_0")
        db_value = database.outputs.texcoordd2_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordd3_0"))
        attribute = test_node.get_attribute("outputs:texcoordd3_0")
        db_value = database.outputs.texcoordd3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordd3_arr_0"))
        attribute = test_node.get_attribute("outputs:texcoordd3_arr_0")
        db_value = database.outputs.texcoordd3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordf2_0"))
        attribute = test_node.get_attribute("outputs:texcoordf2_0")
        db_value = database.outputs.texcoordf2_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordf2_arr_0"))
        attribute = test_node.get_attribute("outputs:texcoordf2_arr_0")
        db_value = database.outputs.texcoordf2_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordf3_0"))
        attribute = test_node.get_attribute("outputs:texcoordf3_0")
        db_value = database.outputs.texcoordf3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordf3_arr_0"))
        attribute = test_node.get_attribute("outputs:texcoordf3_arr_0")
        db_value = database.outputs.texcoordf3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordh2_0"))
        attribute = test_node.get_attribute("outputs:texcoordh2_0")
        db_value = database.outputs.texcoordh2_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordh2_arr_0"))
        attribute = test_node.get_attribute("outputs:texcoordh2_arr_0")
        db_value = database.outputs.texcoordh2_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordh3_0"))
        attribute = test_node.get_attribute("outputs:texcoordh3_0")
        db_value = database.outputs.texcoordh3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:texcoordh3_arr_0"))
        attribute = test_node.get_attribute("outputs:texcoordh3_arr_0")
        db_value = database.outputs.texcoordh3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:timecode_0"))
        attribute = test_node.get_attribute("outputs:timecode_0")
        db_value = database.outputs.timecode_0

        self.assertTrue(test_node.get_attribute_exists("outputs:timecode_arr_0"))
        attribute = test_node.get_attribute("outputs:timecode_arr_0")
        db_value = database.outputs.timecode_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:token_0"))
        attribute = test_node.get_attribute("outputs:token_0")
        db_value = database.outputs.token_0

        self.assertTrue(test_node.get_attribute_exists("outputs:token_arr_0"))
        attribute = test_node.get_attribute("outputs:token_arr_0")
        db_value = database.outputs.token_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:transform4_0"))
        attribute = test_node.get_attribute("outputs:transform4_0")
        db_value = database.outputs.transform4_0

        self.assertTrue(test_node.get_attribute_exists("outputs:transform4_arr_0"))
        attribute = test_node.get_attribute("outputs:transform4_arr_0")
        db_value = database.outputs.transform4_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:uchar_0"))
        attribute = test_node.get_attribute("outputs:uchar_0")
        db_value = database.outputs.uchar_0

        self.assertTrue(test_node.get_attribute_exists("outputs:uchar_arr_0"))
        attribute = test_node.get_attribute("outputs:uchar_arr_0")
        db_value = database.outputs.uchar_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:uint64_0"))
        attribute = test_node.get_attribute("outputs:uint64_0")
        db_value = database.outputs.uint64_0

        self.assertTrue(test_node.get_attribute_exists("outputs:uint64_arr_0"))
        attribute = test_node.get_attribute("outputs:uint64_arr_0")
        db_value = database.outputs.uint64_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:uint_0"))
        attribute = test_node.get_attribute("outputs:uint_0")
        db_value = database.outputs.uint_0

        self.assertTrue(test_node.get_attribute_exists("outputs:uint_arr_0"))
        attribute = test_node.get_attribute("outputs:uint_arr_0")
        db_value = database.outputs.uint_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:vectord3_0"))
        attribute = test_node.get_attribute("outputs:vectord3_0")
        db_value = database.outputs.vectord3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:vectord3_arr_0"))
        attribute = test_node.get_attribute("outputs:vectord3_arr_0")
        db_value = database.outputs.vectord3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:vectorf3_0"))
        attribute = test_node.get_attribute("outputs:vectorf3_0")
        db_value = database.outputs.vectorf3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:vectorf3_arr_0"))
        attribute = test_node.get_attribute("outputs:vectorf3_arr_0")
        db_value = database.outputs.vectorf3_arr_0

        self.assertTrue(test_node.get_attribute_exists("outputs:vectorh3_0"))
        attribute = test_node.get_attribute("outputs:vectorh3_0")
        db_value = database.outputs.vectorh3_0

        self.assertTrue(test_node.get_attribute_exists("outputs:vectorh3_arr_0"))
        attribute = test_node.get_attribute("outputs:vectorh3_arr_0")
        db_value = database.outputs.vectorh3_arr_0
