Merge branch 'develop' into dynamic_reduce

src/common.cpp

@@ -77,7 +77,6 @@ std::vector<shape::dynamic_dimension> compute_broadcasted_dyn_dims(shape s0, sha
     }
     auto offset = s1.ndim() - s0.ndim();
     std::vector<shape::dynamic_dimension> out_dims(s1.dyn_dims());
-    shape::dynamic_dimension one_dyn_dim{1, 1, 0};
     std::transform(
         s0.dyn_dims().cbegin(),
         s0.dyn_dims().cend(),
@@ -88,7 +87,7 @@ std::vector<shape::dynamic_dimension> compute_broadcasted_dyn_dims(shape s0, sha
             {
                 return a;
             }
-            else if(a == one_dyn_dim or b == one_dyn_dim)
+            else if(a == 1 or b == 1)
             {
                 // setting opt to 0, may need to be changed
                 return shape::dynamic_dimension{std::max(a.min, b.min), std::max(a.max, b.max), 0};

src/driver/main.cpp

@@ -109,8 +109,12 @@ struct loader
         ap(brief, {"--brief"}, ap.help("Make the output brief."), ap.set_value(true));
         ap(output_type,
            {"--cpp"},
-           ap.help("Print out the program as cpp program."),
+           ap.help("Print out the program as C++ program."),
            ap.set_value("cpp"));
+        ap(output_type,
+           {"--python", "--py"},
+           ap.help("Print out the program as python program."),
+           ap.set_value("py"));
         ap(output_type, {"--json"}, ap.help("Print out program as json."), ap.set_value("json"));
         ap(output_type,
            {"--text"},
@@ -259,7 +263,9 @@ struct loader
                 type = "binary";
         }
 
-        if(type == "cpp")
+        if(type == "py")
+            p.print_py(*os);
+        else if(type == "cpp")
             p.print_cpp(*os);
         else if(type == "graphviz")
             p.print_graph(*os, brief);

src/file_buffer.cpp

@@ -30,23 +30,31 @@ namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 
 template <class T>
-T generic_read_file(const std::string& filename)
+T generic_read_file(const std::string& filename, size_t offset = 0, size_t nbytes = 0)
 {
     std::ifstream is(filename, std::ios::binary | std::ios::ate);
-    std::streamsize size = is.tellg();
-    if(size < 1)
+    if(nbytes == 0)
+    {
+        // if there is a non-zero offset and nbytes is not set,
+        // calculate size of remaining bytes to read
+        nbytes = is.tellg();
+        if(offset > nbytes)
+            MIGRAPHX_THROW("offset is larger than file size");
+        nbytes -= offset;
+    }
+    if(nbytes < 1)
         MIGRAPHX_THROW("Invalid size for: " + filename);
-    is.seekg(0, std::ios::beg);
+    is.seekg(offset, std::ios::beg);
 
-    T buffer(size, 0);
-    if(not is.read(&buffer[0], size))
+    T buffer(nbytes, 0);
+    if(not is.read(&buffer[0], nbytes))
         MIGRAPHX_THROW("Error reading file: " + filename);
     return buffer;
 }
 
-std::vector<char> read_buffer(const std::string& filename)
+std::vector<char> read_buffer(const std::string& filename, size_t offset, size_t nbytes)
 {
-    return generic_read_file<std::vector<char>>(filename);
+    return generic_read_file<std::vector<char>>(filename, offset, nbytes);
 }
 
 std::string read_string(const std::string& filename)

src/include/migraphx/file_buffer.hpp

@@ -31,7 +31,7 @@
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
 
-std::vector<char> read_buffer(const std::string& filename);
+std::vector<char> read_buffer(const std::string& filename, size_t offset = 0, size_t nbytes = 0);
 std::string read_string(const std::string& filename);
 
 void write_buffer(const std::string& filename, const char* buffer, std::size_t size);

src/include/migraphx/module.hpp

@@ -205,6 +205,12 @@ struct module
 
     void print_graph(std::ostream& os, bool brief = false) const;
 
+    void print_py(std::ostream& os) const;
+    std::unordered_map<instruction_ref, std::string>
+    print_py(std::ostream& os,
+             const std::string& mname,
+             std::unordered_map<instruction_ref, std::string> names) const;
+
     void print_cpp(std::ostream& os) const;
     std::unordered_map<instruction_ref, std::string>
     print_cpp(std::ostream& os,

src/include/migraphx/op/squeeze.hpp

@@ -59,9 +59,8 @@ struct squeeze
         auto input_shape = inputs[0];
         if(input_shape.dynamic())
         {
-            shape::dynamic_dimension one_dyn_dim{1, 1, 0};
             if(std::any_of(axes.begin(), axes.end(), [&](auto axis) {
-                   return input_shape.dyn_dims()[axis] != one_dyn_dim;
+                   return input_shape.dyn_dims()[axis] != 1;
                }))
             {
                 MIGRAPHX_THROW(
@@ -73,7 +72,7 @@ struct squeeze
                 std::copy_if(input_shape.dyn_dims().cbegin(),
                              input_shape.dyn_dims().cend(),
                              std::back_inserter(dyn_dims),
-                             [&](auto dd) { return dd != one_dyn_dim; });
+                             [&](auto dd) { return dd != 1; });
             }
             else
             {

src/include/migraphx/program.hpp

@@ -115,6 +115,7 @@ struct program
                    print_func) const;
 
     void print_graph(std::ostream& os, bool brief = false) const;
+    void print_py(std::ostream& os) const;
     void print_cpp(std::ostream& os) const;
 
     void dry_run(parameter_map params) const;

src/include/migraphx/shape.hpp

@@ -101,6 +101,12 @@ struct shape
         friend bool operator==(const dynamic_dimension& x, const dynamic_dimension& y);
         friend bool operator!=(const dynamic_dimension& x, const dynamic_dimension& y);
         friend std::ostream& operator<<(std::ostream& os, const dynamic_dimension& x);
+
+        // compare to fixed std::size_t dimension
+        friend bool operator==(const dynamic_dimension& x, const std::size_t& y);
+        friend bool operator==(const std::size_t& x, const dynamic_dimension& y);
+        friend bool operator!=(const dynamic_dimension& x, const std::size_t& y);
+        friend bool operator!=(const std::size_t& x, const dynamic_dimension& y);
     };
 
     static const std::vector<type_t>& types();

src/module.cpp

@@ -789,6 +789,22 @@ static std::string cpp_var_name(const std::string& name)
     return to_c_id("x_" + replace_string(name, ":", "_module_"));
 }
 
+static void print_py_op(std::ostream& os, const operation& op)
+{
+    auto v = op.to_value();
+    os << "migraphx.op(" << enclose_name(op.name());
+
+    auto default_values = make_op(op.name()).to_value();
+    for(auto&& x : v)
+    {
+        auto name = x.get_key();
+        if(default_values[name] == x)
+            continue;
+        os << ", " << name << "=" << to_json_string(x.without_key());
+    }
+    os << ")";
+}
+
 static void print_make_op(std::ostream& os, const operation& op)
 {
     auto v = op.to_value();
@@ -804,6 +820,14 @@ static void print_make_op(std::ostream& os, const operation& op)
     os << ")";
 }
 
+static void print_py_shape(std::ostream& os, const migraphx::shape& s)
+{
+    os << "migraphx.shape(" << s.type_string() << ", lens=" << to_json_string(s.lens());
+    if(not s.standard())
+        os << ", strides=" << to_json_string(s.strides());
+    os << ")";
+}
+
 static void print_cpp_shape(std::ostream& os, const migraphx::shape& s)
 {
     os << "migraphx::shape{migraphx::shape::" << s.type_string();
@@ -813,6 +837,68 @@ static void print_cpp_shape(std::ostream& os, const migraphx::shape& s)
     os << "}";
 }
 
+std::unordered_map<instruction_ref, std::string>
+module::print_py(std::ostream& os,
+                 const std::string& mname,
+                 std::unordered_map<instruction_ref, std::string> names) const
+{
+    // cppcheck-suppress variableScope
+    unsigned long seed = names.size();
+    auto last          = std::prev(this->end());
+    names              = this->print(
+        [&](auto ins, auto ins_names) {
+            std::vector<std::string> input_vars;
+            std::transform(ins->inputs().begin(),
+                           ins->inputs().end(),
+                           std::back_inserter(input_vars),
+                           [&](auto input) { return cpp_var_name(ins_names.at(input)); });
+            if(ins != last)
+                os << cpp_var_name(ins_names.at(ins)) << " = ";
+            if(ins->name() == "@literal")
+            {
+                os << mname << ".add_literal(";
+                bool use_abs = false;
+                ins->get_literal().visit([&](auto v) {
+                    use_abs = std::none_of(v.begin(), v.end(), [](auto x) { return x < 0; });
+                });
+                // Disable abs for now
+                use_abs = false;
+                if(use_abs)
+                    os << "migraphx.abs_literal(";
+                os << "migraphx.generate_literal(";
+                print_py_shape(os, ins->get_shape());
+                os << ", " << seed << ")";
+                if(use_abs)
+                    os << ")";
+                os << ")" << std::endl;
+                seed++;
+            }
+            else if(ins->name() == "@param")
+            {
+                std::string name = any_cast<builtin::param>(ins->get_operator()).parameter;
+                os << mname << ".add_parameter(" << enclose_name(name) << ",";
+                print_py_shape(os, ins->get_shape());
+                os << ")" << std::endl;
+            }
+            else if(ins->name() == "@return")
+            {
+                os << mname << ".add_return([" << join_strings(input_vars, ", ") << "])"
+                   << std::endl;
+            }
+            else
+            {
+                assert(ins->name().front() != '@');
+                os << mname << ".add_instruction(";
+                print_py_op(os, ins->get_operator());
+                os << ", [" << join_strings(input_vars, ", ") << "]";
+                os << ")" << std::endl;
+            }
+        },
+        names);
+
+    return names;
+}
+
 std::unordered_map<instruction_ref, std::string>
 module::print_cpp(std::ostream& os,
                   const std::string& mname,
@@ -874,6 +960,8 @@ module::print_cpp(std::ostream& os,
     return names;
 }
 
+void module::print_py(std::ostream& os) const { this->print_py(os, this->name(), {}); }
+
 void module::print_cpp(std::ostream& os) const { this->print_cpp(os, this->name(), {}); }
 
 void module::annotate(std::ostream& os, std::function<void(instruction_ref)> a) const

src/onnx/onnx_parser.cpp

@@ -393,18 +393,31 @@ literal onnx_parser::parse_value(const onnx::AttributeProto& attr) const
 literal onnx_parser::parse_tensor(const onnx::TensorProto& t) const
 {
     std::vector<std::size_t> dims(t.dims().begin(), t.dims().end());
-    if(not t.external_data().empty())
+    auto type = get_type(t.data_type());
+    shape tensor_shape(type, dims);
+    auto external_data = t.external_data();
+    if(not external_data.empty())
     {
-        const std::string& data_file = t.external_data().at(0).value();
-        auto raw_buffer              = read_buffer(path + "/" + data_file);
+        const std::string& data_file = external_data.at(0).value();
+        size_t num_data_fields       = external_data.size();
+        size_t offset                = 0;
+        size_t nbytes                = tensor_shape.bytes();
+
+        if(num_data_fields > 1) // if offset field is present
+        {
+            offset = std::stoul(t.external_data().at(1).value());
+        }
+        if(num_data_fields > 2) // if nbytes field is present
+        {
+            nbytes = std::stoul(t.external_data().at(2).value());
+        }
+        auto raw_buffer = read_buffer(path + "/" + data_file, offset, nbytes);
         std::string s(raw_buffer.begin(), raw_buffer.end());
-        auto type = get_type(t.data_type());
         return create_literal(type, dims, s.data());
     }
     if(t.has_raw_data())
     {
         const std::string& s = t.raw_data();
-        auto type            = get_type(t.data_type());
         return create_literal(type, dims, s.data());
     }
 

src/program.cpp

@@ -854,6 +854,25 @@ void program::print_graph(std::ostream& os, bool brief) const
     mm->print_graph(os, brief);
 }
 
+void program::print_py(std::ostream& os) const
+{
+    auto vec_modules = this->get_modules();
+    std::unordered_map<instruction_ref, std::string> names;
+    os << "p = migraphx.program()\n";
+    for(auto& mod : vec_modules)
+    {
+        std::string var_name = "m" + mod->name();
+        os << var_name << " = ";
+        if(mod->name() == "main")
+            os << "p.get_main_module()";
+        else
+            os << "p.create_module(\"" << mod->name() << "\");";
+        os << std::endl;
+        names = mod->print_py(os, var_name, names);
+        os << std::endl;
+    }
+}
+
 void program::print_cpp(std::ostream& os) const
 {
     auto vec_modules = this->get_modules();

src/shape.cpp

@@ -521,6 +521,14 @@ std::ostream& operator<<(std::ostream& os, const shape::dynamic_dimension& x)
     return os;
 }
 
+bool operator==(const shape::dynamic_dimension& x, const std::size_t& y)
+{
+    return x.min == y and x.max == y;
+}
+bool operator==(const std::size_t& x, const shape::dynamic_dimension& y) { return y == x; }
+bool operator!=(const shape::dynamic_dimension& x, const std::size_t& y) { return not(x == y); }
+bool operator!=(const std::size_t& x, const shape::dynamic_dimension& y) { return not(x == y); }
+
 bool operator==(const shape& x, const shape& y)
 {
     if(x.dynamic() and y.dynamic())

test/onnx/external_constant_test.onnx

+external_constant_test:¡

+v
0"Constant*g
+value*[Bconst_tensorj)
+locationexternal_constant_test.weightj
+offset48j
+length24p
 
external_constant_testb
+
0
+
+

+B
\ No newline at end of file

test/onnx/gen_onnx.py

@@ -28,28 +28,37 @@ import numpy as np
 import onnx
 from onnx import helper
 from onnx import TensorProto
-
-
-def onnx_test(op_test):
-    def run_test():
-        op_info = op_test()
-        if len(op_info) > 3:
-            graph_def = helper.make_graph(op_info[0],
-                                          op_test.__name__,
-                                          op_info[1],
-                                          op_info[2],
-                                          initializer=op_info[3])
-        else:
-            graph_def = helper.make_graph(op_info[0], op_test.__name__,
-                                          op_info[1], op_info[2])
-        model_def = helper.make_model(graph_def,
-                                      producer_name=op_test.__name__)
-        onnx.save(model_def, '{}.onnx'.format(op_test.__name__))
-
-    return run_test
-
-
-@onnx_test
+from onnx.numpy_helper import from_array
+
+
+def onnx_test(external_data=False):
+    def create_onnx_test(op_test):
+        def run_test():
+            op_info = op_test()
+            if len(op_info) > 3:
+                graph_def = helper.make_graph(op_info[0],
+                                              op_test.__name__,
+                                              op_info[1],
+                                              op_info[2],
+                                              initializer=op_info[3])
+            else:
+                graph_def = helper.make_graph(op_info[0], op_test.__name__,
+                                              op_info[1], op_info[2])
+            model_def = helper.make_model(graph_def,
+                                          producer_name=op_test.__name__)
+            onnx.save_model(model_def,
+                            '{}.onnx'.format(op_test.__name__),
+                            save_as_external_data=external_data,
+                            location='{}.weight'.format(op_test.__name__),
+                            size_threshold=0,
+                            convert_attribute=True)
+
+        return run_test
+
+    return create_onnx_test
+
+
+@onnx_test()
 def acos_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -63,7 +72,7 @@ def acos_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def acosh_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -77,7 +86,7 @@ def acosh_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def add_bcast_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 4])
@@ -92,7 +101,7 @@ def add_bcast_test():
     return ([node], [x, y], [z])
 
 
-@onnx_test
+@onnx_test()
 def add_fp16_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [1])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT16, [1])
@@ -115,7 +124,7 @@ def add_fp16_test():
         ])
 
 
