Add more tests

test/eval_test.cpp

@@ -65,6 +65,23 @@ struct reverse_pass
 {
     std::string name() const { return "reverse_pass"; }
 
+    void apply(migraphx::program& p) const
+    {
+        std::reverse(p.begin(), p.end());
+    }
+};
+
+struct reverse_target
+{
+    std::string name() const { return "reverse"; }
+    std::vector<migraphx::pass> get_passes(migraphx::context&) const { return {reverse_pass{}}; }
+    migraphx::context get_context() const { return {}; }
+};
+
+struct invert_pass
+{
+    std::string name() const { return "invert_pass"; }
+
     void apply(migraphx::program& p) const
     {
         for(auto ins : migraphx::iterator_for(p))
@@ -81,19 +98,19 @@ struct reverse_pass
     }
 };
 
-struct reverse_target
+struct invert_target
 {
-    std::string name() const { return "reverse"; }
-    std::vector<migraphx::pass> get_passes(migraphx::context&) const { return {reverse_pass{}}; }
+    std::string name() const { return "invert"; }
+    std::vector<migraphx::pass> get_passes(migraphx::context&) const { return {invert_pass{}}; }
     migraphx::context get_context() const { return {}; }
 };
 
-struct double_reverse_target
+struct double_invert_target
 {
-    std::string name() const { return "double_reverse"; }
+    std::string name() const { return "double_invert"; }
     std::vector<migraphx::pass> get_passes(migraphx::context&) const
     {
-        return {reverse_pass{}, reverse_pass{}};
+        return {invert_pass{}, invert_pass{}};
     }
     migraphx::context get_context() const { return {}; }
 };
@@ -167,20 +184,38 @@ TEST_CASE(param_error_test)
         "Parameter not found: y"));
 }
 
-TEST_CASE(param_shape_error_test)
+TEST_CASE(get_param1)
 {
     migraphx::program p;
+    migraphx::shape s{migraphx::shape::int32_type, {1, 2}};
+    auto x = p.add_parameter("x", s);
+    auto y = p.add_parameter("y", s);
+    p.add_instruction(sum_op{}, x, y);
+    EXPECT(bool{p.get_parameter("x") == x});
+    EXPECT(bool{p.get_parameter("y") == y});
+    EXPECT(bool{p.get_parameter("nonexistent") == p.end()});
+}
 
-    auto x = p.add_parameter("x", {migraphx::shape::int32_type, {1, 2}});
-    auto y = p.add_parameter("y", {migraphx::shape::int32_type, {1, 2}});
+TEST_CASE(get_param2)
+{
+    migraphx::program p;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    p.add_instruction(sum_op{}, one, two);
+    EXPECT(bool{p.get_parameter("nonexistent") == p.end()});
+}
 
+TEST_CASE(get_param_shapes)
+{
+    migraphx::program p;
+    migraphx::shape s{migraphx::shape::int32_type, {1, 2}};
+    auto x = p.add_parameter("x", s);
+    auto y = p.add_parameter("y", s);
     p.add_instruction(sum_op{}, x, y);
-    EXPECT(test::throws<migraphx::exception>(
-        [&] {
-            p.eval({{"x", migraphx::literal{1}.get_argument()},
-                    {"y", migraphx::literal{2}.get_argument()}});
-        },
-        "Incorrect shape"));
+    auto m = p.get_parameter_shapes();
+    EXPECT(m.count("nonexistent") == 0);
+    EXPECT(m.at("x") == s);
+    EXPECT(m.at("y") == s);
 }
 
 TEST_CASE(replace_test)
@@ -249,6 +284,40 @@ TEST_CASE(insert_replace_test)
     EXPECT(result != migraphx::literal{5});
 }
 
