onnx 1.17.0__cp311-cp311-win_amd64.whl → 1.19.0__cp311-cp311-win_amd64.whl

onnx/test/cpp/function_verify_test.cc

@@ -10,11 +10,10 @@
 #include "gtest/gtest.h"
 #include "onnx/checker.h"
 #include "onnx/common/constants.h"
+#include "onnx/defs/function.h"
 #include "onnx/defs/parser.h"
 #include "onnx/defs/printer.h"
 #include "onnx/defs/schema.h"
-#include "onnx/onnx-operators_pb.h"
-#include "onnx/onnx_pb.h"
 #include "onnx/shape_inference/implementation.h"
 
 namespace ONNX_NAMESPACE {
@@ -22,7 +21,7 @@ namespace Test {
 using namespace checker;
 using TENSOR_TYPES_MAP = std::unordered_map<std::string, std::vector<std::string>>;
 
-void GetFunctionProtoOpsetImport(
+static void GetFunctionProtoOpsetImport(
     const OpSchema& op,
     const FunctionProto* function_proto,
     std::unordered_map<std::string, int>& op_set) {
@@ -35,13 +34,13 @@ void GetFunctionProtoOpsetImport(
   }
 }
 
-void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* function_proto, int& counter) {
+static void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* function_proto, int& counter) {
   // This is a simple partial type-checker for a function-body.
   // TODO: Revisit to make the type-checker more complete.
   TENSOR_TYPES_MAP tc_map;
   std::set<std::string> primitive_types(OpSchema::all_tensor_types().begin(), OpSchema::all_tensor_types().end());
   for (const auto& input : function_op.inputs()) {
-    std::string name = input.GetName();
+    const std::string& name = input.GetName();
     auto& tvec = tc_map[name];
     for (const auto& t : input.GetTypes()) {
       tvec.emplace_back(*t);
@@ -49,7 +48,7 @@ void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* func
   }
 
   for (const auto& output : function_op.outputs()) {
-    std::string name = output.GetName();
+    const std::string& name = output.GetName();
     auto& tvec = tc_map[name];
     for (const auto& t : output.GetTypes()) {
       tvec.emplace_back(*t);
@@ -60,7 +59,7 @@ void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* func
   GetFunctionProtoOpsetImport(function_op, function_proto, op_set);
 
   for (auto& node : function_proto->node()) {
-    std::string op_type = node.op_type();
+    const std::string& op_type = node.op_type();
     std::unordered_map<std::string, int>::const_iterator it = op_set.find(node.domain());
     if (it == op_set.end()) {
       fail_check(
@@ -77,7 +76,7 @@ void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* func
     auto num_actual_inputs = static_cast<size_t>(node.input_size());
 
     for (size_t i = 0; i < num_actual_inputs; ++i) {
-      auto actual_param_name = node.input(static_cast<int>(i));
+      const auto& actual_param_name = node.input(static_cast<int>(i));
       auto iter = tc_map.find(actual_param_name);
       if (iter != tc_map.end()) {
         // if i >= num_formal_inputs, it is a variadic parameter corresponding
@@ -91,8 +90,13 @@ void VerifyTypeConstraint(const OpSchema& function_op, const FunctionProto* func
         for (auto& actual_type : iter->second) {
           if (allowed_types.find(actual_type) == allowed_types.end()) {
             fail_check(
-                "Input type " + actual_type + " of parameter " + actual_param_name + " of function " +
-                function_op.Name() + " is not allowed by operator " + op_type);
+                "Input type ",
+                actual_type,
+                " of parameter ",
+                actual_param_name + " of function ",
+                function_op.Name(),
+                " is not allowed by operator ",
+                op_type);
           }
         }
       }
@@ -120,16 +124,16 @@ using AttributeValues = std::vector<AttributeProto>;
 struct FunctionOpAttributeMap {
   std::unordered_map<std::string, std::vector<AttributeValues>> map;
 
-  std::string key(std::string domain, std::string opname, int opset_version) const {
+  std::string key(const std::string& domain, const std::string& opname, int opset_version) const {
     return domain + ":" + opname + ":" + std::to_string(opset_version);
   }
 
   void addTestCase(const std::string& opname, int opset_version, std::initializer_list<const char*> attributes) {
     auto& schema_test_cases = map[key("", opname, opset_version)];
-    schema_test_cases.push_back(AttributeValues());
+    schema_test_cases.emplace_back();
     auto& test_case = schema_test_cases.back();
     for (auto attr_text : attributes) {
-      test_case.push_back(AttributeProto());
+      test_case.emplace_back();
       OnnxParser::Parse(test_case.back(), attr_text);
     }
   }
@@ -170,9 +174,9 @@ struct FunctionOpAttributeMap {
     auto it = map.find(key_value);
     if (it != map.end())
       return it->second;
-    if (schema.attributes().size() == 0) {
+    if (schema.attributes().empty()) {
       // Test with no-attributes
-      map[key_value].push_back(std::vector<AttributeProto>());
+      map[key_value].emplace_back();
     }
     return map[key_value];
   }
@@ -189,16 +193,16 @@ struct FunctionTypeChecker {
   const std::vector<AttributeValues>* attribute_cases;
 
   FunctionTypeChecker(const OpSchema& op_schema, const FunctionProto& proto)
-      : schema(op_schema), function_proto(proto) {
-    attribute_cases = &FunctionOpAttributeMap::instance().getTestCases(op_schema);
-  }
+      : schema(op_schema),
+        function_proto(proto),
+        attribute_cases(&FunctionOpAttributeMap::instance().getTestCases(op_schema)) {}
 
   // Binds each type-variable in schema to a type-value
   std::unordered_map<std::string, DataType> typeVarBindings;
 
   std::vector<std::string> errors;
 
-  void recordError(const std::string& error, AttributeValues attrs) {
+  void recordError(const std::string& error, const AttributeValues& attrs) {
     std::ostringstream ostr;
     ostr << "Type checking failed for instantiation " << schema.Name() << ":" << schema.SinceVersion() << " {";
     for (auto& pair : typeVarBindings) {
@@ -211,7 +215,7 @@ struct FunctionTypeChecker {
     errors.push_back(ostr.str());
   }
 
-  void recordSuccess(AttributeValues attrs) {
+  void recordSuccess(const AttributeValues& attrs) {
     std::cout << "Type checking succeeded for instantiation " << schema.Name() << ":" << schema.SinceVersion() << " {";
     for (auto& pair : typeVarBindings) {
       std::cout << pair.first << " = " << *pair.second << ", ";
@@ -225,7 +229,7 @@ struct FunctionTypeChecker {
   // forTypeVar: This is used to iterate through all possible bindings of type-values
   // to all type-variables used in the op schema, and invoke the type-checker for
   // each possible instantiation.
-  void forTypeVar(int i) {
+  void forTypeVar(size_t i) {
     auto& typeConstraintVector = schema.typeConstraintParams();
     if (i < typeConstraintVector.size()) {
       std::string typeVar = typeConstraintVector[i].type_param_str;
@@ -258,7 +262,7 @@ struct FunctionTypeChecker {
 
     for (auto& attribute_vals : *attribute_cases) {
       ONNX_TRY {
-        auto output_types = shape_inference::InferFunctionOutputTypes(function_proto, input_types, attribute_vals);
+        shape_inference::InferFunctionOutputTypes(function_proto, input_types, attribute_vals);
       }
       ONNX_CATCH(ONNX_NAMESPACE::InferenceError & e) {
         ONNX_HANDLE_EXCEPTION(([&]() { recordError(e.what(), attribute_vals); }));
@@ -267,7 +271,7 @@ struct FunctionTypeChecker {
   }
 
   std::string checkAll() {
-    if (attribute_cases->size() > 0)
+    if (!attribute_cases->empty())
       forTypeVar(0);
     std::string all_errors = "";
     for (const std::string& error : errors)
@@ -276,7 +280,7 @@ struct FunctionTypeChecker {
   }
 };
 
-void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int& counter) {
+static void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int& counter) {
   // Verify function proto is valid
   if (!function_proto) {
     fail_check("Cannot get function body for op '", op.Name(), "'");
@@ -305,7 +309,7 @@ void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int
 
   FunctionTypeChecker type_checker(op, *function_proto);
   auto type_errors = type_checker.checkAll();
-  auto success = (type_errors == "");
+  auto success = (type_errors.empty());
   ASSERT_TRUE(success) << type_errors;
 }
 
@@ -314,7 +318,7 @@ void VerifyFunction(const OpSchema& op, const FunctionProto* function_proto, int
 TEST(FunctionVerification, VerifyFunctionOps) {
   const std::vector<OpSchema> schemas = OpSchemaRegistry::get_all_schemas();
   int function_counter = 0, verified_counter = 0;
-  for (const auto s : schemas) {
+  for (const auto& s : schemas) {
     if (!s.HasFunction())
       continue;
     // Skip test for functions with known errors that need to be fixed:
@@ -330,11 +334,11 @@ TEST(FunctionVerification, VerifyFunctionOps) {
         VerifyFunction(s, function_body, verified_counter);
       }
     }
-    ONNX_CATCH(ONNX_NAMESPACE::checker::ValidationError e) {
+    ONNX_CATCH(const ONNX_NAMESPACE::checker::ValidationError& e) {
       ONNX_HANDLE_EXCEPTION([&]() { FAIL() << e.what(); });
     }
   }
-  std::cerr << "[          ] Verified " << verified_counter << "/" << function_counter << " Functions." << std::endl;
+  std::cerr << "[          ] Verified " << verified_counter << "/" << function_counter << " Functions." << '\n';
 }
 
 // Verify that FunctionExpandHelper obtains missing default attributes
@@ -352,7 +356,7 @@ TEST(FunctionVerification, VerifyFunctionExpandHelper) {
 
   for (const auto& node : graph.node()) {
     if (node.op_type() == "ReduceMean") {
-      auto attr = node.attribute(0);
+      const auto& attr = node.attribute(0);
       EXPECT_EQ(attr.name(), "axes");
       EXPECT_EQ(attr.ints().size(), default_axes_attribute.ints().size());
 
@@ -366,7 +370,7 @@ TEST(FunctionVerification, VerifyFunctionExpandHelper) {
          << "the default attribute `axes` has not been assigned to ReduceMean op.";
 }
 
-void RegisterFunctionSchema() {
+static void RegisterFunctionSchema() {
   ONNX_NAMESPACE::OpSchema function_schema;
   function_schema.SetName("DynamicQuantizeLinear_Fake")
       .SetDomain(AI_ONNX_ML_DOMAIN)

onnx/test/cpp/inliner_test.cc

@@ -9,6 +9,7 @@
 #include "gtest/gtest.h"
 #include "onnx/checker.h"
 #include "onnx/common/constants.h"
+#include "onnx/defs/function.h"
 #include "onnx/defs/parser.h"
 #include "onnx/defs/printer.h"
 #include "onnx/defs/schema.h"
@@ -18,7 +19,11 @@
 namespace ONNX_NAMESPACE {
 namespace Test {
 
-static void InlineFunctions(ModelProto& model, const char* input, const inliner::FunctionIdSet* to_inline = nullptr) {
+static void InlineFunctions(
+    ModelProto& model,
+    const char* input,
+    const inliner::FunctionIdSet* to_inline = nullptr,
+    const ISchemaRegistry* schema_registry = nullptr) {
   OnnxParser parser(input);
   auto status = parser.Parse(model);
   EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
@@ -28,7 +33,9 @@ static void InlineFunctions(ModelProto& model, const char* input, const inliner:
   shape_inference::InferShapes(model);
 
   // std::cout << "Before inlining:\n" << ProtoToString(model) << "\n";
-  if (to_inline != nullptr)
+  if (schema_registry != nullptr)
+    inliner::InlineSelectedFunctions(model, *to_inline, schema_registry);
+  else if (to_inline != nullptr)
     inliner::InlineSelectedFunctions(model, *to_inline);
   else
     inliner::InlineLocalFunctions(model, true);
@@ -191,7 +198,7 @@ foo (x) => (y)
 
   ModelProto model;
   InlineFunctions(model, code);
-  // Check that valueinfo is propagated fron function to main graph.
+  // Check that valueinfo is propagated from function to main graph.
   auto& graph = model.graph();
   auto& temp_new_name = graph.node(0).output(0);
   auto& valueinfos = graph.value_info();
@@ -372,5 +379,127 @@ bar (x) => (y) {
   ASSERT_EQ(node2.attribute_size(), 0);
 }
 
+TEST(SchemaFunctionInliner, BasicTest) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: ["" : 18]>
+agraph (float[N, 128] X) => (float[N, 128] Y)
+{
+  Y = Softmax (X)
+}
+)ONNX";
+
+  ModelProto model;
+  inliner::FunctionIdVector to_inline = {{"", "Softmax"}};
+  auto to_inline_set = inliner::FunctionIdSet::Create(std::move(to_inline));
+  InlineFunctions(model, code, to_inline_set.get(), OpSchemaRegistry::Instance());
+  auto num_nodes = model.graph().node_size();
+  ASSERT_GT(num_nodes, 1);
+}
+
+static bool ContainsOp(const ModelProto& model, const char* op_type) {
+  for (const auto& node : model.graph().node()) {
+    if (node.op_type() == op_type) {
+      return true;
+    }
+  }
+  return false;
+}
+
+TEST(SchemaFunctionInliner, NestedTest) {
+  const char* code = R"ONNX(
+<ir_version: 8, opset_import: ["" : 18]>
+agraph (float[N, C] X, int32[N] expected) => (float Y)
+{
+  Y, log_prob = SoftmaxCrossEntropyLoss (X, expected)
+}
+)ONNX";
+
+  ModelProto model;
+  inliner::FunctionIdVector to_inline = {{"", "SoftmaxCrossEntropyLoss"}};
+  auto to_inline_set = inliner::FunctionIdSet::Create(std::move(to_inline));
+  InlineFunctions(model, code, to_inline_set.get(), OpSchemaRegistry::Instance());
+  auto num_nodes = model.graph().node_size();
+  ASSERT_GT(num_nodes, 1);
+  // Nested call to LogSoftmax should not be inlined.
+  ASSERT_TRUE(ContainsOp(model, "LogSoftmax"));
+
+  inliner::FunctionIdVector to_inline2 = {{"", "SoftmaxCrossEntropyLoss"}, {"", "LogSoftmax"}};
+  to_inline_set = inliner::FunctionIdSet::Create(std::move(to_inline2));
+  InlineFunctions(model, code, to_inline_set.get(), OpSchemaRegistry::Instance());
+  num_nodes = model.graph().node_size();
+  ASSERT_GT(num_nodes, 1);
+  // Nested call to LogSoftmax should be inlined.
+  ASSERT_FALSE(ContainsOp(model, "LogSoftmax"));
+}
+
+TEST(FunctionBuilder, AddInlinedCallBasic) {
+  // Test the AddInlinedCall functionality
+  GraphProto graph;
+
+  // Create a simple graph using parser for better readability
+  const char* graph_text = R"ONNX(
+test_graph (float x) => (float y)
+<float const_val = {2.0}>
+{
+    y = Add(x, const_val)
+}
+)ONNX";
+
+  auto status = OnnxParser::Parse(graph, graph_text);
+  EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
+
+  // Create a function and use AddInlinedCall
+  FunctionProto function;
+  FunctionBuilder builder(function);
+
+  builder.AddInlinedCall({"result"}, graph, {"input_x"}, "test");
+
+  // Verify the function has the expected structure
+  ASSERT_EQ(function.node_size(), 2); // One Constant node + one Add node
+
+  // Check the first node is a Constant
+  ASSERT_EQ(function.node(0).op_type(), "Constant");
+  ASSERT_EQ(function.node(0).output_size(), 1);
+  ASSERT_TRUE(function.node(0).output(0).find("test") != std::string::npos);
+
+  // Check the second node is an Add
+  ASSERT_EQ(function.node(1).op_type(), "Add");
+  ASSERT_EQ(function.node(1).input_size(), 2);
+  ASSERT_EQ(function.node(1).output_size(), 1);
+  ASSERT_EQ(function.node(1).input(0), "input_x"); // Should be renamed to actual input
+  ASSERT_EQ(function.node(1).output(0), "result"); // Should be renamed to actual output
+}
+
+TEST(Renamer, BasicFunctionality) {
+  // Test the Renamer class functionality
+  GraphProto graph;
+
+  // Add input to graph
+  auto* input = graph.add_input();
+  input->set_name("input");
+
+  // Create a Renamer instance
+  inliner::Renamer renamer("test", graph);
+
+  // Test binding names
+  renamer.BindName("formal_input", "actual_input");
+
+  // Test creating unique names and binding
+  std::string unique_name = renamer.BindToUniqueName("temp");
+  ASSERT_TRUE(unique_name.find("test") != std::string::npos);
+
+  // Test renaming a node
+  NodeProto node;
+  node.set_op_type("Add");
+  node.add_input("formal_input");
+  node.add_output("temp_output");
+
+  renamer.RenameNode(node);
+
+  // Verify renaming worked correctly
+  ASSERT_EQ(node.input(0), "actual_input"); // Should be bound to actual name
+  ASSERT_TRUE(node.output(0).find("test") != std::string::npos); // Should have prefix
+}
+
 } // namespace Test
 } // namespace ONNX_NAMESPACE

onnx/test/cpp/parser_test.cc

@@ -228,6 +228,44 @@ TEST(ParserTest, DomainOpCallTest) {
   Parse(n, code);
 }
 
+TEST(ParserTest, OptionalInputTest) {
+  const char* code = "x = SomeOp(y, , z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 3);
+  EXPECT_EQ(n.input(0), "y");
+  EXPECT_EQ(n.input(1), "");
+  EXPECT_EQ(n.input(2), "z");
+}
+
+TEST(ParserTest, LeadingOptionalInputTest) {
+  const char* code = "x = SomeOp( , z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 2);
+  EXPECT_EQ(n.input(0), "");
+  EXPECT_EQ(n.input(1), "z");
+}
+
+TEST(ParserTest, LeadingOptionalInputTest2) {
+  const char* code = "x = SomeOp(\"\" , z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 2);
+  EXPECT_EQ(n.input(0), "");
+  EXPECT_EQ(n.input(1), "z");
+}
+
+TEST(ParserTest, OptionalInputTest2) {
+  const char* code = "x = SomeOp(y, \"\", z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.input_size(), 3);
+  EXPECT_EQ(n.input(0), "y");
+  EXPECT_EQ(n.input(1), "");
+  EXPECT_EQ(n.input(2), "z");
+}
+
 TEST(ParserTest, NodeTest) {
   const char* code = "x = foo(y, z)";
   NodeProto n;
@@ -256,6 +294,23 @@ TEST(ParserTest, NodeTest) {
        )ONNX");
 }
 
+TEST(ParserTest, NodeLabelTest) {
+  const char* code = "[node1] x = foo(y, z)";
+  NodeProto n;
+  Parse(n, code);
+  EXPECT_EQ(n.name(), "node1");
+
+  NodeList nl;
+  Parse(nl, R"ONNX( {
+     [node1] x = foo(y, z)
+     [node2] w = bar(x, y)
+     s = foobar(x, w)
+  } )ONNX");
+  EXPECT_EQ(nl.Get(0).name(), "node1");
+  EXPECT_EQ(nl.Get(1).name(), "node2");
+  EXPECT_FALSE(nl.Get(2).has_name());
+}
+
 TEST(ParserTest, QualifiedOpNameTest) {
   const char* code = "x = com.example.foo(y, z)";
   NodeProto n;
@@ -663,5 +718,47 @@ agraph (float y = {1.0}, float[N] z) => (w) <
   EXPECT_EQ(graph.initializer().Get(1).external_data().Get(1).value(), "17");
 }
 
+TEST(ParserTest, QuotedIdentifiersTest) {
+  const char* code = R"ONNX(
+"a graph name" (float[N, 128] "input/X", float[128,10] "input W", float[10] B) => (float[N] C)
+{
+    "some/temp" = MatMul("input/X", "input W")
+    S = Add("some/temp", B)
+    C = Softmax(S)
+}
+)ONNX";
+
+  GraphProto graph;
+  Parse(graph, code);
+
+  EXPECT_EQ(graph.name(), "a graph name");
+  EXPECT_EQ(graph.input_size(), 3);
+  EXPECT_EQ(graph.output_size(), 1);
+  EXPECT_EQ(graph.node_size(), 3);
+  EXPECT_EQ(graph.node(0).input(0), "input/X");
+  EXPECT_EQ(graph.node(0).input(1), "input W");
+  EXPECT_EQ(graph.node(0).output(0), "some/temp");
+}
+
+TEST(ParserTest, QuotedIdentifierTest2) {
+  const char* code = R"ONNX(
+<
+  opset_import: [ "" : 10 ],
+  domain: "ai.onnx.ml",
+  doc_string: "A function test case."
+>
+"a function name" (float[N] "#y", "$z") => (float[N] "!w")
+<float[N] "/layer/x", float[N] t>
+{
+    "/layer/x" = Add("#y", "$z")
+    t = Add("/layer/x", "/layer/x")
+    "!w" = Mul(t, "#y")
+}
+)ONNX";
+
+  FunctionProto fp;
+  Parse(fp, code);
+}
+
 } // namespace Test
 } // namespace ONNX_NAMESPACE

onnx/test/cpp/schema_registration_test.cc

@@ -127,7 +127,7 @@ TEST(SchemaRegistrationTest, RegisterSpecifiedOpsetSchemaVersion) {
 #endif
 }
 
-// Regsiter opset-11, then opset-14
+// Register opset-11, then opset-14
 // Expects Reg(11, 14) == Reg(11) U Reg(14)
 TEST(SchemaRegistrationTest, RegisterMultipleOpsetSchemaVersions_UpgradeVersion) {
 #ifdef __ONNX_DISABLE_STATIC_REGISTRATION
@@ -170,7 +170,7 @@ TEST(SchemaRegistrationTest, RegisterMultipleOpsetSchemaVersions_UpgradeVersion)
 #endif
 }
 
-// Regsiter opset-14, then opset-11
+// Register opset-14, then opset-11
 // Expects Reg(14, 11) == Reg(11) U Reg(14)
 TEST(SchemaRegistrationTest, RegisterMultipleOpsetSchemaVersions_DowngradeVersion) {
 #ifdef __ONNX_DISABLE_STATIC_REGISTRATION

onnx/test/cpp/shape_inference_test.cc

@@ -10,21 +10,22 @@
 #include "onnx/defs/parser.h"
 #include "onnx/defs/schema.h"
 #include "onnx/defs/shape_inference.h"
-#include "onnx/onnx_pb.h"
 #include "onnx/shape_inference/implementation.h"
 
 using namespace ONNX_NAMESPACE::shape_inference;
 
 namespace ONNX_NAMESPACE {
 // onnx/defs/controlflow/old.cc
+// NOLINTNEXTLINE(misc-use-internal-linkage)
 void ScanInferenceFunctionOpset8(InferenceContext& ctx);
 // onnx/defs/controlflow/defs.cc
+// NOLINTNEXTLINE(misc-use-internal-linkage)
 void ScanInferenceFunction(InferenceContext& ctx);
 
 namespace Test {
 
 template <class Type>
-void CreateDims(Type& proto, int num_dims) {
+static void CreateDims(Type& proto, int num_dims) {
   auto mutable_shape = proto.mutable_shape();
   mutable_shape->clear_dim();
 
@@ -33,9 +34,9 @@ void CreateDims(Type& proto, int num_dims) {
 }
 
 template <class Type>
-void SetDimValues(Type& proto, const std::vector<int>& values) {
+static void SetDimValues(Type& proto, const std::vector<int>& values) {
   auto* mutable_shape = proto.mutable_shape();
-  EXPECT_TRUE(mutable_shape->dim_size() == values.size());
+  EXPECT_TRUE(static_cast<size_t>(mutable_shape->dim_size()) == values.size());
 
   int idx = 0;
   for (auto value : values) {
@@ -46,9 +47,9 @@ void SetDimValues(Type& proto, const std::vector<int>& values) {
 }
 
 template <class Type>
-void SetDimParams(Type& proto, const std::vector<const std::string*>& values) {
+static void SetDimParams(Type& proto, const std::vector<const std::string*>& values) {
   auto mutable_shape = proto.mutable_shape();
-  EXPECT_TRUE(mutable_shape->dim_size() == values.size());
+  EXPECT_TRUE(static_cast<size_t>(mutable_shape->dim_size()) == values.size());
 
   int idx = 0;
   for (auto value : values) {
@@ -59,12 +60,12 @@ void SetDimParams(Type& proto, const std::vector<const std::string*>& values) {
 }
 
 template <class Type>
-void Dump(const Type& t) {
+static void Dump(const Type& t) {
   auto& s_shape = t.shape();
   auto num_dims = s_shape.dim_size();
   std::cout << num_dims << " dims. ";
   for (int i = 0; i < num_dims; ++i) {
-    auto x = s_shape.dim(0);
+    const auto& x = s_shape.dim(0);
     auto y = x.has_dim_value();
     auto z = x.has_dim_param();
 
@@ -343,7 +344,7 @@ TEST(ShapeInferenceTest, mergeShapeInfo_Mismatches) {
 
 // Check subgraph inferencing via GraphInferencer using a Scan
 static void doInferencingTest(bool use_scan_opset8) {
-  auto* schemaRegistry = OpSchemaRegistry::Instance();
+  OpSchemaRegistry::Instance();
   GraphProto subgraph;
 
   // simple tensor without shape info
@@ -507,7 +508,7 @@ TEST(GraphInferencerImplTest, Scan9_BasicTest) {
   doInferencingTest(false);
 }
 
-void ParseAndInfer(ModelProto& model, const char* modelStr) {
+static void ParseAndInfer(ModelProto& model, const char* modelStr) {
   OnnxParser parser(modelStr);
   auto status = parser.Parse(model);
   EXPECT_TRUE(status.IsOK()) << status.ErrorMessage();
@@ -517,7 +518,7 @@ void ParseAndInfer(ModelProto& model, const char* modelStr) {
   ONNX_NAMESPACE::shape_inference::InferShapes(model, ONNX_NAMESPACE::OpSchemaRegistry::Instance(), options);
 }
 
-void RunReshapeShapeInfTest(const char* modelStr, TensorShapeProto& expectedShape) {
+static void RunReshapeShapeInfTest(const char* modelStr, TensorShapeProto& expectedShape) {
   ModelProto model;
   ParseAndInfer(model, modelStr);
 

onnx/test/cpp/test_main.cc

@@ -8,8 +8,8 @@
 
 #include "gtest/gtest.h"
 
-GTEST_API_ int main(int argc, char** argv) {
-  std::cout << "Running main() from test_main.cc" << std::endl;
+int main(int argc, char** argv) {
+  std::cout << "Running main() from test_main.cc" << '\n';
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

onnx/test/cpp/utf8_conversion_test.cc

@@ -0,0 +1,27 @@
+// Copyright (c) ONNX Project Contributors
+
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifdef _WIN32
+#include <string>
+
+#include "gtest/gtest.h"
+#include "onnx/common/path.h"
+namespace ONNX_NAMESPACE::Test {
+
+TEST(UTF8Test, WideStringConvertion) {
+  std::string utf8_str(u8"世界，你好！");
+  EXPECT_EQ(ONNX_NAMESPACE::wstring_to_utf8str(ONNX_NAMESPACE::utf8str_to_wstring(utf8_str)), utf8_str);
+}
+
+TEST(UTF8Test, TryConvertUTF8) {
+  std::string utf8_str(u8"世界，你好！");
+  auto wstr = ONNX_NAMESPACE::utf8str_to_wstring(utf8_str);
+  auto wstr2 = ONNX_NAMESPACE::utf8str_to_wstring(
+      std::string(reinterpret_cast<const char*>(wstr.c_str()), sizeof(std::wstring::value_type) * wstr.size()), true);
+  EXPECT_EQ(wstr, wstr2);
+}
+} // namespace ONNX_NAMESPACE::Test
+#endif