-@onnx_test
+@onnx_test()
 def add_scalar_test():
     x = helper.make_tensor_value_info('0', TensorProto.UINT8, [2, 3, 4, 5])
     y = helper.make_tensor_value_info('1', TensorProto.UINT8, [])
@@ -126,7 +135,7 @@ def add_scalar_test():
     return ([node], [x, y], [z])
 
 
-@onnx_test
+@onnx_test()
 def argmax_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6])
@@ -140,7 +149,7 @@ def argmax_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def argmax_dyn_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [None, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [None, 4, 6])
@@ -154,7 +163,7 @@ def argmax_dyn_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def argmin_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 5])
@@ -168,7 +177,7 @@ def argmin_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def asin_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -182,7 +191,7 @@ def asin_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def asinh_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -196,7 +205,7 @@ def asinh_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def atan_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -210,7 +219,7 @@ def atan_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def atanh_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -224,7 +233,7 @@ def atanh_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_1d_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 5])
     out = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3])
@@ -237,7 +246,7 @@ def averagepool_1d_test():
     return ([node], [x], [out])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_3d_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 5, 5, 5])
     out = helper.make_tensor_value_info('1', TensorProto.FLOAT,
@@ -251,7 +260,7 @@ def averagepool_3d_test():
     return ([node], [x], [out])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_dyn_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                       [None, 3, 5, 5, 5])
@@ -266,7 +275,7 @@ def averagepool_dyn_test():
     return ([node], [x], [out])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_dyn_autopad_error_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [None, 1, 5, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [None, 1, 5, 5])
@@ -280,7 +289,7 @@ def averagepool_dyn_autopad_error_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_dyn_asym_padding_error_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [None, 1, 5, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [None, 1, 3, 3])
@@ -295,7 +304,7 @@ def averagepool_dyn_asym_padding_error_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_dyn_cip_error_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [None, 1, 5, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [None, 1, 1, 1])
@@ -309,7 +318,7 @@ def averagepool_dyn_cip_error_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_notset_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 1, 1])
@@ -325,7 +334,7 @@ def averagepool_notset_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_nt_cip_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 1, 1])
@@ -342,7 +351,7 @@ def averagepool_nt_cip_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_same_lower_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5])
@@ -356,7 +365,7 @@ def averagepool_same_lower_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_sl_cip_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5])
@@ -371,7 +380,7 @@ def averagepool_sl_cip_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def averagepool_same_upper_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5])
@@ -385,7 +394,7 @@ def averagepool_same_upper_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def batch_norm_flat_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     scale = helper.make_tensor_value_info('scale', TensorProto.FLOAT, [1])
@@ -403,7 +412,7 @@ def batch_norm_flat_test():
     return ([node], [x, scale, bias, mean, var], [out])
 
 
-@onnx_test
+@onnx_test()
 def batch_norm_rank_2_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 5])
     scale = helper.make_tensor_value_info('scale', TensorProto.FLOAT, [5])
@@ -421,7 +430,7 @@ def batch_norm_rank_2_test():
     return ([node], [x, scale, bias, mean, var], [out])
 
 
-@onnx_test
+@onnx_test()
 def batch_norm_1d_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT16, [2, 3, 4])
     scale = helper.make_tensor_value_info('scale', TensorProto.FLOAT, [3])
@@ -438,7 +447,7 @@ def batch_norm_1d_test():
     return ([node], [x, scale, bias, mean, var], [out])
 
 
-@onnx_test
+@onnx_test()
 def batch_norm_2d_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3, 4, 4])
     scale = helper.make_tensor_value_info('scale', TensorProto.FLOAT, [3])
@@ -455,7 +464,7 @@ def batch_norm_2d_test():
     return ([node], [x, scale, bias, mean, var], [out])
 
 
-@onnx_test
+@onnx_test()
 def batch_norm_3d_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT16,
                                       [2, 2, 2, 2, 2])
@@ -475,7 +484,7 @@ def batch_norm_3d_test():
     return ([node], [x, scale, bias, mean, var], [out])
 
 
-@onnx_test
+@onnx_test()
 def batch_norm_invalid_bias_rank_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3, 4, 4])
     scale = helper.make_tensor_value_info('scale', TensorProto.FLOAT, [3])
@@ -492,7 +501,7 @@ def batch_norm_invalid_bias_rank_test():
     return ([node], [x, scale, bias, mean, var], [out])
 
 
-@onnx_test
+@onnx_test()
 def binary_dyn_brcst_prelu_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                          [None, 3, 4, 5])
@@ -509,7 +518,7 @@ def binary_dyn_brcst_prelu_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def binary_dyn_brcst_add_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [4, 5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT,
@@ -526,7 +535,7 @@ def binary_dyn_brcst_add_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def binary_dyn_brcst_attr_error_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [4, 5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT,
@@ -543,7 +552,7 @@ def binary_dyn_brcst_attr_error_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def binary_dyn_brcst_mul_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                          [None, 3, 4, 5])
@@ -560,7 +569,7 @@ def binary_dyn_brcst_mul_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def cast_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT16, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -570,7 +579,7 @@ def cast_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def ceil_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -584,7 +593,7 @@ def ceil_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def celu_alpha_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3])
@@ -597,7 +606,7 @@ def celu_alpha_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def celu_default_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
@@ -607,7 +616,7 @@ def celu_default_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def celu_verify_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
@@ -620,7 +629,7 @@ def celu_verify_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def celu_wrong_type_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT16, [2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT16, [2, 3])
@@ -630,7 +639,7 @@ def celu_wrong_type_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def celu_zero_alpha_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
@@ -643,7 +652,7 @@ def celu_zero_alpha_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def clip_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -657,7 +666,7 @@ def clip_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def clip_test_op11():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -672,7 +681,7 @@ def clip_test_op11():
     return ([node], [x], [y], [min_val, max_val])
 
 
-@onnx_test
+@onnx_test()
 def clip_test_op11_max_only():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -686,7 +695,7 @@ def clip_test_op11_max_only():
     return ([node], [x], [y], [max_val])
 
 
-@onnx_test
+@onnx_test()
 def clip_test_op11_min_only():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -698,7 +707,7 @@ def clip_test_op11_min_only():
     return ([node], [x], [y], [min_val])
 
 
-@onnx_test
+@onnx_test()
 def clip_test_op11_no_args():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -708,7 +717,7 @@ def clip_test_op11_no_args():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def clip_test_op11_no_args1():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -718,7 +727,7 @@ def clip_test_op11_no_args1():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def clip_test_args_type_mismatch():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3, 3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 3])
@@ -734,7 +743,7 @@ def clip_test_args_type_mismatch():
     return ([node], [x], [y], [min_val, max_val])
 
 
-@onnx_test
+@onnx_test()
 def concat_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 4, 3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [7, 4, 3])
@@ -750,7 +759,7 @@ def concat_test():
     return ([node], [x, y], [z])
 
 
-@onnx_test
+@onnx_test()
 def constant_test():
     x = np.array([0, 1, 2])
     y = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
@@ -770,7 +779,7 @@ def constant_test():
     return ([node], [], [y])
 
 
-@onnx_test
+@onnx_test()
 def constant_fill_test():
     value = helper.make_tensor_value_info('value', TensorProto.FLOAT, [2, 3])
 
@@ -787,7 +796,7 @@ def constant_fill_test():
     return ([node], [], [value])
 
 
-@onnx_test
+@onnx_test()
 def constant_fill_input_as_shape_test():
     np_shape = np.array([2, 3])
     value = helper.make_tensor_value_info('value', TensorProto.FLOAT, [2, 3])
@@ -816,7 +825,7 @@ def constant_fill_input_as_shape_test():
     return ([const_shape_node, node], [], [value])
 
 
-@onnx_test
+@onnx_test()
 def constant_scalar_test():
     x = np.array([1])
     y = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1])
@@ -836,7 +845,7 @@ def constant_scalar_test():
     return ([node], [], [y])
 
 
-@onnx_test
+@onnx_test()
 def constant_empty_scalar_int64_test():
     x = np.array([]).astype(np.int64)
     y = helper.make_tensor_value_info('0', TensorProto.INT64, [0])