+TEST_CASE(remove_test1)
+{
+    migraphx::program p;
+
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto sum = p.add_instruction(sum_op{}, one, two);
+    auto removed = p.add_instruction(minus_op{}, sum, one);
+    p.remove_instruction(removed);
+    EXPECT(bool{p.validate() == p.end()});
+
+
+    auto result = p.eval({});
+    EXPECT(result == migraphx::literal{3});
+    EXPECT(result != migraphx::literal{1});
+}
+
+TEST_CASE(remove_test2)
+{
+    migraphx::program p;
+
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    auto removed = p.add_instruction(minus_op{}, two, one);
+    p.add_instruction(sum_op{}, one, two);
+    p.remove_instruction(removed);
+    EXPECT(bool{p.validate() == p.end()});
+
+
+    auto result = p.eval({});
+    EXPECT(result == migraphx::literal{3});
+    EXPECT(result != migraphx::literal{1});
+}
+
 TEST_CASE(target_test)
 {
     migraphx::program p;
@@ -262,27 +331,27 @@ TEST_CASE(target_test)
     EXPECT(result != migraphx::literal{4});
 }
 
-TEST_CASE(reverse_target_test)
+TEST_CASE(invert_target_test)
 {
     migraphx::program p;
 
     auto one = p.add_literal(1);
     auto two = p.add_literal(2);
     p.add_instruction(sum_op{}, two, one);
-    p.compile(reverse_target{});
+    p.compile(invert_target{});
     auto result = p.eval({});
     EXPECT(result == migraphx::literal{1});
     EXPECT(result != migraphx::literal{4});
 }
 
-TEST_CASE(double_reverse_target_test)
+TEST_CASE(double_invert_target_test)
 {
     migraphx::program p;
 
     auto one = p.add_literal(1);
     auto two = p.add_literal(2);
     p.add_instruction(sum_op{}, two, one);
-    p.compile(double_reverse_target{});
+    p.compile(double_invert_target{});
     auto result = p.eval({});
     EXPECT(result == migraphx::literal{3});
     EXPECT(result != migraphx::literal{4});

test/generate.cpp

+#include <migraphx/generate.hpp>
+#include "test.hpp"
+
+TEST_CASE(generate)
+{
+    migraphx::shape s{migraphx::shape::float_type, {4, 4, 1, 1}};
+    EXPECT(migraphx::generate_literal(s, 1) == migraphx::generate_argument(s, 1));
+    EXPECT(migraphx::generate_literal(s, 1) != migraphx::generate_argument(s, 0));
+}
+
+int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/perf_report.cpp

+#include <migraphx/program.hpp>
+#include <migraphx/op/add.hpp>
+#include <migraphx/cpu/target.hpp>
+#include <migraphx/ranges.hpp>
+#include "test.hpp"
+
+TEST_CASE(perf_report)
+{
+    migraphx::program p;
+
+    std::stringstream ss;
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    p.add_instruction(migraphx::op::add{}, one, two);
+    p.compile(migraphx::cpu::target{});
+    p.perf_report(ss, 2, {});
+
+    std::string output = ss.str();
+    EXPECT(migraphx::contains(output, "Summary:"));
+    EXPECT(migraphx::contains(output, "Rate:"));
+    EXPECT(migraphx::contains(output, "Total time:"));
+    EXPECT(migraphx::contains(output, "Total instructions time:"));
+    EXPECT(migraphx::contains(output, "Overhead time:"));
+    EXPECT(migraphx::contains(output, "Overhead:"));
+    EXPECT(not migraphx::contains(output, "fast"));
+}
+
+int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/program_test.cpp

@@ -31,6 +31,31 @@ TEST_CASE(program_equality)
     EXPECT(x == y);
 }
 
+TEST_CASE(program_not_equality1)
+{
+    migraphx::program x;
+    migraphx::program y = create_program();
+    EXPECT(x != y);
+    x = y;
+    EXPECT(x == y);
+}
+
+TEST_CASE(program_not_equality2)
+{
+    migraphx::program x;
+    migraphx::program y = create_program();
+    EXPECT(x != y);
+    y = x;
+    EXPECT(x == y);
+}
+
+TEST_CASE(program_default_copy_construct)
+{
+    migraphx::program x;
+    migraphx::program y;
+    EXPECT(x == y);
+}
+
 TEST_CASE(program_copy)
 {
     auto create_program_1 = [] {