inference-engine/thirdparty/fluid/modules/gapi/test/gapi_kernel_tests.cpp

   1 // This file is part of OpenCV project.
   2 // It is subject to the license terms in the LICENSE file found in the top-level directory
   3 // of this distribution and at http://opencv.org/license.html.
   4 //
   5 // Copyright (C) 2018-2019 Intel Corporation
   6
   7
   8 #include "test_precomp.hpp"
   9 #include "opencv2/gapi/cpu/gcpukernel.hpp"
  10 #include "gapi_mock_kernels.hpp"
  11
  12 namespace opencv_test
  13 {
  14
  15 namespace
  16 {
  17     G_TYPED_KERNEL(GClone, <GMat(GMat)>, "org.opencv.test.clone")
  18     {
  19         static GMatDesc outMeta(GMatDesc in) { return in;  }
  20
  21     };
  22
  23     GAPI_OCV_KERNEL(GCloneImpl, GClone)
  24     {
  25         static void run(const cv::Mat& in, cv::Mat &out)
  26         {
  27             out = in.clone();
  28         }
  29     };
  30 }
  31
  32 TEST(KernelPackage, Create)
  33 {
  34     namespace J = Jupiter;
  35     auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz>();
  36     EXPECT_EQ(3u, pkg.size());
  37 }
  38
  39 TEST(KernelPackage, Includes)
  40 {
  41     namespace J = Jupiter;
  42     auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz>();
  43     EXPECT_TRUE (pkg.includes<J::Foo>());
  44     EXPECT_TRUE (pkg.includes<J::Bar>());
  45     EXPECT_TRUE (pkg.includes<J::Baz>());
  46     EXPECT_FALSE(pkg.includes<J::Qux>());
  47 }
  48
  49 TEST(KernelPackage, IncludesAPI)
  50 {
  51     namespace J = Jupiter;
  52     namespace S = Saturn;
  53     auto pkg = cv::gapi::kernels<J::Foo, S::Bar>();
  54     EXPECT_TRUE (pkg.includesAPI<I::Foo>());
  55     EXPECT_TRUE (pkg.includesAPI<I::Bar>());
  56     EXPECT_FALSE(pkg.includesAPI<I::Baz>());
  57     EXPECT_FALSE(pkg.includesAPI<I::Qux>());
  58 }
  59
  60 TEST(KernelPackage, IncludesAPI_Overlapping)
  61 {
  62     namespace J = Jupiter;
  63     namespace S = Saturn;
  64     auto pkg = cv::gapi::kernels<J::Foo, J::Bar, S::Foo, S::Bar>();
  65     EXPECT_TRUE (pkg.includesAPI<I::Foo>());
  66     EXPECT_TRUE (pkg.includesAPI<I::Bar>());
  67     EXPECT_FALSE(pkg.includesAPI<I::Baz>());
  68     EXPECT_FALSE(pkg.includesAPI<I::Qux>());
  69 }
  70
  71 TEST(KernelPackage, Include_Add)
  72 {
  73     namespace J = Jupiter;
  74     auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz>();
  75     EXPECT_FALSE(pkg.includes<J::Qux>());
  76
  77     pkg.include<J::Qux>();
  78     EXPECT_TRUE(pkg.includes<J::Qux>());
  79 }
  80
  81 TEST(KernelPackage, Include_KEEP)
  82 {
  83     namespace J = Jupiter;
  84     namespace S = Saturn;
  85     auto pkg = cv::gapi::kernels<J::Foo, J::Bar>();
  86     EXPECT_FALSE(pkg.includes<S::Foo>());
  87     EXPECT_FALSE(pkg.includes<S::Bar>());
  88
  89     pkg.include<S::Bar>(); // default (KEEP)
  90     EXPECT_TRUE(pkg.includes<J::Bar>());
  91     EXPECT_TRUE(pkg.includes<S::Bar>());
  92
  93     pkg.include<S::Foo>(cv::unite_policy::KEEP); // explicit (KEEP)
  94     EXPECT_TRUE(pkg.includes<J::Foo>());
  95     EXPECT_TRUE(pkg.includes<S::Foo>());
  96 }
  97
  98 TEST(KernelPackage, Include_REPLACE)
  99 {
 100     namespace J = Jupiter;
 101     namespace S = Saturn;
 102     auto pkg = cv::gapi::kernels<J::Foo, J::Bar>();
 103     EXPECT_FALSE(pkg.includes<S::Bar>());
 104
 105     pkg.include<S::Bar>(cv::unite_policy::REPLACE);
 106     EXPECT_FALSE(pkg.includes<J::Bar>());
 107     EXPECT_TRUE(pkg.includes<S::Bar>());
 108 }
 109
 110 TEST(KernelPackage, RemoveBackend)
 111 {
 112     namespace J = Jupiter;
 113     namespace S = Saturn;
 114     auto pkg = cv::gapi::kernels<J::Foo, J::Bar, S::Foo>();
 115     EXPECT_TRUE(pkg.includes<J::Foo>());
 116     EXPECT_TRUE(pkg.includes<J::Bar>());
 117     EXPECT_TRUE(pkg.includes<S::Foo>());
 118
 119     pkg.remove(J::backend());
 120     EXPECT_FALSE(pkg.includes<J::Foo>());
 121     EXPECT_FALSE(pkg.includes<J::Bar>());
 122     EXPECT_TRUE(pkg.includes<S::Foo>());
 123 };
 124
 125 TEST(KernelPackage, RemoveAPI)
 126 {
 127     namespace J = Jupiter;
 128     namespace S = Saturn;
 129     auto pkg = cv::gapi::kernels<J::Foo, J::Bar, S::Foo, S::Bar>();
 130     EXPECT_TRUE(pkg.includes<J::Foo>());
 131     EXPECT_TRUE(pkg.includes<J::Bar>());
 132     EXPECT_TRUE(pkg.includes<S::Foo>());
 133
 134     pkg.remove<I::Foo>();
 135     EXPECT_TRUE(pkg.includes<J::Bar>());
 136     EXPECT_TRUE(pkg.includes<S::Bar>());
 137     EXPECT_FALSE(pkg.includes<J::Foo>());
 138     EXPECT_FALSE(pkg.includes<S::Foo>());
 139 };
 140
 141 TEST(KernelPackage, CreateHetero)
 142 {
 143     namespace J = Jupiter;
 144     namespace S = Saturn;
 145     auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz, S::Qux>();
 146     EXPECT_EQ(4u, pkg.size());
 147 }
 148
 149 TEST(KernelPackage, IncludesHetero)
 150 {
 151     namespace J = Jupiter;
 152     namespace S = Saturn;
 153     auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz, S::Qux>();
 154     EXPECT_TRUE (pkg.includes<J::Foo>());
 155     EXPECT_TRUE (pkg.includes<J::Bar>());
 156     EXPECT_TRUE (pkg.includes<J::Baz>());
 157     EXPECT_FALSE(pkg.includes<J::Qux>());
 158     EXPECT_TRUE (pkg.includes<S::Qux>());
 159 }
 160
 161 TEST(KernelPackage, IncludeHetero)
 162 {
 163     namespace J = Jupiter;
 164     namespace S = Saturn;
 165     auto pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz>();
 166     EXPECT_FALSE(pkg.includes<J::Qux>());
 167     EXPECT_FALSE(pkg.includes<S::Qux>());
 168
 169     pkg.include<S::Qux>();
 170     EXPECT_FALSE(pkg.includes<J::Qux>());
 171     EXPECT_TRUE (pkg.includes<S::Qux>());
 172 }
 173
 174 TEST(KernelPackage, Combine_REPLACE_Full)
 175 {
 176     namespace J = Jupiter;
 177     namespace S = Saturn;
 178     auto j_pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz>();
 179     auto s_pkg = cv::gapi::kernels<S::Foo, S::Bar, S::Baz>();
 180     auto u_pkg = cv::gapi::combine(j_pkg, s_pkg, cv::unite_policy::REPLACE);
 181
 182     EXPECT_EQ(3u, u_pkg.size());
 183     EXPECT_FALSE(u_pkg.includes<J::Foo>());
 184     EXPECT_FALSE(u_pkg.includes<J::Bar>());
 185     EXPECT_FALSE(u_pkg.includes<J::Baz>());
 186     EXPECT_TRUE (u_pkg.includes<S::Foo>());
 187     EXPECT_TRUE (u_pkg.includes<S::Bar>());
 188     EXPECT_TRUE (u_pkg.includes<S::Baz>());
 189 }
 190
 191 TEST(KernelPackage, Combine_REPLACE_Partial)
 192 {
 193     namespace J = Jupiter;
 194     namespace S = Saturn;
 195     auto j_pkg = cv::gapi::kernels<J::Foo, J::Bar>();
 196     auto s_pkg = cv::gapi::kernels<S::Bar>();
 197     auto u_pkg = cv::gapi::combine(j_pkg, s_pkg, cv::unite_policy::REPLACE);
 198
 199     EXPECT_EQ(2u, u_pkg.size());
 200     EXPECT_TRUE (u_pkg.includes<J::Foo>());
 201     EXPECT_FALSE(u_pkg.includes<J::Bar>());
 202     EXPECT_TRUE (u_pkg.includes<S::Bar>());
 203 }
 204
 205 TEST(KernelPackage, Combine_REPLACE_Append)
 206 {
 207     namespace J = Jupiter;
 208     namespace S = Saturn;
 209     auto j_pkg = cv::gapi::kernels<J::Foo, J::Bar>();
 210     auto s_pkg = cv::gapi::kernels<S::Qux>();
 211     auto u_pkg = cv::gapi::combine(j_pkg, s_pkg, cv::unite_policy::REPLACE);
 212
 213     EXPECT_EQ(3u, u_pkg.size());
 214     EXPECT_TRUE(u_pkg.includes<J::Foo>());
 215     EXPECT_TRUE(u_pkg.includes<J::Bar>());
 216     EXPECT_TRUE(u_pkg.includes<S::Qux>());
 217 }
 218
 219 TEST(KernelPackage, Combine_KEEP_AllDups)
 220 {
 221     namespace J = Jupiter;
 222     namespace S = Saturn;
 223     auto j_pkg = cv::gapi::kernels<J::Foo, J::Bar, J::Baz>();
 224     auto s_pkg = cv::gapi::kernels<S::Foo, S::Bar, S::Baz>();
 225     auto u_pkg = cv::gapi::combine(j_pkg ,s_pkg, cv::unite_policy::KEEP);
 226
 227     EXPECT_EQ(6u, u_pkg.size());
 228     EXPECT_TRUE(u_pkg.includes<J::Foo>());
 229     EXPECT_TRUE(u_pkg.includes<J::Bar>());
 230     EXPECT_TRUE(u_pkg.includes<J::Baz>());
 231     EXPECT_TRUE(u_pkg.includes<S::Foo>());
 232     EXPECT_TRUE(u_pkg.includes<S::Bar>());
 233     EXPECT_TRUE(u_pkg.includes<S::Baz>());
 234 }
 235
 236 TEST(KernelPackage, Combine_KEEP_Append_NoDups)
 237 {
 238     namespace J = Jupiter;
 239     namespace S = Saturn;
 240     auto j_pkg = cv::gapi::kernels<J::Foo, J::Bar>();
 241     auto s_pkg = cv::gapi::kernels<S::Qux>();
 242     auto u_pkg = cv::gapi::combine(j_pkg, s_pkg, cv::unite_policy::KEEP);
 243
 244     EXPECT_EQ(3u, u_pkg.size());
 245     EXPECT_TRUE(u_pkg.includes<J::Foo>());
 246     EXPECT_TRUE(u_pkg.includes<J::Bar>());
 247     EXPECT_TRUE(u_pkg.includes<S::Qux>());
 248 }
 249
 250 TEST(KernelPackage, TestWithEmptyLHS)
 251 {
 252     namespace J = Jupiter;
 253     auto lhs = cv::gapi::kernels<>();
 254     auto rhs = cv::gapi::kernels<J::Foo>();
 255     auto pkg = cv::gapi::combine(lhs, rhs, cv::unite_policy::KEEP);
 256
 257     EXPECT_EQ(1u, pkg.size());
 258     EXPECT_TRUE(pkg.includes<J::Foo>());
 259 }
 260
 261 TEST(KernelPackage, TestWithEmptyRHS)
 262 {
 263     namespace J = Jupiter;
 264     auto lhs = cv::gapi::kernels<J::Foo>();
 265     auto rhs = cv::gapi::kernels<>();
 266     auto pkg = cv::gapi::combine(lhs, rhs, cv::unite_policy::KEEP);
 267
 268     EXPECT_EQ(1u, pkg.size());
 269     EXPECT_TRUE(pkg.includes<J::Foo>());
 270 }
 271
 272 TEST(KernelPackage, Can_Use_Custom_Kernel)
 273 {
 274     cv::GMat in[2];
 275     auto out = GClone::on(cv::gapi::add(in[0], in[1]));
 276     const auto in_meta = cv::GMetaArg(cv::GMatDesc{CV_8U,1,cv::Size(32,32)});
 277
 278     auto pkg = cv::gapi::kernels<GCloneImpl>();
 279
 280     EXPECT_NO_THROW(cv::GComputation(cv::GIn(in[0], in[1]), cv::GOut(out)).
 281                         compile({in_meta, in_meta}, cv::compile_args(pkg)));
 282 }
 283
 284 } // namespace opencv_test