@@ -856,7 +865,7 @@ def constant_empty_scalar_int64_test():
     return ([node], [], [y])
 
 
-@onnx_test
+@onnx_test()
 def constant_one_val_int64_test():
     x = np.array([1]).astype(np.int64)
     y = helper.make_tensor_value_info('0', TensorProto.INT64, [0])
@@ -876,7 +885,7 @@ def constant_one_val_int64_test():
     return ([node], [], [y])
 
 
-@onnx_test
+@onnx_test()
 def const_of_shape_empty_input_test():
     tensor_val = onnx.helper.make_tensor('value', onnx.TensorProto.INT64, [1],
                                          [10])
@@ -903,7 +912,7 @@ def const_of_shape_empty_input_test():
     return ([shape_const, node], [], [y])
 
 
-@onnx_test
+@onnx_test()
 def const_of_shape_float_test():
     tensor_val = onnx.helper.make_tensor('value', onnx.TensorProto.FLOAT, [1],
                                          [10])
@@ -930,7 +939,7 @@ def const_of_shape_float_test():
     return ([shape_const, node], [], [y])
 
 
-@onnx_test
+@onnx_test()
 def const_of_shape_int64_test():
     tensor_val = onnx.helper.make_tensor('value', onnx.TensorProto.INT64, [1],
                                          [10])
@@ -955,7 +964,7 @@ def const_of_shape_int64_test():
     return ([shape_const, node], [], [y])
 
 
-@onnx_test
+@onnx_test()
 def const_of_shape_no_value_attr_test():
     shape_val = np.array([2, 3, 4]).astype(np.int64)
     shape_ts = helper.make_tensor(name='shape_tensor',
@@ -979,7 +988,7 @@ def const_of_shape_no_value_attr_test():
     return ([shape_const, node], [], [y])
 
 
-@onnx_test
+@onnx_test()
 def conv_1d_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3])
@@ -990,7 +999,7 @@ def conv_1d_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_3d_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 5, 5, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3, 3, 3])
@@ -1002,7 +1011,7 @@ def conv_3d_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_attr_fail_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3])
@@ -1016,7 +1025,7 @@ def conv_attr_fail_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_autopad_fail_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 32, 32])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 1, 1])
@@ -1033,7 +1042,7 @@ def conv_autopad_fail_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_autopad_same_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 32, 32])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3, 3])
@@ -1049,7 +1058,7 @@ def conv_autopad_same_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_bias_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 32, 32])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 5, 5])
@@ -1065,7 +1074,7 @@ def conv_bias_test():
     return ([node], [x, y, z], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_bn_relu_maxpool_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 32, 32])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 5, 5])
@@ -1101,7 +1110,7 @@ def conv_bn_relu_maxpool_test():
     return ([node0, node1, node2, node3], [x, y, z, m, n, k, l], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_dynamic_batch_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [None, 3, 5, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3, 3])
@@ -1112,7 +1121,7 @@ def conv_dynamic_batch_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_dynamic_img_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                       [1, 3, None, None])
@@ -1124,7 +1133,7 @@ def conv_dynamic_img_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_dynamic_weights_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 5, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT,
@@ -1136,7 +1145,7 @@ def conv_dynamic_weights_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_dynamic_img_and_weights_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                       [1, 3, None, None])
@@ -1149,7 +1158,7 @@ def conv_dynamic_img_and_weights_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_dynamic_batch_same_upper_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [None, 3, 5, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 3, 3])
@@ -1162,7 +1171,7 @@ def conv_dynamic_batch_same_upper_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_dynamic_img_same_upper_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                       [1, 3, None, None])
@@ -1177,7 +1186,7 @@ def conv_dynamic_img_same_upper_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_dynamic_kernel_same_lower_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 5, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT,
@@ -1191,7 +1200,7 @@ def conv_dynamic_kernel_same_lower_test():
     return ([node], [x, y], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_relu_maxpool_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 32, 32])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 5, 5])
@@ -1217,7 +1226,7 @@ def conv_relu_maxpool_test():
     return ([node1, node2, node3], [x, y, z], [out])
 
 
-@onnx_test
+@onnx_test()
 def conv_relu_maxpool_x2_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 32, 32])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [5, 3, 5, 5])
@@ -1261,7 +1270,7 @@ def conv_relu_maxpool_x2_test():
     return ([node1, node2, node3, node4, node5, node6], [x, y, z, m, n], [out])
 
 
-@onnx_test
+@onnx_test()
 def convinteger_bias_test():
     x = helper.make_tensor_value_info('0', TensorProto.INT8, [1, 3, 32, 32])
     y = helper.make_tensor_value_info('1', TensorProto.INT8, [1, 3, 5, 5])
@@ -1277,7 +1286,7 @@ def convinteger_bias_test():
     return ([node], [x, y, z], [out])
 
 
-@onnx_test
+@onnx_test()
 def cos_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -1291,7 +1300,7 @@ def cos_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def cosh_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1])
@@ -1305,7 +1314,7 @@ def cosh_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def deconv_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 3, 3])
     w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 1, 3, 3])
@@ -1319,7 +1328,7 @@ def deconv_test():
     return ([node], [x, w], [y])
 
 
-@onnx_test
+@onnx_test()
 def deconv_bias_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 3, 3])
     w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 1, 3, 3])
@@ -1334,7 +1343,7 @@ def deconv_bias_test():
     return ([node], [x, w, b], [y])
 
 
-@onnx_test
+@onnx_test()
 def deconv_input_pads_strides_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 3, 3])
     w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3])
@@ -1349,7 +1358,7 @@ def deconv_input_pads_strides_test():
     return ([node], [x, w], [y])
 
 
-@onnx_test
+@onnx_test()
 def deconv_input_pads_asymm_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 3, 3])
     w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3])
@@ -1364,7 +1373,7 @@ def deconv_input_pads_asymm_test():
     return ([node], [x, w], [y])
 
 
-@onnx_test
+@onnx_test()
 def deconv_input_pads_asymm_1d_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 3])
     w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3])
@@ -1380,7 +1389,7 @@ def deconv_input_pads_asymm_1d_test():
     return ([node], [x, w], [y])
 
 
-@onnx_test
+@onnx_test()
 def deconv_output_padding_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 3, 3])
     w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3])
@@ -1395,7 +1404,7 @@ def deconv_output_padding_test():
     return ([node], [x, w], [y])
 
 
-@onnx_test
+@onnx_test()
 def deconv_output_padding_3d_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 3, 3, 3])
     w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3, 3])
@@ -1410,7 +1419,7 @@ def deconv_output_padding_3d_test():
     return ([node], [x, w], [y])
 
 
-@onnx_test
+@onnx_test()
 def deconv_output_shape_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 3, 3])
     w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3])
@@ -1425,7 +1434,7 @@ def deconv_output_shape_test():
     return ([node], [x, w], [y])
 
 
-@onnx_test
+@onnx_test()
 def deconv_output_shape_3d_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 3, 3, 3])
     w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3, 3])
@@ -1440,7 +1449,7 @@ def deconv_output_shape_3d_test():
     return ([node], [x, w], [y])
 
 
-@onnx_test
+@onnx_test()
 def deconv_stride_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 3, 3])
     w = helper.make_tensor_value_info('w', TensorProto.FLOAT, [1, 2, 3, 3])
@@ -1454,7 +1463,7 @@ def deconv_stride_test():
     return ([node], [x, w], [y])
 
 
-@onnx_test
+@onnx_test()
 def depthtospace_test():
 
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 8, 5, 5])
@@ -1469,7 +1478,7 @@ def depthtospace_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def depthtospace_simple_test():
 
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 8, 2, 3])
@@ -1484,7 +1493,7 @@ def depthtospace_simple_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def depthtospace_crd_test():
 
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 8, 5, 5])
@@ -1499,7 +1508,7 @@ def depthtospace_crd_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def spacetodepth_test():
 
     x = helper.make_tensor_value_info('x', TensorProto.float, [2, 2, 10, 10])
@@ -1513,7 +1522,7 @@ def spacetodepth_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def spacetodepth_simple_test():
 
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 2, 4, 6])
@@ -1527,7 +1536,7 @@ def spacetodepth_simple_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def spacetodepth_invalid_blocksize_test():
 
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 2, 4, 6])
@@ -1541,7 +1550,7 @@ def spacetodepth_invalid_blocksize_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def spacetodepth_nondivisibility_test():
 
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 2, 5, 5])
@@ -1555,7 +1564,7 @@ def spacetodepth_nondivisibility_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def dequantizelinear_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.INT8, [5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1])
@@ -1570,7 +1579,7 @@ def dequantizelinear_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def dequantizelinear_zero_point_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.INT8, [5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1])
@@ -1601,17 +1610,17 @@ def make_dequantizelinear_axis_graph(axis):
     return ([node], [arg0, arg1, arg2], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def dequantizelinear_axis_test():
     return make_dequantizelinear_axis_graph(2)
 
 
-@onnx_test
+@onnx_test()
 def dequantizelinear_neg_axis_test():
     return make_dequantizelinear_axis_graph(-2)
 
 
-@onnx_test
+@onnx_test()
 def dropout_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 2, 2])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 2, 2])
@@ -1625,7 +1634,7 @@ def dropout_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def elu_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -1638,7 +1647,7 @@ def elu_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def embedding_bag_test():
 
     index_val = np.array([1, 0, 2])
@@ -1691,7 +1700,7 @@ def embedding_bag_test():
     return ([index, offset, node1, node2, node3], [weight], [y1, y2, y3])
 
 
-@onnx_test
+@onnx_test()
 def embedding_bag_offset_test():
 
     index_val = np.array([1, 0])
@@ -1730,7 +1739,7 @@ def embedding_bag_offset_test():
     return ([index, offset, node], [weight], [y])
 
 
-@onnx_test
+@onnx_test()
 def equal_test():
     ax1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
     x1 = helper.make_tensor("x1",
@@ -1750,7 +1759,7 @@ def equal_test():
     return ([node], [x2], [y], [x1])
 
 
-@onnx_test
+@onnx_test()
 def equal_bool_test():
 
     x1 = helper.make_tensor_value_info('x1', TensorProto.FLOAT, [2, 3])
@@ -1768,7 +1777,7 @@ def equal_bool_test():
     return ([node1, node2], [x1, x2], [y])
 
 
-@onnx_test
+@onnx_test()
 def erf_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10, 15])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10, 15])
@@ -1782,7 +1791,7 @@ def erf_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def exp_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -1796,7 +1805,7 @@ def exp_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def expand_test():
     shape_val = np.array([2, 3, 4, 5]).astype(np.int64)
     shape_ts = helper.make_tensor(name='shape_tensor',
@@ -1819,7 +1828,23 @@ def expand_test():
     return ([shape_const, node], [x], [y])
 
 
-@onnx_test
+@onnx_test(True)
+def external_constant_test():
+    x = np.array([0, 1, 2])
+    y = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
+
+    tensor = from_array(x)
+    tensor.name = 'const_tensor'
+
+    node = onnx.helper.make_node('Constant',
+                                 inputs=[],
+                                 outputs=['0'],
+                                 value=tensor)
+
+    return ([node], [], [y])
+
+
+@onnx_test()
 def eyelike_default_test():
     T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
     T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
@@ -1832,7 +1857,7 @@ def eyelike_default_test():
     return ([node], [T1], [T2])
 
 
-@onnx_test
+@onnx_test()
 def eyelike_double_test():
     T1 = helper.make_tensor_value_info('T1', TensorProto.DOUBLE, [6, 15])
     T2 = helper.make_tensor_value_info('T2', TensorProto.DOUBLE, [6, 15])
@@ -1845,7 +1870,7 @@ def eyelike_double_test():
     return ([node], [T1], [T2])
 
 
-@onnx_test
+@onnx_test()
 def eyelike_half_test():
     T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT16, [8, 8])
     T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT16, [8, 8])
@@ -1858,7 +1883,7 @@ def eyelike_half_test():
     return ([node], [T1], [T2])
 
 
