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):

    TEST_DATA = [
        {
            'inputs': [
                ['inputs:a_colord3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_colord3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_colord4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_colord4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_colord3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_colord3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_colord4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_colord4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_colorf3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_colorf3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_colorf4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_colorf4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_colorf3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_colorf3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_colorf4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_colorf4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_colorh3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_colorh3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_colorh4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_colorh4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_colorh3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_colorh3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_colorh4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_colorh4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_double_inf', float("-Inf"), False],
                ['inputs:a_double_ninf', float("Inf"), False],
                ['inputs:a_double2_inf', [float("-Inf"), float("-Inf")], False],
                ['inputs:a_double2_ninf', [float("Inf"), float("Inf")], False],
                ['inputs:a_double3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_double3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_double4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_double4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_double_array_inf', [float("-Inf"), float("-Inf")], False],
                ['inputs:a_double_array_ninf', [float("Inf"), float("Inf")], False],
                ['inputs:a_double2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['inputs:a_double2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['inputs:a_double3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_double3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_double4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_double4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_float_inf', float("-Inf"), False],
                ['inputs:a_float_ninf', float("Inf"), False],
                ['inputs:a_float2_inf', [float("-Inf"), float("-Inf")], False],
                ['inputs:a_float2_ninf', [float("Inf"), float("Inf")], False],
                ['inputs:a_float3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_float3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_float4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_float4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_float_array_inf', [float("-Inf"), float("-Inf")], False],
                ['inputs:a_float_array_ninf', [float("Inf"), float("Inf")], False],
                ['inputs:a_float2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['inputs:a_float2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['inputs:a_float3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_float3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_float4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_float4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_frame4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_frame4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_frame4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_frame4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_half_inf', float("-Inf"), False],
                ['inputs:a_half_ninf', float("Inf"), False],
                ['inputs:a_half2_inf', [float("-Inf"), float("-Inf")], False],
                ['inputs:a_half2_ninf', [float("Inf"), float("Inf")], False],
                ['inputs:a_half3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_half3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_half4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_half4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_half_array_inf', [float("-Inf"), float("-Inf")], False],
                ['inputs:a_half_array_ninf', [float("Inf"), float("Inf")], False],
                ['inputs:a_half2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['inputs:a_half2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['inputs:a_half3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_half3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_half4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_half4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_matrixd2_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_matrixd2_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_matrixd3_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_matrixd3_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_matrixd4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_matrixd4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_matrixd2_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_matrixd2_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_matrixd3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_matrixd3_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_matrixd4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_matrixd4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_normald3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_normald3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_normald3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_normald3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_normalf3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_normalf3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_normalf3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_normalf3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_normalh3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_normalh3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_normalh3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_normalh3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_pointd3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_pointd3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_pointd3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_pointd3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_pointf3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_pointf3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_pointf3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_pointf3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_pointh3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_pointh3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_pointh3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_pointh3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_quatd4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_quatd4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_quatd4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_quatd4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_quatf4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_quatf4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_quatf4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_quatf4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_quath4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_quath4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_quath4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_quath4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_texcoordd2_inf', [float("-Inf"), float("-Inf")], False],
                ['inputs:a_texcoordd2_ninf', [float("Inf"), float("Inf")], False],
                ['inputs:a_texcoordd3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_texcoordd3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_texcoordd2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['inputs:a_texcoordd2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['inputs:a_texcoordd3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_texcoordd3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_texcoordf2_inf', [float("-Inf"), float("-Inf")], False],
                ['inputs:a_texcoordf2_ninf', [float("Inf"), float("Inf")], False],
                ['inputs:a_texcoordf3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_texcoordf3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_texcoordf2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['inputs:a_texcoordf2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['inputs:a_texcoordf3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_texcoordf3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_texcoordh2_inf', [float("-Inf"), float("-Inf")], False],
                ['inputs:a_texcoordh2_ninf', [float("Inf"), float("Inf")], False],
                ['inputs:a_texcoordh3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_texcoordh3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_texcoordh2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['inputs:a_texcoordh2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['inputs:a_texcoordh3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_texcoordh3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_timecode_inf', float("-Inf"), False],
                ['inputs:a_timecode_ninf', float("Inf"), False],
                ['inputs:a_timecode_array_inf', [float("-Inf"), float("-Inf")], False],
                ['inputs:a_timecode_array_ninf', [float("Inf"), float("Inf")], False],
                ['inputs:a_vectord3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_vectord3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_vectord3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_vectord3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_vectorf3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_vectorf3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_vectorf3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_vectorf3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['inputs:a_vectorh3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['inputs:a_vectorh3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['inputs:a_vectorh3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['inputs:a_vectorh3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
            ],
            'outputs': [
                ['outputs:a_colord3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_colord3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_colord4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_colord4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_colord3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_colord3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_colord4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_colord4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_colorf3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_colorf3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_colorf4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_colorf4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_colorf3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_colorf3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_colorf4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_colorf4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_colorh3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_colorh3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_colorh4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_colorh4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_colorh3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_colorh3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_colorh4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_colorh4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_double_inf', float("-Inf"), False],
                ['outputs:a_double_ninf', float("Inf"), False],
                ['outputs:a_double2_inf', [float("-Inf"), float("-Inf")], False],
                ['outputs:a_double2_ninf', [float("Inf"), float("Inf")], False],
                ['outputs:a_double3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_double3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_double4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_double4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_double_array_inf', [float("-Inf"), float("-Inf")], False],
                ['outputs:a_double_array_ninf', [float("Inf"), float("Inf")], False],
                ['outputs:a_double2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['outputs:a_double2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['outputs:a_double3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_double3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_double4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_double4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_float_inf', float("-Inf"), False],
                ['outputs:a_float_ninf', float("Inf"), False],
                ['outputs:a_float2_inf', [float("-Inf"), float("-Inf")], False],
                ['outputs:a_float2_ninf', [float("Inf"), float("Inf")], False],
                ['outputs:a_float3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_float3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_float4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_float4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_float_array_inf', [float("-Inf"), float("-Inf")], False],
                ['outputs:a_float_array_ninf', [float("Inf"), float("Inf")], False],
                ['outputs:a_float2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['outputs:a_float2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['outputs:a_float3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_float3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_float4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_float4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_frame4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_frame4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_frame4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_frame4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_half_inf', float("-Inf"), False],
                ['outputs:a_half_ninf', float("Inf"), False],
                ['outputs:a_half2_inf', [float("-Inf"), float("-Inf")], False],
                ['outputs:a_half2_ninf', [float("Inf"), float("Inf")], False],
                ['outputs:a_half3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_half3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_half4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_half4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_half_array_inf', [float("-Inf"), float("-Inf")], False],
                ['outputs:a_half_array_ninf', [float("Inf"), float("Inf")], False],
                ['outputs:a_half2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['outputs:a_half2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['outputs:a_half3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_half3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_half4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_half4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_matrixd2_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_matrixd2_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_matrixd3_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_matrixd3_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_matrixd4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_matrixd4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_matrixd2_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_matrixd2_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_matrixd3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_matrixd3_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_matrixd4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_matrixd4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_normald3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_normald3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_normald3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_normald3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_normalf3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_normalf3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_normalf3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_normalf3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_normalh3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_normalh3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_normalh3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_normalh3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_pointd3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_pointd3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_pointd3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_pointd3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_pointf3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_pointf3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_pointf3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_pointf3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_pointh3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_pointh3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_pointh3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_pointh3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_quatd4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_quatd4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_quatd4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_quatd4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_quatf4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_quatf4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_quatf4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_quatf4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_quath4_inf', [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_quath4_ninf', [float("Inf"), float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_quath4_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_quath4_array_ninf', [[float("Inf"), float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_texcoordd2_inf', [float("-Inf"), float("-Inf")], False],
                ['outputs:a_texcoordd2_ninf', [float("Inf"), float("Inf")], False],
                ['outputs:a_texcoordd3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_texcoordd3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_texcoordd2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['outputs:a_texcoordd2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['outputs:a_texcoordd3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_texcoordd3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_texcoordf2_inf', [float("-Inf"), float("-Inf")], False],
                ['outputs:a_texcoordf2_ninf', [float("Inf"), float("Inf")], False],
                ['outputs:a_texcoordf3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_texcoordf3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_texcoordf2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['outputs:a_texcoordf2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['outputs:a_texcoordf3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_texcoordf3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_texcoordh2_inf', [float("-Inf"), float("-Inf")], False],
                ['outputs:a_texcoordh2_ninf', [float("Inf"), float("Inf")], False],
                ['outputs:a_texcoordh3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_texcoordh3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_texcoordh2_array_inf', [[float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf")]], False],
                ['outputs:a_texcoordh2_array_ninf', [[float("Inf"), float("Inf")], [float("Inf"), float("Inf")]], False],
                ['outputs:a_texcoordh3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_texcoordh3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_timecode_inf', float("-Inf"), False],
                ['outputs:a_timecode_ninf', float("Inf"), False],
                ['outputs:a_timecode_array_inf', [float("-Inf"), float("-Inf")], False],
                ['outputs:a_timecode_array_ninf', [float("Inf"), float("Inf")], False],
                ['outputs:a_vectord3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_vectord3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_vectord3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_vectord3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_vectorf3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_vectorf3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_vectorf3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_vectorf3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
                ['outputs:a_vectorh3_inf', [float("-Inf"), float("-Inf"), float("-Inf")], False],
                ['outputs:a_vectorh3_ninf', [float("Inf"), float("Inf"), float("Inf")], False],
                ['outputs:a_vectorh3_array_inf', [[float("-Inf"), float("-Inf"), float("-Inf")], [float("-Inf"), float("-Inf"), float("-Inf")]], False],
                ['outputs:a_vectorh3_array_ninf', [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]], False],
            ],
        },
    ]

    async def test_generated(self):
        test_info = _TestGraphAndNode()
        controller = og.Controller()
        for i, test_run in enumerate(self.TEST_DATA):
            await _test_clear_scene(self, test_run)
            test_info = await _test_setup_scene(self, controller, "/TestGraph", "TestNode_omni_graph_test_TestNanInf", "omni.graph.test.TestNanInf", test_run, test_info)
            await controller.evaluate(test_info.graph)
            _test_verify_scene(self, controller, test_run, test_info, f"omni.graph.test.TestNanInf User test case #{i+1}")

    async def test_vectorized_generated(self):
        test_info = _TestGraphAndNode()
        controller = og.Controller()
        for i, test_run in enumerate(self.TEST_DATA):
            await _test_clear_scene(self, test_run)
            test_info = await _test_setup_scene(self, controller, "/TestGraph", "TestNode_omni_graph_test_TestNanInf","omni.graph.test.TestNanInf", test_run, test_info, 16)
            await controller.evaluate(test_info.graph)
            _test_verify_scene(self, controller, test_run, test_info, f"omni.graph.test.TestNanInf User test case #{i+1}", 16)

    async def test_thread_safety(self):
        import omni.kit
        # Generate multiple instances of the test setup to run them concurrently
        instance_setup = dict()
        for n in range(24):
            instance_setup[f"/TestGraph_{n}"] = _TestGraphAndNode()

        for i, test_run in enumerate(self.TEST_DATA):
            await _test_clear_scene(self, test_run)
            for (key, test_info) in instance_setup.items():
                test_info = await _test_setup_scene(self, og.Controller(allow_exists_prim=True), key, "TestNode_omni_graph_test_TestNanInf", "omni.graph.test.TestNanInf", test_run, test_info)
            self.assertEqual(len(og.get_all_graphs()), 24)

            # We want to evaluate all graphs concurrently. Kick them all.
            # Evaluate multiple times to skip 2 serial frames and increase chances for a race condition.
            for _ in range(10):
                await omni.kit.app.get_app().next_update_async()

            for (key, test_instance) in instance_setup.items():
                _test_verify_scene(self, og.Controller(), test_run, test_info, f"omni.graph.test.TestNanInf User test case #{i+1}, instance{key}")

async def test_data_access(self):
    from omni.graph.test.ogn.OgnTestNanInfDatabase import OgnTestNanInfDatabase
    (_, (test_node,), _, _) = og.Controller.edit("/TestGraph", {
        og.Controller.Keys.CREATE_NODES: ("Template_omni_graph_test_TestNanInf", "omni.graph.test.TestNanInf")
    })
    database = OgnTestNanInfDatabase(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:a_colord3_array_inf"))
    attribute = test_node.get_attribute("inputs:a_colord3_array_inf")
    db_value = database.inputs.a_colord3_array_inf
    expected_value = [[float("Inf"), float("Inf"), float("Inf")], [float("Inf"), float("Inf"), float("Inf")]]
    ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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