mirror of https://github.com/opencv/opencv.git
Open Source Computer Vision Library
https://opencv.org/
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
514 lines
15 KiB
514 lines
15 KiB
#include "../test_precomp.hpp" |
|
|
|
#include "backends/common/serialization.hpp" |
|
|
|
namespace { |
|
struct MyCustomType { |
|
int val; |
|
std::string name; |
|
std::vector<float> vec; |
|
std::map<int, uint64_t> mmap; |
|
bool operator==(const MyCustomType& other) const { |
|
return val == other.val && name == other.name && |
|
vec == other.vec && mmap == other.mmap; |
|
} |
|
}; |
|
} |
|
|
|
namespace cv { |
|
namespace gapi { |
|
namespace s11n { |
|
namespace detail { |
|
template<> struct S11N<MyCustomType> { |
|
static void serialize(IOStream &os, const MyCustomType &p) { |
|
os << p.val << p.name << p.vec << p.mmap; |
|
} |
|
static MyCustomType deserialize(IIStream &is) { |
|
MyCustomType p; |
|
is >> p.val >> p.name >> p.vec >> p.mmap; |
|
return p; |
|
} |
|
}; |
|
} // namespace detail |
|
} // namespace s11n |
|
} // namespace gapi |
|
} // namespace cv |
|
|
|
namespace opencv_test { |
|
|
|
struct S11N_Basic: public ::testing::Test { |
|
template<typename T> void put(T &&t) { |
|
cv::gapi::s11n::ByteMemoryOutStream os; |
|
os << t; |
|
m_buffer = os.data(); |
|
} |
|
|
|
template<typename T> T get() { |
|
// FIXME: This stream API needs a fix-up |
|
cv::gapi::s11n::ByteMemoryInStream is(m_buffer); |
|
T t{}; |
|
is >> t; |
|
return t; |
|
} |
|
|
|
private: |
|
std::vector<char> m_buffer; |
|
}; |
|
|
|
namespace |
|
{ |
|
template<typename T> |
|
bool operator==(const cv::detail::VectorRef& a, const cv::detail::VectorRef& b) |
|
{ |
|
return a.rref<T>() == b.rref<T>(); |
|
} |
|
|
|
template<typename T> |
|
bool operator==(const cv::detail::OpaqueRef& a, const cv::detail::OpaqueRef& b) |
|
{ |
|
return a.rref<T>() == b.rref<T>(); |
|
} |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_int_pos) { |
|
int x = 42; |
|
put(x); |
|
EXPECT_EQ(x, get<int>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_int_neg) { |
|
int x = -42; |
|
put(x); |
|
EXPECT_EQ(x, get<int>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_fp32) { |
|
float x = 3.14f; |
|
put(x); |
|
EXPECT_EQ(x, get<float>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_fp64) { |
|
double x = 3.14; |
|
put(x); |
|
EXPECT_EQ(x, get<double>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_uint64) { |
|
uint64_t x = 2147483647374; |
|
put(x); |
|
EXPECT_EQ(x, get<uint64_t>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_int32_pos) { |
|
int32_t x = 2147483647; |
|
put(x); |
|
EXPECT_EQ(x, get<int32_t>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_int32_neg) { |
|
int32_t x = -2147483646; |
|
put(x); |
|
EXPECT_EQ(x, get<int32_t>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_vector_bool) { |
|
std::vector<bool> v = {false, true, false}; |
|
put(v); |
|
EXPECT_EQ(v, get<std::vector<bool>>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_map_string2string) { |
|
using T = std::map<std::string, std::string>; |
|
T v; |
|
v["gapi"] = "cool"; |
|
v["42"] = "answer"; |
|
v["hi"] = "hello there"; |
|
put(v); |
|
EXPECT_EQ(v, get<T>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_map_int2int) { |
|
using T = std::map<int, int32_t>; |
|
T v; |
|
v[1] = 23; |
|
v[-100] = 0; |
|
v[435346] = -12346; |
|
put(v); |
|
EXPECT_EQ(v, get<T>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_map_float2cvsize) { |
|
using T = std::map<float, cv::Size>; |
|
T v; |
|
v[0.4f] = cv::Size(4, 5); |
|
v[234.43f] = cv::Size(3421, 321); |
|
v[2223.f] = cv::Size(1920, 1080); |
|
put(v); |
|
EXPECT_EQ(v, get<T>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_map_uint642cvmat) { |
|
using T = std::map<uint64_t, cv::Mat>; |
|
T v; |
|
v[21304805324] = cv::Mat(3, 3, CV_8UC1, cv::Scalar::all(3)); |
|
v[4353245222] = cv::Mat(5, 5, CV_8UC3, cv::Scalar::all(7)); |
|
v[0] = cv::Mat(10, 10, CV_32FC2, cv::Scalar::all(-128.f)); |
|
put(v); |
|
auto out_v = get<T>(); |
|
for (const auto& el : out_v) { |
|
EXPECT_NE(v.end(), v.find(el.first)); |
|
EXPECT_EQ(0, cv::norm(el.second, v[el.first])); |
|
} |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_vector_int) { |
|
std::vector<int> v = {1,2,3}; |
|
put(v); |
|
EXPECT_EQ(v, get<std::vector<int>>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_vector_cvSize) { |
|
std::vector<cv::Size> v = { |
|
cv::Size(640, 480), |
|
cv::Size(1280, 1024), |
|
}; |
|
put(v); |
|
EXPECT_EQ(v, get<std::vector<cv::Size>>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_vector_string) { |
|
std::vector<std::string> v = { |
|
"hello", |
|
"world", |
|
"ok!" |
|
}; |
|
put(v); |
|
EXPECT_EQ(v, get<std::vector<std::string>>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_vector_empty) { |
|
std::vector<char> v; |
|
put(v); |
|
EXPECT_EQ(v, get<std::vector<char>>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_variant) { |
|
using S = std::string; |
|
using V = cv::util::variant<int,S>; |
|
V v1{42}, v2{S{"hey"}}; |
|
|
|
put(v1); |
|
EXPECT_EQ(v1, get<V>()); |
|
|
|
put(v2); |
|
EXPECT_EQ(v2, get<V>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_GArg_int) { |
|
const int x = 42; |
|
cv::GArg gs(x); |
|
put(gs); |
|
|
|
cv::GArg gd = get<cv::GArg>(); |
|
EXPECT_EQ(cv::detail::ArgKind::OPAQUE_VAL, gd.kind); |
|
EXPECT_EQ(cv::detail::OpaqueKind::CV_INT, gd.opaque_kind); |
|
EXPECT_EQ(x, gs.get<int>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_GArg_Point) { |
|
const cv::Point pt{1,2}; |
|
cv::GArg gs(pt); |
|
put(gs); |
|
|
|
cv::GArg gd = get<cv::GArg>(); |
|
EXPECT_EQ(cv::detail::ArgKind::OPAQUE_VAL, gd.kind); |
|
EXPECT_EQ(cv::detail::OpaqueKind::CV_POINT, gd.opaque_kind); |
|
EXPECT_EQ(pt, gs.get<cv::Point>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_Mat_full) { |
|
auto mat = cv::Mat::eye(cv::Size(64,64), CV_8UC3); |
|
put(mat); |
|
EXPECT_EQ(0, cv::norm(mat, get<cv::Mat>(), cv::NORM_INF)); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_Mat_view) { |
|
auto mat = cv::Mat::eye(cv::Size(320,240), CV_8UC3); |
|
auto view = mat(cv::Rect(10,15,123,70)); |
|
put(view); |
|
EXPECT_EQ(0, cv::norm(view, get<cv::Mat>(), cv::NORM_INF)); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_MatDesc) { |
|
cv::GMatDesc v = { CV_8U, 1, {320,240} }; |
|
put(v); |
|
EXPECT_EQ(v, get<cv::GMatDesc>()); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_MetaArg_MatDesc) { |
|
cv::GMatDesc desc = { CV_8U, 1,{ 320,240 } }; |
|
auto v = cv::GMetaArg{ desc }; |
|
put(v); |
|
cv::GMetaArg out_v = get<cv::GMetaArg>(); |
|
cv::GMatDesc out_desc = cv::util::get<cv::GMatDesc>(out_v); |
|
EXPECT_EQ(desc, out_desc); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_MetaArgs_MatDesc) { |
|
cv::GMatDesc desc1 = { CV_8U, 1,{ 320,240 } }; |
|
cv::GMatDesc desc2 = { CV_8U, 1,{ 640,480 } }; |
|
GMetaArgs v; |
|
v.resize(2); |
|
v[0] = cv::GMetaArg{ desc1 }; |
|
v[1] = cv::GMetaArg{ desc2 }; |
|
put(v); |
|
cv::GMetaArgs out_v = get<cv::GMetaArgs>(); |
|
cv::GMatDesc out_desc1 = cv::util::get<cv::GMatDesc>(out_v[0]); |
|
cv::GMatDesc out_desc2 = cv::util::get<cv::GMatDesc>(out_v[1]); |
|
EXPECT_EQ(desc1, out_desc1); |
|
EXPECT_EQ(desc2, out_desc2); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_MetaArg_Monostate) { |
|
GMetaArg v; |
|
put(v); |
|
cv::GMetaArg out_v = get<cv::GMetaArg>(); |
|
if (!util::holds_alternative<util::monostate>(out_v)) |
|
{ |
|
GTEST_FAIL(); |
|
} |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_RunArg_Mat) { |
|
cv::Mat mat = cv::Mat::eye(cv::Size(64, 64), CV_8UC3); |
|
auto v = cv::GRunArg{ mat }; |
|
put(v); |
|
cv::GRunArg out_v = get<cv::GRunArg>(); |
|
cv::Mat out_mat = cv::util::get<cv::Mat>(out_v); |
|
EXPECT_EQ(0, cv::norm(mat, out_mat, cv::NORM_INF)); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_RunArgs_Mat) { |
|
cv::Mat mat1 = cv::Mat::eye(cv::Size(64, 64), CV_8UC3); |
|
cv::Mat mat2 = cv::Mat::eye(cv::Size(128, 128), CV_8UC3); |
|
GRunArgs v; |
|
v.resize(2); |
|
v[0] = cv::GRunArg{ mat1 }; |
|
v[1] = cv::GRunArg{ mat2 }; |
|
put(v); |
|
cv::GRunArgs out_v = get<cv::GRunArgs>(); |
|
cv::Mat out_mat1 = cv::util::get<cv::Mat>(out_v[0]); |
|
cv::Mat out_mat2 = cv::util::get<cv::Mat>(out_v[1]); |
|
EXPECT_EQ(0, cv::norm(mat1, out_mat1, cv::NORM_INF)); |
|
EXPECT_EQ(0, cv::norm(mat2, out_mat2, cv::NORM_INF)); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_RunArg_Scalar) { |
|
cv::Scalar scalar = cv::Scalar(128, 33, 53); |
|
auto v = cv::GRunArg{ scalar }; |
|
put(v); |
|
cv::GRunArg out_v = get<cv::GRunArg>(); |
|
cv::Scalar out_scalar = cv::util::get<cv::Scalar>(out_v); |
|
EXPECT_EQ(scalar, out_scalar); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_RunArgs_Scalar) { |
|
cv::Scalar scalar1 = cv::Scalar(128, 33, 53); |
|
cv::Scalar scalar2 = cv::Scalar(64, 15, 23); |
|
GRunArgs v; |
|
v.resize(2); |
|
v[0] = cv::GRunArg{ scalar1 }; |
|
v[1] = cv::GRunArg{ scalar2 }; |
|
put(v); |
|
cv::GRunArgs out_v = get<cv::GRunArgs>(); |
|
cv::Scalar out_scalar1 = cv::util::get<cv::Scalar>(out_v[0]); |
|
cv::Scalar out_scalar2 = cv::util::get<cv::Scalar>(out_v[1]); |
|
EXPECT_EQ(scalar1, out_scalar1); |
|
EXPECT_EQ(scalar2, out_scalar2); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_RunArg_Opaque) { |
|
auto op = cv::detail::OpaqueRef(42); |
|
auto v = cv::GRunArg{ op }; |
|
put(v); |
|
cv::GRunArg out_v = get<cv::GRunArg>(); |
|
cv::detail::OpaqueRef out_op = cv::util::get<cv::detail::OpaqueRef>(out_v); |
|
EXPECT_TRUE(operator==<int>(op, out_op)); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_RunArgs_Opaque) { |
|
cv::detail::OpaqueRef op1 = cv::detail::OpaqueRef(cv::Point(1, 2)); |
|
cv::detail::OpaqueRef op2 = cv::detail::OpaqueRef(cv::Size(12, 21)); |
|
GRunArgs v; |
|
v.resize(2); |
|
v[0] = cv::GRunArg{ op1 }; |
|
v[1] = cv::GRunArg{ op2 }; |
|
put(v); |
|
cv::GRunArgs out_v = get<cv::GRunArgs>(); |
|
cv::detail::OpaqueRef out_op1 = cv::util::get<cv::detail::OpaqueRef>(out_v[0]); |
|
cv::detail::OpaqueRef out_op2 = cv::util::get<cv::detail::OpaqueRef>(out_v[1]); |
|
EXPECT_TRUE(operator==<cv::Point>(op1, out_op1)); |
|
EXPECT_TRUE(operator==<cv::Size>(op2, out_op2)); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_RunArg_Array) { |
|
auto op = cv::detail::VectorRef(std::vector<cv::Mat>{cv::Mat::eye(3, 3, CV_8UC1), cv::Mat::zeros(5, 5, CV_8UC3)}); |
|
|
|
auto v = cv::GRunArg{ op }; |
|
put(v); |
|
cv::GRunArg out_v = get<cv::GRunArg>(); |
|
cv::detail::VectorRef out_op = cv::util::get<cv::detail::VectorRef>(out_v); |
|
auto vec1 = op.rref<cv::Mat>(); |
|
auto vec2 = out_op.rref<cv::Mat>(); |
|
EXPECT_EQ(0, cv::norm(vec1[0], vec2[0], cv::NORM_INF)); |
|
EXPECT_EQ(0, cv::norm(vec1[1], vec2[1], cv::NORM_INF)); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_RunArgs_Array) { |
|
auto vec_sc = std::vector<cv::Scalar>{cv::Scalar(11), cv::Scalar(31)}; |
|
auto vec_d = std::vector<double>{0.4, 1.0, 123.55, 22.08}; |
|
cv::detail::VectorRef op1 = cv::detail::VectorRef(vec_sc); |
|
cv::detail::VectorRef op2 = cv::detail::VectorRef(vec_d); |
|
GRunArgs v; |
|
v.resize(2); |
|
v[0] = cv::GRunArg{ op1 }; |
|
v[1] = cv::GRunArg{ op2 }; |
|
put(v); |
|
cv::GRunArgs out_v = get<cv::GRunArgs>(); |
|
cv::detail::VectorRef out_op1 = cv::util::get<cv::detail::VectorRef>(out_v[0]); |
|
cv::detail::VectorRef out_op2 = cv::util::get<cv::detail::VectorRef>(out_v[1]); |
|
EXPECT_TRUE(operator==<cv::Scalar>(op1, out_op1)); |
|
EXPECT_TRUE(operator==<double>(op2, out_op2)); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_RunArgs_MatScalar) { |
|
cv::Mat mat = cv::Mat::eye(cv::Size(64, 64), CV_8UC3); |
|
cv::Scalar scalar = cv::Scalar(128, 33, 53); |
|
GRunArgs v; |
|
v.resize(2); |
|
v[0] = cv::GRunArg{ mat }; |
|
v[1] = cv::GRunArg{ scalar }; |
|
put(v); |
|
cv::GRunArgs out_v = get<cv::GRunArgs>(); |
|
unsigned int i = 0; |
|
for (auto it : out_v) |
|
{ |
|
using T = cv::GRunArg; |
|
switch (it.index()) |
|
{ |
|
case T::index_of<cv::Mat>() : |
|
{ |
|
cv::Mat out_mat = cv::util::get<cv::Mat>(out_v[i]); |
|
EXPECT_EQ(0, cv::norm(mat, out_mat, cv::NORM_INF)); |
|
} break; |
|
case T::index_of<cv::Scalar>() : |
|
{ |
|
cv::Scalar out_scalar = cv::util::get<cv::Scalar>(out_v[i]); |
|
EXPECT_EQ(scalar, out_scalar); |
|
} break; |
|
default: |
|
GAPI_Assert(false && "This value type is not supported!"); // ...maybe because of STANDALONE mode. |
|
break; |
|
} |
|
i++; |
|
} |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_Bind_RunArgs_MatScalar) { |
|
cv::Mat mat = cv::Mat::eye(cv::Size(128, 64), CV_8UC3); |
|
cv::Scalar scalar = cv::Scalar(128, 33, 53); |
|
GRunArgs v; |
|
v.resize(2); |
|
v[0] = cv::GRunArg{ mat }; |
|
v[1] = cv::GRunArg{ scalar }; |
|
GRunArgsP output = cv::gapi::bind(v); |
|
unsigned int i = 0; |
|
for (auto it : output) |
|
{ |
|
using T = cv::GRunArgP; |
|
switch (it.index()) |
|
{ |
|
case T::index_of<cv::Mat*>() : |
|
{ |
|
cv::Mat* out_mat = cv::util::get<cv::Mat*>(it); |
|
EXPECT_EQ(mat.size(), out_mat->size()); |
|
} break; |
|
case T::index_of<cv::Scalar*>() : |
|
{ |
|
cv::Scalar* out_scalar = cv::util::get<cv::Scalar*>(it); |
|
EXPECT_EQ(out_scalar->val[0], scalar.val[0]); |
|
EXPECT_EQ(out_scalar->val[1], scalar.val[1]); |
|
EXPECT_EQ(out_scalar->val[2], scalar.val[2]); |
|
} break; |
|
default: |
|
GAPI_Assert(false && "This value type is not supported!"); // ...maybe because of STANDALONE mode. |
|
break; |
|
} |
|
i++; |
|
} |
|
} |
|
|
|
namespace { |
|
template <cv::detail::OpaqueKind K, typename T> |
|
bool verifyOpaqueKind(T&& in) { |
|
auto inObjs = cv::gin(in); |
|
auto in_o_ref = cv::util::get<cv::detail::OpaqueRef>(inObjs[0]); |
|
return K == in_o_ref.getKind(); |
|
} |
|
|
|
template <cv::detail::OpaqueKind K, typename T> |
|
bool verifyArrayKind(T&& in) { |
|
auto inObjs = cv::gin(in); |
|
auto in_o_ref = cv::util::get<cv::detail::VectorRef>(inObjs[0]); |
|
return K == in_o_ref.getKind(); |
|
} |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_Gin_GOpaque) { |
|
int i; float f; double d; |
|
std::uint64_t ui; bool b; |
|
std::string s; |
|
cv::Rect r; cv::Size sz; |
|
cv::Point p; |
|
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_INT>(i)); |
|
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_FLOAT>(f)); |
|
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_DOUBLE>(d)); |
|
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_UINT64>(ui)); |
|
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_BOOL>(b)); |
|
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_STRING>(s)); |
|
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_RECT>(r)); |
|
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_SIZE>(sz)); |
|
EXPECT_TRUE(verifyOpaqueKind<cv::detail::OpaqueKind::CV_POINT>(p)); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_Gin_GArray) { |
|
std::vector<int> i; std::vector<float> f; std::vector<double> d; |
|
std::vector<std::uint64_t> ui; std::vector<bool> b; |
|
std::vector<std::string> s; |
|
std::vector<cv::Rect> r; std::vector<cv::Size> sz; |
|
std::vector<cv::Point> p; |
|
std::vector<cv::Mat> mat; |
|
std::vector<cv::Scalar> sc; |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_INT>(i)); |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_FLOAT>(f)); |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_DOUBLE>(d)); |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_UINT64>(ui)); |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_BOOL>(b)); |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_STRING>(s)); |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_RECT>(r)); |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_SIZE>(sz)); |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_POINT>(p)); |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_MAT>(mat)); |
|
EXPECT_TRUE(verifyArrayKind<cv::detail::OpaqueKind::CV_SCALAR>(sc)); |
|
} |
|
|
|
TEST_F(S11N_Basic, Test_Custom_Type) { |
|
MyCustomType var{1324, "Hello", {1920, 1080, 720}, {{1, 2937459432}, {42, 253245432}}}; |
|
cv::gapi::s11n::ByteMemoryOutStream os; |
|
cv::gapi::s11n::detail::S11N<MyCustomType>::serialize(os, var); |
|
cv::gapi::s11n::ByteMemoryInStream is(os.data()); |
|
MyCustomType new_var = cv::gapi::s11n::detail::S11N<MyCustomType>::deserialize(is); |
|
EXPECT_EQ(var, new_var); |
|
} |
|
} // namespace opencv_test
|
|
|