-@onnx_test
+@onnx_test()
 def eyelike_k_test():
     T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
     T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
@@ -1866,7 +1891,7 @@ def eyelike_k_test():
     return ([node], [T1], [T2])
 
 
-@onnx_test
+@onnx_test()
 def eyelike_k_outofbounds_neg_test():
     T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [2, 4])
     T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [2, 4])
@@ -1877,7 +1902,7 @@ def eyelike_k_outofbounds_neg_test():
     return ([node], [T1], [T2])
 
 
-@onnx_test
+@onnx_test()
 def eyelike_k_outofbounds_pos_test():
     T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
     T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
@@ -1885,7 +1910,7 @@ def eyelike_k_outofbounds_pos_test():
     return ([node], [T1], [T2])
 
 
-@onnx_test
+@onnx_test()
 def eyelike_not_rank2_test():
     T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4, 2])
     T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
@@ -1897,7 +1922,7 @@ def eyelike_not_rank2_test():
     return ([node], [T1], [T2])
 
 
-@onnx_test
+@onnx_test()
 def eyelike_verify_test():
     T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
     T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
@@ -1905,7 +1930,7 @@ def eyelike_verify_test():
     return ([node], [T1], [T2])
 
 
-@onnx_test
+@onnx_test()
 def eyelike_verify_negk_test():
     T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
     T2 = helper.make_tensor_value_info('T2', TensorProto.FLOAT, [3, 4])
@@ -1916,7 +1941,7 @@ def eyelike_verify_negk_test():
     return ([node], [T1], [T2])
 
 
-@onnx_test
+@onnx_test()
 def eyelike_set_dtype_test():
     T1 = helper.make_tensor_value_info('T1', TensorProto.FLOAT, [3, 4])
     T2 = helper.make_tensor_value_info('T2', TensorProto.DOUBLE, [3, 4])
@@ -1927,7 +1952,7 @@ def eyelike_set_dtype_test():
     return ([node], [T1], [T2])
 
 
-@onnx_test
+@onnx_test()
 def flatten_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [6, 20])
@@ -1943,7 +1968,7 @@ def flatten_test():
     return ([node, node2], [x], [y, y2])
 
 
-@onnx_test
+@onnx_test()
 def flatten_nonstd_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 5, 4])
     y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [6, 20])
@@ -1966,7 +1991,7 @@ def flatten_nonstd_test():
     return ([trans, node, node2], [x], [y, y2])
 
 
-@onnx_test
+@onnx_test()
 def flatten_dyn_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [None, 3, 4, 5])
     y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [None, 20])
@@ -1979,7 +2004,7 @@ def flatten_dyn_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def floor_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -1993,7 +2018,7 @@ def floor_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def gather_test():
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [3, 4, 5, 6])
     i = helper.make_tensor_value_info('indices', TensorProto.INT32,
@@ -2010,7 +2035,7 @@ def gather_test():
     return ([node], [x, i], [y])
 
 
-@onnx_test
+@onnx_test()
 def gather_elements_axis0_test():
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [3, 4])
     i = helper.make_tensor_value_info('indices', TensorProto.INT32, [2, 3])
@@ -2026,7 +2051,7 @@ def gather_elements_axis0_test():
     return ([node], [x, i], [y])
 
 
-@onnx_test
+@onnx_test()
 def gather_elements_axis1_test():
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [3, 4])
     i = helper.make_tensor_value_info('indices', TensorProto.INT32, [2, 3])
@@ -2042,7 +2067,7 @@ def gather_elements_axis1_test():
     return ([node], [x, i], [y])
 
 
-@onnx_test
+@onnx_test()
 def gathernd_test():
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [2, 2])
     i = helper.make_tensor_value_info('indices', TensorProto.INT64, [2, 2])
@@ -2055,7 +2080,7 @@ def gathernd_test():
     return ([node], [x, i], [y])
 
 
-@onnx_test
+@onnx_test()
 def gathernd_batch_dims_test():
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [2, 2, 2])
     i = helper.make_tensor_value_info('indices', TensorProto.INT64, [2, 1])
@@ -2071,7 +2096,7 @@ def gathernd_batch_dims_test():
     return ([node], [x, i], [y])
 
 
-@onnx_test
+@onnx_test()
 def gemm_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5, 7])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [11, 5])
@@ -2089,7 +2114,7 @@ def gemm_test():
     return ([node], [x, y, z], [a])
 
 
-@onnx_test
+@onnx_test()
 def gemm_ex_test():
     m1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 1, 8, 6])
     m2 = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1, 1, 8, 7])
@@ -2106,7 +2131,7 @@ def gemm_ex_test():
     return ([node], [m1, m2, m3], [y])
 
 
-@onnx_test
+@onnx_test()
 def gemm_ex_brcst_test():
     m1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 1, 5, 6])
     m2 = helper.make_tensor_value_info('2', TensorProto.FLOAT, [1, 1, 5, 7])
@@ -2123,7 +2148,7 @@ def gemm_ex_brcst_test():
     return ([node], [m1, m2, m3], [y])
 
 
-@onnx_test
+@onnx_test()
 def gemm_half_test():
     m1 = helper.make_tensor_value_info('1', TensorProto.FLOAT16, [1, 1, 8, 6])
     m2 = helper.make_tensor_value_info('2', TensorProto.FLOAT16, [1, 1, 8, 7])
@@ -2140,7 +2165,7 @@ def gemm_half_test():
     return ([node], [m1, m2, m3], [y])
 
 
-@onnx_test
+@onnx_test()
 def globalavgpool_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 16, 16])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 1, 1])
@@ -2154,7 +2179,7 @@ def globalavgpool_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def globalavgpool_dyn_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                       [None, 3, 16, 16])
@@ -2169,7 +2194,7 @@ def globalavgpool_dyn_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def globallppool_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 16, 16])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 1, 1])
@@ -2183,7 +2208,7 @@ def globallppool_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def globallppool_dyn_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                       [1, 3, None, None])
@@ -2198,7 +2223,7 @@ def globallppool_dyn_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def globalmaxpool_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 16, 16])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 1, 1])
@@ -2212,7 +2237,7 @@ def globalmaxpool_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def globalmaxpool_dyn_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                       [None, 3, 32, 32])
@@ -2227,7 +2252,7 @@ def globalmaxpool_dyn_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def greater_test():
     ax1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
     x1 = helper.make_tensor("x1",
@@ -2247,7 +2272,7 @@ def greater_test():
     return ([node], [x2], [y], [x1])
 
 
-@onnx_test
+@onnx_test()
 def greater_bool_test():
 
     x1 = helper.make_tensor_value_info('x1', TensorProto.FLOAT, [2, 3])
@@ -2265,7 +2290,7 @@ def greater_bool_test():
     return ([node1, node2], [x1, x2], [y])
 
 
-@onnx_test
+@onnx_test()
 def greaterorequal_test():
 
     x1 = helper.make_tensor_value_info('x1', TensorProto.FLOAT, [3])
@@ -2281,7 +2306,7 @@ def greaterorequal_test():
     return ([node], [x1, x2], [y])
 
 
-@onnx_test
+@onnx_test()
 def group_conv_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 4, 16, 16])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 1, 3, 3])
@@ -2297,7 +2322,7 @@ def group_conv_test():
     return ([node], [x, y], [z])
 
 
-@onnx_test
+@onnx_test()
 def hardsigmoid_default_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 3, 4, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 3, 4, 5])
@@ -2307,7 +2332,7 @@ def hardsigmoid_default_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def hardsigmoid_double_test():
     x = helper.make_tensor_value_info('x', TensorProto.DOUBLE, [1, 3, 4, 5])
     y = helper.make_tensor_value_info('y', TensorProto.DOUBLE, [1, 3, 4, 5])
@@ -2321,7 +2346,7 @@ def hardsigmoid_double_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def hardsigmoid_half_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT16, [1, 3, 4, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT16, [1, 3, 4, 5])
@@ -2331,7 +2356,7 @@ def hardsigmoid_half_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def hardsigmoid_verify_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 5])
@@ -2341,7 +2366,7 @@ def hardsigmoid_verify_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def hardswish_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 5])
@@ -2351,7 +2376,7 @@ def hardswish_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def if_else_test():
     x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3])
     y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [2, 3])
@@ -2405,7 +2430,7 @@ def if_else_test():
     return ([node], [x, y], [res], [cond_tensor, xt_tensor, yt_tensor])
 
 
-@onnx_test
+@onnx_test()
 def if_literal_test():
     then_out = onnx.helper.make_tensor_value_info('then_out',
                                                   onnx.TensorProto.FLOAT, [5])
@@ -2453,7 +2478,7 @@ def if_literal_test():
     return ([node], [cond_input], [ret])
 
 
-@onnx_test
+@onnx_test()
 def if_param_excp_test():
     then_out = onnx.helper.make_tensor_value_info('then_out',
                                                   onnx.TensorProto.FLOAT,
@@ -2505,7 +2530,7 @@ def if_param_excp_test():
     return ([node], [cond_input, x, y], [ret])
 
 
-@onnx_test
+@onnx_test()
 def if_param_excp1_test():
     then_out = onnx.helper.make_tensor_value_info('sub_out',
                                                   onnx.TensorProto.FLOAT,
@@ -2540,7 +2565,7 @@ def if_param_excp1_test():
     return ([node], [cond_input, x], [ret])
 
 
-@onnx_test
+@onnx_test()
 def if_param_test():
     then_out = onnx.helper.make_tensor_value_info('then_out',
                                                   onnx.TensorProto.FLOAT,
@@ -2592,7 +2617,7 @@ def if_param_test():
     return ([node], [cond_input, x, y], [ret])
 
 
-@onnx_test
+@onnx_test()
 def if_pl_test():
     out_x = onnx.helper.make_tensor_value_info('out_x', onnx.TensorProto.FLOAT,
                                                [2, 3])
@@ -2660,7 +2685,7 @@ def if_pl_test():
     return ([node], [cond_input, x, y], [ret], [xt_tensor, yt_tensor])
 
 
-@onnx_test
+@onnx_test()
 def if_then_test():
     x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [2, 3])
     y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [2, 3])
@@ -2714,7 +2739,7 @@ def if_then_test():
     return ([node], [x, y], [res], [cond_tensor, xt_tensor, yt_tensor])
 
 
-@onnx_test
+@onnx_test()
 def if_tuple_test():
     x = onnx.helper.make_tensor_value_info('x', onnx.TensorProto.FLOAT, [1, 4])
     y = onnx.helper.make_tensor_value_info('y', onnx.TensorProto.FLOAT, [3, 4])
@@ -2785,7 +2810,7 @@ def if_tuple_test():
                      y], [res0, res1], [one_tensor, two_tensor, three_tensor])
 
 
-@onnx_test
+@onnx_test()
 def imagescaler_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 16, 16])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 16, 16])
@@ -2799,7 +2824,7 @@ def imagescaler_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def imagescaler_half_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [1, 3, 16, 16])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT16, [1, 3, 16, 16])
@@ -2813,7 +2838,7 @@ def imagescaler_half_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def implicit_add_bcast_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 4, 1])
@@ -2828,7 +2853,7 @@ def implicit_add_bcast_test():
     return ([node], [x, y], [z])
 
 
-@onnx_test
+@onnx_test()
 def implicit_pow_bcast_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 4, 1])
@@ -2844,7 +2869,7 @@ def implicit_pow_bcast_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def implicit_sub_bcast_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.UINT64, [2, 3, 4, 5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.UINT64, [4, 5])
@@ -2860,7 +2885,7 @@ def implicit_sub_bcast_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def initializer_not_an_input():
     values = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
     w = helper.make_tensor(name='w',
@@ -2880,7 +2905,7 @@ def initializer_not_an_input():
     return ([node], [x], [y], [w])
 
 
-@onnx_test
+@onnx_test()
 def instance_norm_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 2, 3, 3])
     scale = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2])
@@ -2894,7 +2919,7 @@ def instance_norm_test():
     return ([node], [x, scale, bias], [y])
 
 
-@onnx_test
+@onnx_test()
 def instance_norm_half_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [1, 2, 3, 3])
     scale = helper.make_tensor_value_info('1', TensorProto.FLOAT16, [2])
@@ -2908,7 +2933,7 @@ def instance_norm_half_test():
     return ([node], [x, scale, bias], [y])
 
 
-@onnx_test
+@onnx_test()
 def instance_norm_type_mismatch_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 2, 3, 3])
     scale = helper.make_tensor_value_info('1', TensorProto.FLOAT16, [2])
@@ -2922,7 +2947,7 @@ def instance_norm_type_mismatch_test():
     return ([node], [x, scale, bias], [y])
 
 
-@onnx_test
+@onnx_test()
 def instance_norm_invalid_type_test():
     x = helper.make_tensor_value_info('0', TensorProto.INT32, [1, 2, 3, 3])
     scale = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2])
@@ -2936,7 +2961,7 @@ def instance_norm_invalid_type_test():
     return ([node], [x, scale, bias], [y])
 
 
-@onnx_test
+@onnx_test()
 def instance_norm_nonbroadcastable_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 2, 3, 3])
     scale = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4])
@@ -2950,7 +2975,7 @@ def instance_norm_nonbroadcastable_test():
     return ([node], [x, scale, bias], [y])
 
 
-@onnx_test
+@onnx_test()
 def instance_norm_val_test():
     x = np.array([[[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
                    [[0, 1, 2], [3, 4, 5], [6, 7, 8]]]])
@@ -2980,7 +3005,7 @@ def instance_norm_val_test():
     return ([node], [], [y], [x_tensor, scale_tensor, bias_tensor])
 
 
-@onnx_test
+@onnx_test()
 def instance_norm_val_3d_test():
     x = np.array([[[[[0, 1], [2, 3]], [[4, 5], [6, 7]]],
                    [[[0, 1], [2, 3]], [[4, 5], [6, 7]]]]])
@@ -3010,7 +3035,7 @@ def instance_norm_val_3d_test():
     return ([node], [], [y], [x_tensor, scale_tensor, bias_tensor])
 
 
-@onnx_test
+@onnx_test()
 def isnan_float_test():
     t1 = helper.make_tensor_value_info('t1', TensorProto.FLOAT, [2, 3])
     t2 = helper.make_tensor_value_info('t2', TensorProto.FLOAT, [2, 3])
@@ -3023,7 +3048,7 @@ def isnan_float_test():
     return ([node], [t1], [t2])
 
 
-@onnx_test
+@onnx_test()
 def isnan_half_test():
     t1 = helper.make_tensor_value_info('t1', TensorProto.FLOAT16, [2, 3])
     t2 = helper.make_tensor_value_info('t2', TensorProto.FLOAT16, [2, 3])
@@ -3036,7 +3061,7 @@ def isnan_half_test():
     return ([node], [t1], [t2])
 
 
-@onnx_test
+@onnx_test()
 def layernorm_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 1, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 1, 5])
@@ -3099,7 +3124,7 @@ def layernorm_test():
              bias_add], [x, scale, bias], [y], [pow_tensor, epsilon_tensor])
 
 
-@onnx_test
+@onnx_test()
 def leaky_relu_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -3112,7 +3137,7 @@ def leaky_relu_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def less_test():
     ax1 = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
     x1 = helper.make_tensor("x1",
@@ -3132,7 +3157,7 @@ def less_test():
     return ([node], [x2], [y], [x1])
 
 
-@onnx_test
+@onnx_test()
 def less_bool_test():
 
     x1 = helper.make_tensor_value_info('x1', TensorProto.FLOAT, [2, 3])
@@ -3150,7 +3175,7 @@ def less_bool_test():
     return ([node1, node2], [x1, x2], [y])
 
 
-@onnx_test
+@onnx_test()
 def lessorequal_test():
 
     x1 = helper.make_tensor_value_info('x1', TensorProto.FLOAT, [3])
@@ -3166,7 +3191,7 @@ def lessorequal_test():
     return ([node], [x1, x2], [y])
 
 
-@onnx_test
+@onnx_test()
 def log_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -3180,7 +3205,7 @@ def log_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def logical_and_bcast_test():
     x = helper.make_tensor_value_info('0', TensorProto.BOOL, [2, 3, 4, 5])
     y = helper.make_tensor_value_info('1', TensorProto.BOOL, [4, 5])
@@ -3191,7 +3216,7 @@ def logical_and_bcast_test():
     return ([node], [x, y], [z])
 
 
-@onnx_test
+@onnx_test()
 def logical_or_test():
     x = helper.make_tensor_value_info('0', TensorProto.BOOL, [2, 3, 4, 5])
     y = helper.make_tensor_value_info('1', TensorProto.BOOL, [2, 3, 4, 5])
@@ -3202,7 +3227,7 @@ def logical_or_test():
     return ([node], [x, y], [z])
 
 
-@onnx_test
+@onnx_test()
 def logical_xor_bcast_test():
     x = helper.make_tensor_value_info('0', TensorProto.BOOL, [2, 3, 4, 5])
     y = helper.make_tensor_value_info('1', TensorProto.BOOL, [4, 1])
@@ -3213,7 +3238,7 @@ def logical_xor_bcast_test():
     return ([node], [x, y], [z])
 
 
-@onnx_test
+@onnx_test()
 def logsoftmax_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 5, 6])
@@ -3226,7 +3251,7 @@ def logsoftmax_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def logsoftmax_nonstd_input_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [6, 9])
     y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [3, 4])
@@ -3246,7 +3271,7 @@ def logsoftmax_nonstd_input_test():
     return ([node0, node1], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def loop_default_test():
     body = helper.make_graph([
         helper.make_node("Add", ["a", "b_in"], ["my_local"]),
@@ -3283,7 +3308,7 @@ def loop_default_test():
     return ([node], [a, b], [b_loop, uout])
 
 
-@onnx_test
+@onnx_test()
 def loop_test():
     body = helper.make_graph([
         helper.make_node("Add", ["a", "b_in"], ["my_local"]),
@@ -3324,7 +3349,7 @@ def loop_test():
     return ([node], [iter, cond, a, b], [b_loop, uout])
 
 
-@onnx_test
+@onnx_test()
 def lpnormalization_axis_error_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
@@ -3336,7 +3361,7 @@ def lpnormalization_axis_error_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def lpnormalization_default_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4])
@@ -3350,7 +3375,7 @@ def lpnormalization_default_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def lpnormalization_l1_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4])
@@ -3364,7 +3389,7 @@ def lpnormalization_l1_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def lpnormalization_l2_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4])
@@ -3376,7 +3401,7 @@ def lpnormalization_l2_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def lpnormalization_p_error_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 3])
@@ -3388,7 +3413,7 @@ def lpnormalization_p_error_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def lppool_l1_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 3, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 3, 3])
@@ -3401,7 +3426,7 @@ def lppool_l1_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def lppool_l2_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 3, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 3, 3])
@@ -3414,7 +3439,7 @@ def lppool_l2_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def lrn_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 28, 24, 24])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 28, 24, 24])
@@ -3430,7 +3455,7 @@ def lrn_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def matmul_bmbm_test():
     m1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 6, 7])
     m2 = helper.make_tensor_value_info('2', TensorProto.FLOAT, [5, 2, 1, 7, 8])
@@ -3445,7 +3470,7 @@ def matmul_bmbm_test():
     return ([node], [m1, m2], [y])
 
 
-@onnx_test
+@onnx_test()
 def matmul_bmv_test():
     m1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 6, 7])
     m2 = helper.make_tensor_value_info('2', TensorProto.FLOAT, [7])
@@ -3460,7 +3485,7 @@ def matmul_bmv_test():
     return ([node], [m1, m2], [y])
 
 
-@onnx_test
+@onnx_test()
 def matmul_mv_test():
     m1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [6, 7])
     m2 = helper.make_tensor_value_info('2', TensorProto.FLOAT, [7])
@@ -3475,7 +3500,7 @@ def matmul_mv_test():
     return ([node], [m1, m2], [y])
 
 
-@onnx_test
+@onnx_test()
 def matmul_vbm_test():
     m1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [7])
     m2 = helper.make_tensor_value_info('2', TensorProto.FLOAT, [5, 7, 8])
@@ -3490,7 +3515,7 @@ def matmul_vbm_test():
     return ([node], [m1, m2], [y])
 
 
-@onnx_test
+@onnx_test()
 def matmul_vm_test():
     m1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [7])
     m2 = helper.make_tensor_value_info('2', TensorProto.FLOAT, [7, 8])
@@ -3505,7 +3530,7 @@ def matmul_vm_test():
     return ([node], [m1, m2], [y])
 
 
-@onnx_test
+@onnx_test()
 def matmul_vv_test():
     m1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [7])
     m2 = helper.make_tensor_value_info('2', TensorProto.FLOAT, [7])
@@ -3520,7 +3545,7 @@ def matmul_vv_test():
     return ([node], [m1, m2], [y])
 
 
-@onnx_test
+@onnx_test()
 def matmulinteger_test():
     m1 = helper.make_tensor_value_info('1', TensorProto.INT8, [3, 6, 16])
     m2 = helper.make_tensor_value_info('2', TensorProto.INT8, [3, 16, 8])
@@ -3535,7 +3560,7 @@ def matmulinteger_test():
     return ([node], [m1, m2], [y])
 
 
-@onnx_test
+@onnx_test()
 def max_test():
     a = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     b = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -3551,7 +3576,7 @@ def max_test():
     return ([node], [a, b, c], [y])
 
 
-@onnx_test
+@onnx_test()
 def maxpool_notset_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 1, 1])
@@ -3567,7 +3592,7 @@ def maxpool_notset_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def maxpool_same_upper_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1, 1, 5, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1, 1, 5, 5])
@@ -3581,7 +3606,7 @@ def maxpool_same_upper_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def mean_broadcast_test():
     data_0 = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3, 4])
     data_1 = helper.make_tensor_value_info('1', TensorProto.FLOAT,
@@ -3600,7 +3625,7 @@ def mean_broadcast_test():
     return ([node], [data_0, data_1, data_2, data_3, data_4], [mean])
 
 
-@onnx_test
+@onnx_test()
 def mean_fp16_test():
     data_0 = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [1, 2, 3])
     data_1 = helper.make_tensor_value_info('1', TensorProto.FLOAT16, [1, 2, 3])
@@ -3616,7 +3641,7 @@ def mean_fp16_test():
     return ([node], [data_0, data_1, data_2], [mean])
 
 
-@onnx_test
+@onnx_test()
 def mean_invalid_broadcast_test():
     data_0 = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 2, 3])
     data_1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 2, 3])
@@ -3631,7 +3656,7 @@ def mean_invalid_broadcast_test():
     return ([node], [data_0, data_1, data_2], [mean])
 
 
-@onnx_test
+@onnx_test()
 def mean_single_input_test():
     data_0 = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 2, 3])
     mean = helper.make_tensor_value_info('mean', TensorProto.FLOAT, [1, 2, 3])
@@ -3641,7 +3666,7 @@ def mean_single_input_test():
     return ([node], [data_0], [mean])
 
 
-@onnx_test
+@onnx_test()
 def mean_test():
     data = [
         helper.make_tensor_value_info(str(i), TensorProto.DOUBLE, [2, 2, 2])
@@ -3655,7 +3680,7 @@ def mean_test():
     return ([node], data, [mean])
 
 
-@onnx_test
+@onnx_test()
 def mean_integral_test():
     data = [
         helper.make_tensor_value_info(str(i), TensorProto.INT32, [2, 2, 2])
@@ -3669,7 +3694,7 @@ def mean_integral_test():
     return ([node], data, [mean])
 
 
-@onnx_test
+@onnx_test()
 def min_test():
     a = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     b = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -3685,7 +3710,7 @@ def min_test():
     return ([node], [a, b, c], [y])
 
 
-@onnx_test
+@onnx_test()
 def mod_test():
     a = helper.make_tensor_value_info('0', TensorProto.INT32, [3, 3, 3])
     b = helper.make_tensor_value_info('1', TensorProto.INT32, [3, 3, 3])
@@ -3696,7 +3721,7 @@ def mod_test():
     return ([node], [a, b], [y])
 
 
-@onnx_test
+@onnx_test()
 def mod_test_half():
     a = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [3, 3, 3])
     b = helper.make_tensor_value_info('1', TensorProto.FLOAT16, [3, 3, 3])
@@ -3707,7 +3732,7 @@ def mod_test_half():
     return ([node], [a, b], [y])
 
 
-@onnx_test
+@onnx_test()
 def mod_test_different_dtypes():
     a = helper.make_tensor_value_info('0', TensorProto.INT16, [3, 3, 3])
     b = helper.make_tensor_value_info('1', TensorProto.INT32, [3, 3, 3])
@@ -3722,7 +3747,7 @@ def mod_test_different_dtypes():
     return ([node], [a, b], [y])
 
 
-@onnx_test
+@onnx_test()
 def mod_test_fmod():
     a = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3, 3, 3])
     b = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 3, 3])
@@ -3738,7 +3763,7 @@ def mod_test_fmod():
     return ([node], [a, b], [y])
 
 
-@onnx_test
+@onnx_test()
 def mod_test_fmod_half():
     a = helper.make_tensor_value_info('0', TensorProto.FLOAT16, [3, 3, 3])
     b = helper.make_tensor_value_info('1', TensorProto.FLOAT16, [3, 3, 3])
@@ -3752,7 +3777,7 @@ def mod_test_fmod_half():
     return ([node], [a, b], [y])
 
 
-@onnx_test
+@onnx_test()
 def mod_test_fmod_different_dtypes():
     a = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3, 3, 3])
     b = helper.make_tensor_value_info('1', TensorProto.INT32, [3, 3, 3])
@@ -3768,7 +3793,7 @@ def mod_test_fmod_different_dtypes():
     return ([node], [a, b], [y])
 
 
-@onnx_test
+@onnx_test()
 def multinomial_test():
     sample_size = 10
     seed = 0.0
@@ -3785,7 +3810,7 @@ def multinomial_test():
     return ([node], [input], [output])
 
 
-@onnx_test
+@onnx_test()
 def multinomial_generated_seed_test():
     sample_size = 10
     input = helper.make_tensor_value_info("input", TensorProto.FLOAT, [1, 10])
@@ -3800,7 +3825,7 @@ def multinomial_generated_seed_test():
     return ([node], [input], [output])
 
 
-@onnx_test
+@onnx_test()
 def multinomial_dtype_error_test():
     sample_size = 10
     dtype = 0
@@ -3817,7 +3842,7 @@ def multinomial_dtype_error_test():
     return ([node], [input], [output])
 
 
-@onnx_test
+@onnx_test()
 def multinomial_int64_test():
     sample_size = 10
     dtype = 7
@@ -3836,7 +3861,7 @@ def multinomial_int64_test():
     return ([node], [input], [output])
 
 
-@onnx_test
+@onnx_test()
 def neg_test():
     x = helper.make_tensor_value_info('0', TensorProto.INT64, [2, 3])
     y = helper.make_tensor_value_info('1', TensorProto.INT64, [2, 3])
@@ -3846,7 +3871,7 @@ def neg_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def neg_dynamic_test():
     x = helper.make_tensor_value_info('0', TensorProto.INT64, [None, 3])
     y = helper.make_tensor_value_info('1', TensorProto.INT64, [None, 3])
@@ -3856,7 +3881,7 @@ def neg_dynamic_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def nms_test():
     b = helper.make_tensor_value_info('boxes', TensorProto.FLOAT, [1, 6, 4])
     s = helper.make_tensor_value_info('scores', TensorProto.FLOAT, [1, 1, 6])
@@ -3881,7 +3906,7 @@ def nms_test():
     return ([node], [b, s, mo, iou, st], [out])
 
 
-@onnx_test
+@onnx_test()
 def nms_use_dyn_output_false_test():
     b = helper.make_tensor_value_info('boxes', TensorProto.FLOAT, [1, 6, 4])
     s = helper.make_tensor_value_info('scores', TensorProto.FLOAT, [1, 1, 6])
@@ -3906,7 +3931,7 @@ def nms_use_dyn_output_false_test():
     return ([node], [b, s, mo, iou, st], [out])
 
 
-@onnx_test
+@onnx_test()
 def nms_dynamic_batch_test():
     b = helper.make_tensor_value_info('boxes', TensorProto.FLOAT, [None, 6, 4])
     s = helper.make_tensor_value_info('scores', TensorProto.FLOAT,
@@ -3933,7 +3958,7 @@ def nms_dynamic_batch_test():
     return ([node], [b, s, mo, iou, st], [out])
 
 
-@onnx_test
+@onnx_test()
 def nms_dynamic_boxes_test():
     b = helper.make_tensor_value_info('boxes', TensorProto.FLOAT, [1, None, 4])
     s = helper.make_tensor_value_info('scores', TensorProto.FLOAT,
@@ -3958,7 +3983,7 @@ def nms_dynamic_boxes_test():
     return ([node], [b, s, mo, iou, st], [out])
 
 
-@onnx_test
+@onnx_test()
 def nms_dynamic_classes_test():
     b = helper.make_tensor_value_info('boxes', TensorProto.FLOAT, [1, 6, 4])
     s = helper.make_tensor_value_info('scores', TensorProto.FLOAT,
@@ -3983,7 +4008,7 @@ def nms_dynamic_classes_test():
     return ([node], [b, s, mo, iou, st], [out])
 
 
-@onnx_test
+@onnx_test()
 def not_test():
     x = helper.make_tensor_value_info('0', TensorProto.INT32, [4])
     y = helper.make_tensor_value_info('1', TensorProto.INT32, [4])
@@ -3993,7 +4018,7 @@ def not_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def not_bool_test():
     x = helper.make_tensor_value_info('0', TensorProto.BOOL, [4])
     y = helper.make_tensor_value_info('1', TensorProto.BOOL, [4])
@@ -4003,7 +4028,7 @@ def not_bool_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def no_pad_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 2])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 2])
@@ -4016,7 +4041,7 @@ def no_pad_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def nonzero_dynamic_test():
     x = helper.make_tensor_value_info('data', TensorProto.BOOL, [2, 2])
     y = helper.make_tensor_value_info('indices', TensorProto.INT64, [2, 3])
@@ -4028,7 +4053,7 @@ def nonzero_dynamic_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def nonzero_test():
     data1 = np.array([[1., 0.], [1., 1.]])
     data = helper.make_tensor(name='data',
@@ -4044,7 +4069,7 @@ def nonzero_test():
     return ([node], [], [y], [data])
 
 
-@onnx_test
+@onnx_test()
 def nonzero_int_test():
     data1 = np.array([[1, 1, 0], [1, 0, 1]])
     data = helper.make_tensor(name='data',
@@ -4060,7 +4085,7 @@ def nonzero_int_test():
     return ([node], [], [y], [data])
 
 
-@onnx_test
+@onnx_test()
 def onehot_test():
     axis_value = 0
     depth = np.array([3])
@@ -4082,7 +4107,7 @@ def onehot_test():
     return ([node], [indices, values], [y], [depth_tensor])
 
 
-@onnx_test
+@onnx_test()
 def pad_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 2])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 4])
@@ -4095,7 +4120,7 @@ def pad_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def pad_3arg_test():
     values = np.array([1])
     val_tensor = helper.make_tensor(name='val',
@@ -4127,7 +4152,7 @@ def pad_3arg_test():
     return ([arg_val, arg_pad, node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def pad_reflect_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 2])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 5])
@@ -4150,7 +4175,7 @@ def pad_reflect_test():
     return ([arg_pad, node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def pad_reflect_multiaxis_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 5])
@@ -4173,7 +4198,7 @@ def pad_reflect_multiaxis_test():
     return ([arg_pad, node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def pow_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 3, 4, 5])
@@ -4189,7 +4214,7 @@ def pow_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def pow_fp32_i64_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.INT64, [2, 3, 4, 5])
@@ -4205,7 +4230,7 @@ def pow_fp32_i64_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def pow_i64_fp32_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.INT64, [2, 3, 4, 5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 3, 4, 5])
@@ -4221,7 +4246,7 @@ def pow_i64_fp32_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def prefix_scan_sum_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2, 2])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 2])
@@ -4238,7 +4263,7 @@ def prefix_scan_sum_test():
     return ([node], [x], [y], [axis_tensor])
 
 
-@onnx_test
+@onnx_test()
 def prelu_brcst_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [4, 5])
@@ -4254,7 +4279,7 @@ def prelu_brcst_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def quantizelinear_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1])
@@ -4269,7 +4294,7 @@ def quantizelinear_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def quantizelinear_int32_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.INT32, [5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1])
@@ -4284,7 +4309,7 @@ def quantizelinear_int32_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def quantizelinear_zero_point_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1])
@@ -4315,17 +4340,17 @@ def make_quantizelinear_axis_graph(axis):
     return ([node], [arg0, arg1, arg2], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def quantizelinear_axis_test():
     return make_quantizelinear_axis_graph(2)
 
 
-@onnx_test
+@onnx_test()
 def quantizelinear_neg_axis_test():
     return make_quantizelinear_axis_graph(-2)
 
 
-@onnx_test
+@onnx_test()
 def randomnormal_test():
     dtype = 11
     mean = 10.0
@@ -4347,7 +4372,7 @@ def randomnormal_test():
     return ([node], [], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomnormal_dtype_error_test():
     dtype = 6
     shape = [2, 3, 4]
@@ -4363,7 +4388,7 @@ def randomnormal_dtype_error_test():
     return ([node], [], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomnormal_generated_seed_test():
     sample_size = 10
     input = helper.make_tensor_value_info("input", TensorProto.FLOAT, [1, 10])
@@ -4378,7 +4403,7 @@ def randomnormal_generated_seed_test():
     return ([node], [input], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomnormal_shape_error_test():
     dtype = 1
     output = helper.make_tensor_value_info('output', TensorProto.FLOAT,
@@ -4392,7 +4417,7 @@ def randomnormal_shape_error_test():
     return ([node], [], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomnormallike_test():
     dtype = 10
     mean = 10.0
@@ -4414,7 +4439,7 @@ def randomnormallike_test():
     return ([node], [input], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomnormallike_type_error_test():
     seed = 0
     input = helper.make_tensor_value_info('input', TensorProto.INT32,
@@ -4430,7 +4455,7 @@ def randomnormallike_type_error_test():
     return ([node], [input], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomuniform_test():
     dtype = 11
     high = 1.0
@@ -4452,7 +4477,7 @@ def randomuniform_test():
     return ([node], [], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomuniform_dtype_error_test():
     dtype = 6
     shape = [2, 3, 4]
@@ -4468,7 +4493,7 @@ def randomuniform_dtype_error_test():
     return ([node], [], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomuniform_generated_seed_test():
     sample_size = 10
     input = helper.make_tensor_value_info("input", TensorProto.FLOAT, [1, 10])
@@ -4483,7 +4508,7 @@ def randomuniform_generated_seed_test():
     return ([node], [input], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomuniform_shape_error_test():
     dtype = 1
     output = helper.make_tensor_value_info('output', TensorProto.FLOAT,
@@ -4497,7 +4522,7 @@ def randomuniform_shape_error_test():
     return ([node], [], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomuniformlike_test():
     dtype = 10
     high = 10.0
@@ -4519,7 +4544,7 @@ def randomuniformlike_test():
     return ([node], [input], [output])
 
 
-@onnx_test
+@onnx_test()
 def randomuniformlike_type_error_test():
     seed = 0
     input = helper.make_tensor_value_info('input', TensorProto.INT32,
@@ -4535,7 +4560,7 @@ def randomuniformlike_type_error_test():
     return ([node], [input], [output])
 
 
-@onnx_test
+@onnx_test()
 def range_test():
 
     start_val = np.array([10])
@@ -4578,7 +4603,7 @@ def range_test():
     return ([start, limit, delta, node], [], [y])
 
 
-@onnx_test
+@onnx_test()
 def range_float_test():
 
     start_val = np.array([2])
@@ -4621,7 +4646,7 @@ def range_float_test():
     return ([start, limit, delta, node], [], [y])
 
 
-@onnx_test
+@onnx_test()
 def recip_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3])
@@ -4635,7 +4660,7 @@ def recip_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reducel1_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6])
@@ -4678,7 +4703,7 @@ def reducel1_dyn_noaxes_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reducel2_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 5])
@@ -4693,7 +4718,7 @@ def reducel2_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reduce_log_sum_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 1, 5, 6])
@@ -4708,7 +4733,7 @@ def reduce_log_sum_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reduce_log_sum_exp_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [4, 5, 6])
@@ -4723,7 +4748,7 @@ def reduce_log_sum_exp_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reducemax_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6])
@@ -4754,7 +4779,7 @@ def reducemax_dyn_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reducemean_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4])
@@ -4769,7 +4794,7 @@ def reducemean_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reducemean_keepdims_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6])
@@ -4784,7 +4809,7 @@ def reducemean_keepdims_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reducemin_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 1, 5, 1])
@@ -4799,7 +4824,7 @@ def reducemin_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reduceprod_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6])
@@ -4814,7 +4839,7 @@ def reduceprod_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reducesum_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6])
@@ -4829,7 +4854,7 @@ def reducesum_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reducesum_empty_axes_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6])
@@ -4848,7 +4873,7 @@ def reducesum_empty_axes_test():
     return ([node], [x], [y], [axes_tensor])
 
 
-@onnx_test
+@onnx_test()
 def reducesum_noop_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 6])
@@ -4867,7 +4892,7 @@ def reducesum_noop_test():
     return ([node], [x], [y], [axes_tensor])
 
 
-@onnx_test
+@onnx_test()
 def reducesum_keepdims_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 1])
@@ -4882,7 +4907,7 @@ def reducesum_keepdims_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reducesum_multiaxis_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 1, 1])
@@ -4897,7 +4922,7 @@ def reducesum_multiaxis_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reducesum_square_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 4, 6])
@@ -4912,7 +4937,7 @@ def reducesum_square_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reshape_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [4, 2, 3])
     x_shape = helper.make_tensor_value_info('1', TensorProto.INT64, [2])
@@ -4931,7 +4956,7 @@ def reshape_test():
             [helper.make_tensor('1', TensorProto.INT64, [2], [3, 8])])
 
 
-@onnx_test
+@onnx_test()
 def reshape_non_standard_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3, 4])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [4, 3, 2])
@@ -4951,7 +4976,7 @@ def reshape_non_standard_test():
     return ([trans, res], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def resize_downsample_f_test():
     scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
     scale_tensor = helper.make_tensor(name='scales',
@@ -4973,7 +4998,7 @@ def resize_downsample_f_test():
     return ([node], [X], [Y], [scale_tensor])
 
 
-@onnx_test
+@onnx_test()
 def resize_downsample_c_test():
     scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
     scale_tensor = helper.make_tensor(name='scales',
@@ -4994,7 +5019,7 @@ def resize_downsample_c_test():
     return ([node], [X], [Y], [scale_tensor])
 
 
-@onnx_test
+@onnx_test()
 def resize_downsample_linear_test():
     scales = np.array([1.0, 1.0, 0.6, 0.5], dtype=np.float32)
     scale_tensor = helper.make_tensor(name='scales',
@@ -5013,7 +5038,7 @@ def resize_downsample_linear_test():
     return ([node], [X], [Y], [scale_tensor])
 
 
-@onnx_test
+@onnx_test()
 def resize_nonstd_input_test():
     scales = np.array([1.0, 1.0, 0.6, 0.6], dtype=np.float32)
     scale_tensor = helper.make_tensor(name='scales',
@@ -5039,7 +5064,7 @@ def resize_nonstd_input_test():
     return ([trn, node], [X], [Y], [scale_tensor])
 
 
-@onnx_test
+@onnx_test()
 def resize_outsize_test():
     out_lens = np.array([1, 1, 4, 6], dtype=np.int64)
     out_lens_tensor = helper.make_tensor(name='out_lens',
@@ -5062,7 +5087,7 @@ def resize_outsize_test():
     return ([node], [X], [Y], [out_lens_tensor])
 
 
-@onnx_test
+@onnx_test()
 def resize_upsample_linear_ac_test():
     scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
     scales_tensor = helper.make_tensor(name='scales',
@@ -5083,7 +5108,7 @@ def resize_upsample_linear_ac_test():
     return ([node], [X], [Y], [scales_tensor])
 
 
-@onnx_test
+@onnx_test()
 def resize_upsample_linear_test():
     scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
     scales_tensor = helper.make_tensor(name='scales',
@@ -5102,7 +5127,7 @@ def resize_upsample_linear_test():
     return ([node], [X], [Y], [scales_tensor])
 
 
-@onnx_test
+@onnx_test()
 def resize_upsample_pf_test():
     scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
     scale_tensor = helper.make_tensor(name='scales',
@@ -5121,7 +5146,7 @@ def resize_upsample_pf_test():
     return ([node], [X], [Y], [scale_tensor])
 
 
-@onnx_test
+@onnx_test()
 def resize_upsample_pc_test():
     scales = np.array([1.0, 1.0, 2.0, 1.5], dtype=np.float32)
     scale_tensor = helper.make_tensor(name='scales',
@@ -5144,7 +5169,7 @@ def resize_upsample_pc_test():
     return ([node], [X], [Y], [scale_tensor])
 
 
-@onnx_test
+@onnx_test()
 def reversesequence_4D_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2, 2, 2])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 2, 2])
@@ -5160,7 +5185,7 @@ def reversesequence_4D_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reversesequence_batch_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [4, 4])
     seq_lens = np.array([1, 2, 3, 4])
@@ -5188,7 +5213,7 @@ def reversesequence_batch_test():
     return ([arg_seq_lens, node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reversesequence_batch_axis_err_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [4, 4, 2])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [4, 4, 2])
@@ -5204,7 +5229,7 @@ def reversesequence_batch_axis_err_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reversesequence_rank_err_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [4])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [4])
@@ -5218,7 +5243,7 @@ def reversesequence_rank_err_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reversesequence_sequence_lens_shape_err_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [4, 4])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [4, 4])
@@ -5232,7 +5257,7 @@ def reversesequence_sequence_lens_shape_err_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reversesequence_same_axis_err_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [4, 4])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [4, 4])
@@ -5248,7 +5273,7 @@ def reversesequence_same_axis_err_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reversesequence_time_axis_err_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [4, 4, 2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [4, 4, 2, 3])
@@ -5264,7 +5289,7 @@ def reversesequence_time_axis_err_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def reversesequence_time_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [4, 4])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [4, 4])
@@ -5280,7 +5305,7 @@ def reversesequence_time_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def roialign_default_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10, 4, 7, 8])
     roi = helper.make_tensor_value_info('rois', TensorProto.FLOAT, [8, 4])
@@ -5294,7 +5319,7 @@ def roialign_default_test():
     return ([node], [x, roi, bi], [y])
 
 
-@onnx_test
+@onnx_test()
 def roialign_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10, 5, 4, 7])
     roi = helper.make_tensor_value_info('rois', TensorProto.FLOAT, [8, 4])
@@ -5315,7 +5340,7 @@ def roialign_test():
     return ([node], [x, roi, bi], [y])
 
 
-@onnx_test
+@onnx_test()
 def scatter_add_test():
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [3, 4, 5, 6])
     i = helper.make_tensor_value_info('indices', TensorProto.INT32,
@@ -5335,7 +5360,7 @@ def scatter_add_test():
     return ([node], [x, i, u], [y])
 
 
-@onnx_test
+@onnx_test()
 def scatter_mul_test():
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [3, 4, 5, 6])
     i = helper.make_tensor_value_info('indices', TensorProto.INT32,
@@ -5355,7 +5380,7 @@ def scatter_mul_test():
     return ([node], [x, i, u], [y])
 
 
-@onnx_test
+@onnx_test()
 def scatter_none_test():
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [3, 4, 5, 6])
     i = helper.make_tensor_value_info('indices', TensorProto.INT32,
@@ -5375,7 +5400,7 @@ def scatter_none_test():
     return ([node], [x, i, u], [y])
 
 
-@onnx_test
+@onnx_test()
 def scatternd_add_test():
     data = helper.make_tensor_value_info('data', TensorProto.FLOAT, [2, 2, 2])
     indices = helper.make_tensor_value_info('indices', TensorProto.INT64,
@@ -5393,7 +5418,7 @@ def scatternd_add_test():
     return ([node], [data, indices, updates], [output])
 
 
-@onnx_test
+@onnx_test()
 def scatternd_mul_test():
     data = helper.make_tensor_value_info('data', TensorProto.FLOAT, [2, 2, 2])
     indices = helper.make_tensor_value_info('indices', TensorProto.INT64,
@@ -5411,7 +5436,7 @@ def scatternd_mul_test():
     return ([node], [data, indices, updates], [output])
 
 
-@onnx_test
+@onnx_test()
 def scatternd_test():
     data = helper.make_tensor_value_info('data', TensorProto.FLOAT, [2, 2, 2])
     indices = helper.make_tensor_value_info('indices', TensorProto.INT64,
@@ -5428,7 +5453,7 @@ def scatternd_test():
     return ([node], [data, indices, updates], [output])
 
 
-@onnx_test
+@onnx_test()
 def selu_test():
     x = helper.make_tensor_value_info('x', TensorProto.DOUBLE, [2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.DOUBLE, [2, 3])
@@ -5442,7 +5467,7 @@ def selu_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def shape_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 4, 5, 6])
     y = helper.make_tensor_value_info('y', TensorProto.INT64, [4])
@@ -5456,7 +5481,7 @@ def shape_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def shape_gather_test():
     values = np.array([1])
     # value = helper.make_tensor_value_info('value', TensorProto.INT32, [1])
@@ -5491,7 +5516,7 @@ def shape_gather_test():
     return ([node_const, node_shape, node_gather], [x], [z])
 
 
-@onnx_test
+@onnx_test()
 def sign_test():
     x = helper.make_tensor_value_info('x', TensorProto.DOUBLE, [10, 5])
     y = helper.make_tensor_value_info('y', TensorProto.DOUBLE, [10, 5])
@@ -5505,7 +5530,7 @@ def sign_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def sin_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -5519,7 +5544,7 @@ def sin_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def sinh_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -5533,7 +5558,7 @@ def sinh_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def sinh_dynamic_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [None])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [None])
@@ -5547,7 +5572,7 @@ def sinh_dynamic_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def size_float_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 3, 4])
     y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
@@ -5559,7 +5584,7 @@ def size_float_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def size_half_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT16, [3, 1])
     y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
@@ -5571,7 +5596,7 @@ def size_half_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def size_int_test():
     x = helper.make_tensor_value_info('x', TensorProto.INT32, [8, 2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
@@ -5583,7 +5608,7 @@ def size_int_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def size_verify_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 5, 3])
     y = helper.make_tensor_value_info('y', TensorProto.INT64, [1])
@@ -5595,7 +5620,7 @@ def size_verify_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def slice_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3, 2])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 2])
@@ -5610,7 +5635,7 @@ def slice_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def slice_3arg_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [5, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 5])
@@ -5642,7 +5667,7 @@ def slice_3arg_test():
     return ([arg_start, arg_end, node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def slice_5arg_test():
     step = np.array([1, 1])
     step_tensor = helper.make_tensor(name="step",
@@ -5695,7 +5720,7 @@ def slice_5arg_test():
     return ([arg_step, arg_axis, arg_end, arg_start, node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def slice_5arg_reverse_test():
     step = np.array([-1, 1])
     step_tensor = helper.make_tensor(name="step",
@@ -5748,7 +5773,7 @@ def slice_5arg_reverse_test():
     return ([arg_step, arg_axis, arg_end, arg_start, node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def slice_5arg_step_test():
     step = np.array([-2, 2])
     step_tensor = helper.make_tensor(name="step",
@@ -5801,7 +5826,7 @@ def slice_5arg_step_test():
     return ([arg_step, arg_axis, arg_end, arg_start, node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def slice_max_end_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [10, 20])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [9, 17])
@@ -5816,7 +5841,7 @@ def slice_max_end_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def softmax_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3])
@@ -5826,7 +5851,7 @@ def softmax_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def softmax_nonstd_input_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [6, 8])
     y = helper.make_tensor_value_info('2', TensorProto.FLOAT, [3, 4])
@@ -5843,7 +5868,7 @@ def softmax_nonstd_input_test():
     return ([node0, node1], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def softmax_dyn_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [None, 3, 4, 4])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [None, 3, 4, 4])
@@ -5853,7 +5878,7 @@ def softmax_dyn_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def softsign_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [5])
@@ -5872,7 +5897,7 @@ def softplus_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def softsign_nd_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT16, [3, 4, 5])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT16, [3, 4, 5])
@@ -5891,7 +5916,7 @@ def softplus_nd_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def split_minus_axis_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10, 15])
     y1 = helper.make_tensor_value_info('y1', TensorProto.FLOAT, [10, 5])
@@ -5908,7 +5933,7 @@ def split_minus_axis_test():
     return ([node], [x], [y1, y2, y3])
 
 
-@onnx_test
+@onnx_test()
 def split_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10, 15])
     y1 = helper.make_tensor_value_info('y1', TensorProto.FLOAT, [10, 7])
@@ -5924,7 +5949,7 @@ def split_test():
     return ([node], [x], [y1, y2, y3])
 
 
-@onnx_test
+@onnx_test()
 def split_test_default():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10, 15])
     y1 = helper.make_tensor_value_info('y1', TensorProto.FLOAT, [5, 15])
@@ -5939,7 +5964,7 @@ def split_test_default():
     return ([node], [x], [y1, y2])
 
 
-@onnx_test
+@onnx_test()
 def split_test_no_attribute():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [300, 15])
     y1 = helper.make_tensor_value_info('y1', TensorProto.FLOAT, [75, 15])
@@ -5966,7 +5991,7 @@ def split_test_no_attribute():
     return ([const_node, node], [x], [y1, y2, y3, y4])
 
 
-@onnx_test
+@onnx_test()
 def split_test_no_attribute_invalid_split():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [300, 15])
     y1 = helper.make_tensor_value_info('y1', TensorProto.FLOAT, [75, 15])
@@ -5993,7 +6018,7 @@ def split_test_no_attribute_invalid_split():
     return ([const_node, node], [x], [y1, y2, y3, y4])
 
 
-@onnx_test
+@onnx_test()
 def split_test_invalid_split():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10, 15])
     y1 = helper.make_tensor_value_info('y1', TensorProto.FLOAT, [10, 7])
@@ -6009,7 +6034,7 @@ def split_test_invalid_split():
     return ([node], [x], [y1, y2, y3])
 
 
-@onnx_test
+@onnx_test()
 def split_test_no_attribute_invalid_input_split():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10, 15])
     y1 = helper.make_tensor_value_info('y1', TensorProto.FLOAT, [10, 7])
@@ -6025,7 +6050,7 @@ def split_test_no_attribute_invalid_input_split():
     return ([node], [x], [y1, y2, y3])
 
 
-@onnx_test
+@onnx_test()
 def sqrt_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10, 15])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10, 15])
@@ -6039,7 +6064,7 @@ def sqrt_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def squeeze_axes_input_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 1, 5, 1])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 5])
@@ -6056,7 +6081,7 @@ def squeeze_axes_input_test():
     return ([node], [x], [y], [axes_tensor])
 
 
-@onnx_test
+@onnx_test()
 def squeeze_empty_axes_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [3, 1, 5, 1])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [3, 5])
@@ -6073,7 +6098,7 @@ def squeeze_empty_axes_test():
     return ([node], [x], [y], [axes_tensor])
 
 
-@onnx_test
+@onnx_test()
 def squeeze_unsqueeze_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                       [1, 3, 1, 1, 2, 1])
@@ -6093,7 +6118,7 @@ def squeeze_unsqueeze_test():
     return ([node, node2], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def squeeze_unsqueeze_dyn_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                       [1, None, 1, 1, None, 1])
@@ -6113,7 +6138,7 @@ def squeeze_unsqueeze_dyn_test():
     return ([node, node2], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def sub_bcast_test():
     arg0 = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     arg1 = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 4])
@@ -6131,7 +6156,7 @@ def sub_bcast_test():
     return ([node], [arg0, arg1], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def sub_scalar_test():
     values = np.array([1])
     arg_node = helper.make_tensor_value_info('0', TensorProto.FLOAT,
@@ -6160,7 +6185,7 @@ def sub_scalar_test():
     return ([arg_const, node], [arg_node], [arg_out])
 
 
-@onnx_test
+@onnx_test()
 def sum_int_test():
     a = helper.make_tensor_value_info('0', TensorProto.INT16, [3])
     b = helper.make_tensor_value_info('1', TensorProto.UINT16, [3])
@@ -6180,7 +6205,7 @@ def sum_int_test():
     return ([cnode1, cnode2, node], [a, b, c], [y])
 
 
-@onnx_test
+@onnx_test()
 def sum_test():
     a = helper.make_tensor_value_info('0', TensorProto.FLOAT, [3])
     b = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3])
@@ -6196,7 +6221,7 @@ def sum_test():
     return ([node], [a, b, c], [y])
 
 
-@onnx_test
+@onnx_test()
 def sum_type_test():
     valb = np.array([1, 0])
     t_bool = helper.make_tensor(name="bool",
@@ -6290,7 +6315,7 @@ def sum_type_test():
              ])
 
 
-@onnx_test
+@onnx_test()
 def tan_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [10])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [10])
@@ -6304,7 +6329,7 @@ def tan_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def tanh_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [1])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [1])
@@ -6318,7 +6343,7 @@ def tanh_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def thresholdedrelu_default_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 3])
@@ -6330,7 +6355,7 @@ def thresholdedrelu_default_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def thresholdedrelu_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.FLOAT, [2, 2, 3])
@@ -6344,7 +6369,7 @@ def thresholdedrelu_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def thresholdedrelu_int_test():
     x = helper.make_tensor_value_info('x', TensorProto.INT32, [2, 2, 3])
     y = helper.make_tensor_value_info('y', TensorProto.INT32, [2, 2, 3])
@@ -6358,7 +6383,7 @@ def thresholdedrelu_int_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def tile_test():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2])
     y = helper.make_tensor_value_info('y', TensorProto.INT64, [2])
@@ -6370,7 +6395,7 @@ def tile_test():
             [helper.make_tensor('y', TensorProto.INT64, [2], [1, 2])])
 
 
-@onnx_test
+@onnx_test()
 def tile_test_3x2():
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2])
     y = helper.make_tensor_value_info('y', TensorProto.INT64, [2])
@@ -6382,7 +6407,7 @@ def tile_test_3x2():
             [helper.make_tensor('y', TensorProto.INT64, [2], [3, 2])])
 
 
-@onnx_test
+@onnx_test()
 def topk_attrk_test():
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [2, 5, 3, 2])
     val = helper.make_tensor_value_info('val', TensorProto.FLOAT, [2, 2, 3, 2])
@@ -6396,7 +6421,7 @@ def topk_attrk_test():
     return ([node], [x], [val, ind])
 
 
-@onnx_test
+@onnx_test()
 def topk_neg_axis_test():
     k = np.array([3])
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [3, 4, 5, 6])
@@ -6417,7 +6442,7 @@ def topk_neg_axis_test():
     return ([node], [x], [val, ind], [k_tensor])
 
 
-@onnx_test
+@onnx_test()
 def topk_test():
     k = np.array([4])
     x = helper.make_tensor_value_info('data', TensorProto.FLOAT, [2, 5, 3, 2])
@@ -6451,7 +6476,7 @@ def transpose_default_perm_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def transpose_invalid_perm_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 2, 4, 3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 2, 2])
@@ -6466,7 +6491,7 @@ def transpose_invalid_perm_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def transpose_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [1, 2, 2, 3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [1, 3, 2, 2])
@@ -6481,7 +6506,7 @@ def transpose_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def transpose_dyn_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [None, 2, 2, 3])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [None, 3, 2, 2])
@@ -6526,7 +6551,7 @@ def transpose_gather_test():
     return ([td, ti, node], [x, i], [y])
 
 
-@onnx_test
+@onnx_test()
 def undefined_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [2, 3, 4, 5])
@@ -6536,7 +6561,7 @@ def undefined_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def unknown_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 4])
@@ -6552,7 +6577,7 @@ def unknown_test():
     return ([node, node2], [x, y], [a])
 
 
-@onnx_test
+@onnx_test()
 def unknown_aten_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [2, 3, 4, 5])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [3, 4])
@@ -6569,7 +6594,7 @@ def unknown_aten_test():
     return ([node], [x, y], [a])
 
 
-@onnx_test
+@onnx_test()
 def upsample_linear_test():
     scales = np.array([1.0, 1.0, 2.0, 2.0], dtype=np.float32)
     scales_tensor = helper.make_tensor(name='scales',
@@ -6588,7 +6613,7 @@ def upsample_linear_test():
     return ([node], [X], [Y], [scales_tensor])
 
 
-@onnx_test
+@onnx_test()
 def upsample_test():
     scales = np.array([1.0, 1.0, 2.0, 3.0], dtype=np.float32)
     scale_tensor = helper.make_tensor(name='scales',
@@ -6609,7 +6634,7 @@ def upsample_test():
     return ([node], [X], [Y], [scale_tensor])
 
 
-@onnx_test
+@onnx_test()
 def variable_batch_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT,
                                       [None, 3, 16, 16])
@@ -6621,7 +6646,7 @@ def variable_batch_test():
     return ([node], [x], [y])
 
 
-@onnx_test
+@onnx_test()
 def variable_batch_leq_zero_test():
     x = helper.make_tensor_value_info('0', TensorProto.FLOAT, [0, 3, 16, 16])
     y = helper.make_tensor_value_info('1', TensorProto.FLOAT, [-1, 3, 16, 16])
@@ -6632,7 +6657,7 @@ def variable_batch_leq_zero_test():
     return ([node], [x, y], [z])
 
 
-@onnx_test
+@onnx_test()
 def where_test():
     c = helper.make_tensor_value_info('c', TensorProto.BOOL, [2])
     x = helper.make_tensor_value_info('x', TensorProto.FLOAT, [2, 2, 2])

test/onnx/onnx_test.cpp

@@ -1818,6 +1818,16 @@ migraphx::program create_external_data_prog()
     return p;
 }
 
+TEST_CASE(external_constant_test)
+{
+    migraphx::program p;
+    auto* mm = p.get_main_module();
+    mm->add_literal(migraphx::literal{{migraphx::shape::int64_type, {3}}, {0, 1, 2}});
+
+    auto prog = optimize_onnx("external_constant_test.onnx");
+    EXPECT(p == prog);
+}
+
 TEST_CASE(external_data_test)
 {
     migraphx::program p = create_external_data_prog();

test/shape_test.cpp

@@ -160,6 +160,20 @@ TEST_CASE(test_shape_dynamic_compares)
     EXPECT(ss0.str() != ss3.str());
 }
 
+TEST_CASE(dynamic_dimension_size_t_compares)
+{
+    using migraphx::shape;
+    auto a = shape::dynamic_dimension{2, 2, 2};
+    EXPECT(a == 2);
+    EXPECT(a != 3);
+    EXPECT(static_cast<std::size_t>(2) == a);
+    EXPECT(static_cast<std::size_t>(3) != a);
+
+    auto b = shape::dynamic_dimension{2, 4, 0};
+    EXPECT(b != 2);
+    EXPECT(static_cast<std::size_t>(2) != b);
+}
+
 TEST_CASE(test_shape_dynamic_errors)
 {
     using migraphx::shape;