#else
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
#endif
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
#else
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
#endif
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
TEST_P(DivTest, DISABLED_DivByZeroTest) // https://github.com/opencv/opencv/pull/12826
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
//
// TODO: Make threshold a configurable parameter of this test (ADE-221)
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
cv::Mat &outx = out_mat_gapi,
&outy = out_mat2;
//
// TODO: Make threshold a configurable parameter of this test (ADE-221)
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
cv::Mat &outm = out_mat_gapi,
&outa = out_mat2;
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
}
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
}
}
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
}
}
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
}
}
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
}
}
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
}
}
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
}
}
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
}
}
}
// Comparison //////////////////////////////////////////////////////////////
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
TEST_P(NormTest, AccuracyTest)
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(0, cv::norm(out_mat_ocv, out_mat_gapi, NORM_L1));
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(ocv_res, out_gapi_scalar.val[0]);
}
}
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
- EXPECT_EQ(out_mat_gapi.size(), sz_out);
+ EXPECT_EQ(sz_out, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
- EXPECT_EQ(out_mat_gapi.size(), sz_out);
+ EXPECT_EQ(sz_out, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
EXPECT_EQ(0, cvtest::norm(out_mat_gapi, out_mat_ocv, NORM_INF));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
};
// run for uninitialized output
cv::GComputation c(cv::GIn(in), cv::GOut(out));
c.apply(cv::gin(in_mat1), cv::gout(out_sz), getCompileArgs());
- EXPECT_EQ(out_sz, sz);
+ EXPECT_EQ(sz, out_sz);
}
TEST_P(SizeRTest, ParseTest)
cv::GComputation c(cv::GIn(op_rect), cv::GOut(out));
c.apply(cv::gin(rect), cv::gout(out_sz), getCompileArgs());
- EXPECT_EQ(out_sz, sz);
+ EXPECT_EQ(sz, out_sz);
}
namespace {
cv::GComputation c(cv::GIn(in), cv::GOut(out));
c.apply(cv::gin(frame), cv::gout(out_sz), getCompileArgs());
- EXPECT_EQ(out_sz, sz);
+ EXPECT_EQ(sz, out_sz);
}
} // opencv_test
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
EXPECT_TRUE(cmpF(out_mat_gapi2, out_mat_ocv2));
- EXPECT_EQ(out_mat_gapi.size(), sz);
- EXPECT_EQ(out_mat_gapi2.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
+ EXPECT_EQ(sz, out_mat_gapi2.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), Size(sz.width, sz.height * 3 / 2));
+ EXPECT_EQ(Size(sz.width, sz.height * 3 / 2), out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), Size(sz.width, sz.height * 3 / 2));
+ EXPECT_EQ(Size(sz.width, sz.height * 3 / 2), out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), Size(sz.width, sz.height * 2 / 3));
+ EXPECT_EQ(Size(sz.width, sz.height * 2 / 3), out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), Size(sz.width, sz.height * 2 / 3));
+ EXPECT_EQ(Size(sz.width, sz.height * 2 / 3), out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi_planar, out_mat_ocv_planar));
- EXPECT_EQ(out_mat_gapi_planar.size(), sz_p);
+ EXPECT_EQ(sz_p, out_mat_gapi_planar.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi_planar, out_mat_ocv_planar));
- EXPECT_EQ(out_mat_gapi_planar.size(), sz_p);
+ EXPECT_EQ(sz_p, out_mat_gapi_planar.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
// Comparison //////////////////////////////////////////////////////////////
{
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
- EXPECT_EQ(out_mat_gapi.size(), sz);
+ EXPECT_EQ(sz, out_mat_gapi.size());
}
}
} // opencv_test
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
}
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_TRUE(cmpF(out_mat_gapi, out_mat_ocv));
}
}
}
// Comparison //////////////////////////////////////////////////////////////
{
- ASSERT_EQ(out_mat_gapi.size(), sz);
+ ASSERT_EQ(sz, out_mat_gapi.size());
EXPECT_EQ(0, cvtest::norm(out_mat_ocv, out_mat_gapi, NORM_INF));
}
}
c.apply(cv::gin(mat_in), cv::gout(mat_out), cv::compile_args(cv::gapi::kernels<OCVGeneratePoint, OCVPaintPoint>()));
int painted = mat_out.at<uint8_t>(42, 42);
- EXPECT_EQ(painted, 77);
+ EXPECT_EQ(77, painted);
}
TEST(GOpaque, TestOpaqueBetweenIslands)
c.apply(cv::gin(mat_in), cv::gout(mat_out), cv::compile_args(cv::gapi::kernels<OCVGeneratePoint, OCVPaintPoint>()));
int painted = mat_out.at<uint8_t>(42, 42);
- EXPECT_EQ(painted, 77);
+ EXPECT_EQ(77, painted);
}
TEST(GOpaque, TestOpaqueCustomOut2)
cv::GComputation c(cv::GIn(in1, in2), cv::GOut(std::get<0>(out), std::get<1>(out)));
c.apply(cv::gin(input1, input2), cv::gout(out1, out2), cv::compile_args(cv::gapi::kernels<OCVGenerateOpaque>()));
- EXPECT_EQ(out1.num, input1.size().width * input1.size().height);
- EXPECT_EQ(out1.s, str);
+ EXPECT_EQ(input1.size().width * input1.size().height, out1.num);
+ EXPECT_EQ(str, out1.s);
- EXPECT_EQ(out2.num, input2.size().width * input2.size().height);
- EXPECT_EQ(out2.s, str2);
+ EXPECT_EQ(input2.size().width * input2.size().height, out2.num);
+ EXPECT_EQ(str2, out2.s);
}
TEST(GOpaque, TestOpaqueOCLBackendIn)
cv::compile_args(cv::gapi::kernels<OCLPaintPoint>()));
int painted = mat_out.at<uint8_t>(42, 42);
- EXPECT_EQ(painted, 77);
+ EXPECT_EQ(77, painted);
}
TEST(GOpaque, TestOpaqueOCLBackendBetween)
cv::compile_args(cv::gapi::kernels<OCLGeneratePoint, OCLPaintPoint>()));
int painted = mat_out.at<uint8_t>(42, 42);
- EXPECT_EQ(painted, 77);
+ EXPECT_EQ(77, painted);
}
TEST(GOpaque, TestOpaqueOCLBackendOut)
}
// SSD-MobilenetV1 structure check
- ASSERT_EQ(detections[0].total(), 1u);
+ ASSERT_EQ(1u, detections[0].total());
ASSERT_EQ(detections[2].total(), detections[0].total() * 100);
ASSERT_EQ(detections[2].total(), detections[3].total());
ASSERT_EQ((detections[2].total() * 4), detections[1].total());
GMatDesc m_desc;
GMetaArgs meta_args = descr_of(cv::gin(m, s, v));
- EXPECT_EQ(meta_args.size(), 3u);
+ EXPECT_EQ(3u, meta_args.size());
EXPECT_NO_THROW(m_desc = util::get<cv::GMatDesc>(meta_args[0]));
EXPECT_NO_THROW(util::get<cv::GScalarDesc>(meta_args[1]));
EXPECT_NO_THROW(util::get<cv::GArrayDesc>(meta_args[2]));
{
int x;
q.pop(x);
- EXPECT_EQ(x, i);
+ EXPECT_EQ(i, x);
}
}
int x = 1;
v.pop(x);
- EXPECT_EQ(x, i);
+ EXPECT_EQ(i, x);
}
}
TEST(OwnMat, DefaultConstruction)
{
Mat m;
- ASSERT_EQ(m.data, nullptr);
- ASSERT_EQ(m.cols, 0);
- ASSERT_EQ(m.rows, 0);
- ASSERT_EQ(m.cols, 0);
- ASSERT_EQ(m.type(), 0);
- ASSERT_EQ(m.depth(), 0);
+ ASSERT_EQ(nullptr, m.data);
+ ASSERT_EQ(0, m.cols);
+ ASSERT_EQ(0, m.rows);
+ ASSERT_EQ(0, m.cols);
+ ASSERT_EQ(0, m.type());
+ ASSERT_EQ(0, m.depth());
ASSERT_TRUE(m.dims.empty());
ASSERT_TRUE(m.empty());
}
Mat m;
m.create(size, CV_8UC1);
- ASSERT_NE(m.data, nullptr);
- ASSERT_EQ((cv::gapi::own::Size{m.cols, m.rows}), size);
+ ASSERT_NE(nullptr, m.data);
+ ASSERT_EQ(size, (cv::gapi::own::Size{m.cols, m.rows}));
- ASSERT_EQ(m.total(), static_cast<size_t>(size.height) * size.width);
- ASSERT_EQ(m.type(), CV_8UC1);
- ASSERT_EQ(m.depth(), CV_8U);
- ASSERT_EQ(m.channels(), 1);
- ASSERT_EQ(m.elemSize(), sizeof(uint8_t));
- ASSERT_EQ(m.step, sizeof(uint8_t) * m.cols);
+ ASSERT_EQ(static_cast<size_t>(size.height) * size.width, m.total());
+ ASSERT_EQ(CV_8UC1, m.type());
+ ASSERT_EQ(CV_8U, m.depth());
+ ASSERT_EQ(1, m.channels());
+ ASSERT_EQ(sizeof(uint8_t), m.elemSize());
+ ASSERT_EQ(sizeof(uint8_t) * m.cols, m.step);
ASSERT_TRUE(m.dims.empty());
ASSERT_FALSE(m.empty());
}
Mat m;
m.create(dims, CV_32F);
- ASSERT_NE(nullptr , m.data );
+ ASSERT_NE(nullptr , m.data);
ASSERT_EQ((cv::gapi::own::Size{0,0}), (cv::gapi::own::Size{m.cols, m.rows}));
ASSERT_EQ(multiply_dims(dims), m.total());
- ASSERT_EQ(CV_32F , m.type() );
- ASSERT_EQ(CV_32F , m.depth() );
- ASSERT_EQ(-1 , m.channels());
- ASSERT_EQ(sizeof(float) , m.elemSize());
- ASSERT_EQ(0u , m.step );
- ASSERT_EQ(dims , m.dims );
+ ASSERT_EQ(CV_32F, m.type());
+ ASSERT_EQ(CV_32F, m.depth());
+ ASSERT_EQ(-1, m.channels());
+ ASSERT_EQ(sizeof(float), m.elemSize());
+ ASSERT_EQ(0u, m.step);
+ ASSERT_EQ(dims, m.dims);
ASSERT_FALSE(m.empty());
}
Mat m;
m.create(size.height,size.width, CV_8UC1);
- ASSERT_NE(m.data, nullptr);
- ASSERT_EQ((cv::Size{m.cols, m.rows}), size);
+ ASSERT_NE(nullptr, m.data);
+ ASSERT_EQ(size, (cv::Size{m.cols, m.rows}));
- ASSERT_EQ(m.total(), static_cast<size_t>(size.height) * size.width);
- ASSERT_EQ(m.type(), CV_8UC1);
- ASSERT_EQ(m.depth(), CV_8U);
- ASSERT_EQ(m.channels(), 1);
- ASSERT_EQ(m.elemSize(), sizeof(uint8_t));
- ASSERT_EQ(m.step, sizeof(uint8_t) * m.cols);
+ ASSERT_EQ(static_cast<size_t>(size.height) * size.width, m.total());
+ ASSERT_EQ(CV_8UC1, m.type());
+ ASSERT_EQ(CV_8U, m.depth());
+ ASSERT_EQ(1, m.channels());
+ ASSERT_EQ(sizeof(uint8_t), m.elemSize());
+ ASSERT_EQ(sizeof(uint8_t) * m.cols, m.step);
ASSERT_TRUE(m.dims.empty());
ASSERT_FALSE(m.empty());
}
Mat m;
m.create(size, CV_8UC3);
- ASSERT_NE(m.data, nullptr);
- ASSERT_EQ((cv::Size{m.cols, m.rows}), size);
+ ASSERT_NE(nullptr, m.data);
+ ASSERT_EQ(size, (cv::Size{m.cols, m.rows}));
- ASSERT_EQ(m.type(), CV_8UC3);
- ASSERT_EQ(m.depth(), CV_8U);
- ASSERT_EQ(m.channels(), 3);
- ASSERT_EQ(m.elemSize(), 3 * sizeof(uint8_t));
- ASSERT_EQ(m.step, 3* sizeof(uint8_t) * m.cols);
+ ASSERT_EQ(CV_8UC3, m.type());
+ ASSERT_EQ(CV_8U, m.depth());
+ ASSERT_EQ(3, m.channels());
+ ASSERT_EQ(3 * sizeof(uint8_t), m.elemSize());
+ ASSERT_EQ(3 * sizeof(uint8_t) * m.cols, m.step);
ASSERT_TRUE(m.dims.empty());
ASSERT_FALSE(m.empty());
}
};
void ensure_mats_are_same(Mat const& copy, Mat const& m){
- EXPECT_NE(copy.data, nullptr);
+ EXPECT_NE(nullptr, copy.data);
EXPECT_EQ(state_of(copy), state_of(m));
}
}
void ensure_state_moved_to(Mat const& moved_to)
{
- EXPECT_EQ(state_of(moved_to), initial_state);
- EXPECT_EQ(state_of(moved_from), state_of(Mat{}));
+ EXPECT_EQ(state_of(moved_to), initial_state);
+ EXPECT_EQ(state_of(moved_from), state_of(Mat{}));
}
};
for (int i = 0; i < 4; ++i)
{
- EXPECT_EQ(s[i], 0.0);
+ EXPECT_EQ(0.0, s[i]);
}
}
{
cv::gapi::own::Scalar s(5.0);
- EXPECT_EQ(s[0], 5.0);
- EXPECT_EQ(s[1], 0.0);
- EXPECT_EQ(s[2], 0.0);
- EXPECT_EQ(s[3], 0.0);
+ EXPECT_EQ(5.0, s[0]);
+ EXPECT_EQ(0.0, s[1]);
+ EXPECT_EQ(0.0, s[2]);
+ EXPECT_EQ(0.0, s[3]);
}
TEST(Scalar, CreateFromVals)
{
cv::gapi::own::Scalar s(5.3, 3.3, 4.1, -2.0);
- EXPECT_EQ(s[0], 5.3);
- EXPECT_EQ(s[1], 3.3);
- EXPECT_EQ(s[2], 4.1);
- EXPECT_EQ(s[3], -2.0);
+ EXPECT_EQ(5.3, s[0]);
+ EXPECT_EQ(3.3, s[1]);
+ EXPECT_EQ(4.1, s[2]);
+ EXPECT_EQ(-2.0, s[3]);
}
} // namespace opencv_test
}
GAPI_Assert(out_mat || out_int);
if (out_int) {
- EXPECT_EQ( 3, out_int.value());
+ EXPECT_EQ(3, out_int.value());
}
}
}
if (out_vec || out_int) {
EXPECT_EQ(320, out_vec.value()[0]);
EXPECT_EQ(240, out_vec.value()[1]);
- EXPECT_EQ( 3, out_int.value());
+ EXPECT_EQ(3, out_int.value());
}
}
}
// check self consistency
EXPECT_EQ(reinterpret_cast<void*>(surf->get_handle()),
reinterpret_cast<void*>(mfx_core_handle));
- EXPECT_EQ(surf->get_locks_count(), 0);
- EXPECT_EQ(surf->obtain_lock(), 0);
- EXPECT_EQ(surf->get_locks_count(), 1);
- EXPECT_EQ(surf->release_lock(), 1);
- EXPECT_EQ(surf->get_locks_count(), 0);
+ EXPECT_EQ(0, surf->get_locks_count());
+ EXPECT_EQ(0, surf->obtain_lock());
+ EXPECT_EQ(1, surf->get_locks_count());
+ EXPECT_EQ(1, surf->release_lock());
+ EXPECT_EQ(0, surf->get_locks_count());
}
TEST(OneVPL_Source_Surface, ConcurrentLock)
auto surf = Surface::create_surface(std::move(handle), associated_memory);
// check self consistency
- EXPECT_EQ(surf->get_locks_count(), 0);
+ EXPECT_EQ(0, surf->get_locks_count());
// MFX internal limitation: do not exceede U16 range
// so I16 is using here
}
worker_thread.join();
- EXPECT_EQ(surf->get_locks_count(), lock_counter * 2);
+ EXPECT_EQ(lock_counter * 2, surf->get_locks_count());
}
TEST(OneVPL_Source_Surface, MemoryLifeTime)
std::shared_ptr<void> associated_memory (preallocated_memory_ptr.get(),
[&preallocated_memory_ptr] (void* ptr) {
EXPECT_TRUE(preallocated_memory_ptr);
- EXPECT_EQ(preallocated_memory_ptr.get(), ptr);
+ EXPECT_EQ(ptr, preallocated_memory_ptr.get());
preallocated_memory_ptr.reset();
});
}
// workspace memory must be alive
- EXPECT_EQ(surfaces.size(), 0);
+ EXPECT_EQ(0, surfaces.size());
EXPECT_TRUE(associated_memory != nullptr);
EXPECT_TRUE(preallocated_memory_ptr.get() != nullptr);
associated_memory.reset();
// workspace memory must be still alive
- EXPECT_EQ(surfaces.size(), 0);
+ EXPECT_EQ(0, surfaces.size());
EXPECT_TRUE(associated_memory == nullptr);
EXPECT_TRUE(preallocated_memory_ptr.get() != nullptr);
auto surf = Surface::create_surface(std::move(handle), associated_memory);
// check consistency
- EXPECT_EQ(surf->get_locks_count(), 0);
+ EXPECT_EQ(0, surf->get_locks_count());
{
VPLMediaFrameCPUAdapter adapter(surf);
- EXPECT_EQ(surf->get_locks_count(), 1);
+ EXPECT_EQ(1, surf->get_locks_count());
}
- EXPECT_EQ(surf->get_locks_count(), 0);
+ EXPECT_EQ(0, surf->get_locks_count());
}
TEST(OneVPL_Source_CPU_Accelerator, InitDestroy)
surface_size_bytes,
create_test_surface);
// check consistency
- EXPECT_EQ(acceleration_policy->get_surface_count(key), surface_count);
- EXPECT_EQ(acceleration_policy->get_free_surface_count(key), surface_count);
+ EXPECT_EQ(surface_count, acceleration_policy->get_surface_count(key));
+ EXPECT_EQ(surface_count, acceleration_policy->get_free_surface_count(key));
pool_export_keys.push_back(key);
}
surface_size_bytes,
create_test_surface);
// check consistency
- EXPECT_EQ(acceleration_policy->get_surface_count(key), surface_count);
- EXPECT_EQ(acceleration_policy->get_free_surface_count(key), surface_count);
+ EXPECT_EQ(surface_count, acceleration_policy->get_surface_count(key));
+ EXPECT_EQ(surface_count, acceleration_policy->get_free_surface_count(key));
// consume available surfaces
std::vector<std::shared_ptr<Surface>> surfaces;
for (size_t i = 0; i < surface_count; i++) {
std::shared_ptr<Surface> surf = acceleration_policy->get_free_surface(key).lock();
EXPECT_TRUE(surf.get() != nullptr);
- EXPECT_EQ(surf->obtain_lock(), 0);
+ EXPECT_EQ(0, surf->obtain_lock());
surfaces.push_back(std::move(surf));
}
// check consistency (no free surfaces)
EXPECT_EQ(acceleration_policy->get_surface_count(key), surface_count);
- EXPECT_EQ(acceleration_policy->get_free_surface_count(key), 0);
+ EXPECT_EQ(0, acceleration_policy->get_free_surface_count(key));
// fail consume non-free surfaces
for (size_t i = 0; i < surface_count; i++) {
// release surfaces
for (auto& surf : surfaces) {
- EXPECT_EQ(surf->release_lock(), 1);
+ EXPECT_EQ(1, surf->release_lock());
}
surfaces.clear();
// check consistency
- EXPECT_EQ(acceleration_policy->get_surface_count(key), surface_count);
- EXPECT_EQ(acceleration_policy->get_free_surface_count(key), surface_count);
+ EXPECT_EQ(surface_count, acceleration_policy->get_surface_count(key));
+ EXPECT_EQ(surface_count, acceleration_policy->get_free_surface_count(key));
//check availability after release
for (size_t i = 0; i < surface_count; i++) {
std::shared_ptr<Surface> surf = acceleration_policy->get_free_surface(key).lock();
EXPECT_TRUE(surf.get() != nullptr);
- EXPECT_EQ(surf->obtain_lock(), 0);
+ EXPECT_EQ(0, surf->obtain_lock());
}
}
create_test_surface);
// check consistency
- EXPECT_EQ(acceleration_policy->get_surface_count(key), surface_count);
- EXPECT_EQ(acceleration_policy->get_free_surface_count(key), surface_count);
+ EXPECT_EQ(surface_count, acceleration_policy->get_surface_count(key));
+ EXPECT_EQ(surface_count, acceleration_policy->get_free_surface_count(key));
// consume available surfaces
std::vector<std::shared_ptr<Surface>> surfaces;
for (size_t i = 0; i < surface_count; i++) {
std::shared_ptr<Surface> surf = acceleration_policy->get_free_surface(key).lock();
EXPECT_TRUE(surf.get() != nullptr);
- EXPECT_EQ(surf->obtain_lock(), 0);
+ EXPECT_EQ(0, surf->obtain_lock());
surfaces.push_back(std::move(surf));
}
// concurrent release surfaces
size_t surfaces_count = surfaces.size();
for (auto& surf : surfaces) {
- EXPECT_EQ(surf->release_lock(), 1);
+ EXPECT_EQ(1, surf->release_lock());
std::this_thread::sleep_for(std::chrono::seconds(1));
}
surfaces.clear();
mfxSession mfx_session{};
engine.initialize_session(mfx_session, DecoderParams{}, std::shared_ptr<IDataProvider>{});
- EXPECT_EQ(engine.get_ready_frames_count(), 0);
+ EXPECT_EQ(0, engine.get_ready_frames_count());
ProcessingEngineBase::ExecutionStatus ret = engine.process(mfx_session);
EXPECT_EQ(ret, ProcessingEngineBase::ExecutionStatus::Continue);
- EXPECT_EQ(engine.pipeline_stage_num, 0);
+ EXPECT_EQ(0, engine.pipeline_stage_num);
ret = engine.process(mfx_session);
EXPECT_EQ(ret, ProcessingEngineBase::ExecutionStatus::Continue);
- EXPECT_EQ(engine.pipeline_stage_num, 1);
+ EXPECT_EQ(1, engine.pipeline_stage_num);
ret = engine.process(mfx_session);
EXPECT_EQ(ret, ProcessingEngineBase::ExecutionStatus::Continue);
- EXPECT_EQ(engine.pipeline_stage_num, 2);
+ EXPECT_EQ(2, engine.pipeline_stage_num);
ret = engine.process(mfx_session);
EXPECT_EQ(ret, ProcessingEngineBase::ExecutionStatus::Processed);
- EXPECT_EQ(engine.pipeline_stage_num, 3);
- EXPECT_EQ(engine.get_ready_frames_count(), 1);
+ EXPECT_EQ(3, engine.pipeline_stage_num);
+ EXPECT_EQ(1, engine.get_ready_frames_count());
ret = engine.process(mfx_session);
EXPECT_EQ(ret, ProcessingEngineBase::ExecutionStatus::SessionNotFound);
- EXPECT_EQ(engine.pipeline_stage_num, 3);
- EXPECT_EQ(engine.get_ready_frames_count(), 1);
+ EXPECT_EQ(3, engine.pipeline_stage_num);
+ EXPECT_EQ(1, engine.get_ready_frames_count());
cv::gapi::wip::Data frame;
engine.get_frame(frame);
any a(8);
auto casted_pointer = any_cast<int>(&a);
ASSERT_NE(nullptr, casted_pointer);
- ASSERT_EQ(*casted_pointer, 8);
+ ASSERT_EQ(8, *casted_pointer);
*casted_pointer = 7;
- ASSERT_EQ(any_cast<int>(a), 7);
+ ASSERT_EQ(7, any_cast<int>(a));
}
TEST(Any, any_cast_ref_throws_on_empty)
using namespace util;
any a(8);
- ASSERT_EQ(any_cast<int>(a), 8);
+ ASSERT_EQ(8, any_cast<int>(a));
any b (a);
ASSERT_NE(nullptr, any_cast<int>(&b));
- ASSERT_EQ(8 , any_cast<int>(b));
- ASSERT_EQ(8 , any_cast<int>(a));
+ ASSERT_EQ(8, any_cast<int>(b));
+ ASSERT_EQ(8, any_cast<int>(a));
}
TEST(Any, copy_empty)
using namespace util;
any a(8);
- ASSERT_EQ(any_cast<int>(a), 8);
+ ASSERT_EQ(8, any_cast<int>(a));
any b (std::move(a));
ASSERT_NE(nullptr, any_cast<int>(&b));
- ASSERT_EQ(8 , any_cast<int>(b));
+ ASSERT_EQ(8, any_cast<int>(b));
ASSERT_EQ(nullptr, any_cast<int>(&a));
}
any a(8);
any b;
- ASSERT_EQ(any_cast<int>(a), 8);
+ ASSERT_EQ(8, any_cast<int>(a));
b = (std::move(a));
ASSERT_NE(nullptr, any_cast<int>(&b));
- ASSERT_EQ(8 , any_cast<int>(b));
+ ASSERT_EQ(8, any_cast<int>(b));
ASSERT_EQ(nullptr, any_cast<int>(&a));
}
any a(8);
any b;
- ASSERT_EQ(any_cast<int>(a), 8);
+ ASSERT_EQ(8, any_cast<int>(a));
ASSERT_EQ(nullptr, any_cast<int>(&b));
b = a;
ASSERT_NE(nullptr, any_cast<int>(&b));
- ASSERT_EQ(8 , any_cast<int>(b));
- ASSERT_EQ(8 , any_cast<int>(a));
+ ASSERT_EQ(8, any_cast<int>(b));
+ ASSERT_EQ(8, any_cast<int>(a));
}
TEST(Any, get_ref_to_val_from_any)
any a(x);
int& casted_ref = any_cast<int>(a);
- ASSERT_EQ(casted_ref, 8);
+ ASSERT_EQ(8, casted_ref);
}
TEST(Any, update_val_via_ref)
int x = 8;
any a(x);
int& casted_ref = any_cast<int>(a);
- ASSERT_EQ(casted_ref, 8);
+ ASSERT_EQ(8, casted_ref);
casted_ref = 7;
- ASSERT_EQ(any_cast<int>(a), 7);
+ ASSERT_EQ(7, any_cast<int>(a));
}
} // namespace opencv_test
test_validation::MyBoolParamIndexedVisitor visitor(ss);
EXPECT_TRUE(cv::util::visit(visitor, var, int{42}));
- EXPECT_EQ(ss.str(), std::string("0:42,"));
+ EXPECT_EQ(std::string("0:42,"), ss.str());
}
std::stringstream ss;
test_validation::MyBoolNoParamNonIndexedVisitor visitor(ss);
cv::util::visit(visitor, var);
- EXPECT_EQ(ss.str(), std::string("0:42,"));
+ EXPECT_EQ(std::string("0:42,"), ss.str());
var = double{1.0};
EXPECT_TRUE(cv::util::visit(visitor, var));
- EXPECT_EQ(ss.str(), std::string("0:42,1:1,"));
+ EXPECT_EQ(std::string("0:42,1:1,"), ss.str());
var = char{'a'};
EXPECT_TRUE(cv::util::visit(visitor, var));
- EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,"));
+ EXPECT_EQ(std::string("0:42,1:1,2:a,"), ss.str());
var = float{6.0};
EXPECT_TRUE(cv::util::visit(visitor, var));
- EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,"));
+ EXPECT_EQ(std::string("0:42,1:1,2:a,3:6,"), ss.str());
var = test_validation::MyType{};
EXPECT_TRUE(cv::util::visit(visitor, var));
- EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,4:MyType,"));
+ EXPECT_EQ(std::string("0:42,1:1,2:a,3:6,4:MyType,"), ss.str());
var = test_validation::MyClass{};
EXPECT_TRUE(cv::util::visit(visitor, var));
- EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,4:MyType,5:MyClass,"));
+ EXPECT_EQ(std::string("0:42,1:1,2:a,3:6,4:MyType,5:MyClass,"), ss.str());
}
TEST(Variant, StaticVisitor)
test_validation::MyVoidNoParamNonIndexedVisitor visitor(ss);
cv::util::visit(visitor, var);
- EXPECT_EQ(ss.str(), std::string("42,"));
+ EXPECT_EQ(std::string("42,"), ss.str());
var = double{1.0};
cv::util::visit(visitor, var);
- EXPECT_EQ(ss.str(), std::string("42,1,"));
+ EXPECT_EQ(std::string("42,1,"), ss.str());
var = char{'a'};
cv::util::visit(visitor, var);
- EXPECT_EQ(ss.str(), std::string("42,1,a,"));
+ EXPECT_EQ(std::string("42,1,a,"), ss.str());
var = float{6.0};
cv::util::visit(visitor, var);
- EXPECT_EQ(ss.str(), std::string("42,1,a,6,"));
+ EXPECT_EQ(std::string("42,1,a,6,"), ss.str());
var = test_validation::MyType{};
cv::util::visit(visitor, var);
- EXPECT_EQ(ss.str(), std::string("42,1,a,6,MyType,"));
+ EXPECT_EQ(std::string("42,1,a,6,MyType,"), ss.str());
var = test_validation::MyClass{};
cv::util::visit(visitor, var);
- EXPECT_EQ(ss.str(), std::string("42,1,a,6,MyType,MyClass,"));
+ EXPECT_EQ(std::string("42,1,a,6,MyType,MyClass,"), ss.str());
}
TEST(Variant, StaticIndexedVisitor)
std::stringstream ss;
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor {ss}, var);
- EXPECT_EQ(ss.str(), std::string("0:42,"));
+ EXPECT_EQ(std::string("0:42,"), ss.str());
var = double{1.0};
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor (ss), var);
- EXPECT_EQ(ss.str(), std::string("0:42,1:1,"));
+ EXPECT_EQ(std::string("0:42,1:1,"), ss.str());
var = char{'a'};
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor (ss), var);
- EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,"));
+ EXPECT_EQ(std::string("0:42,1:1,2:a,"), ss.str());
var = float{6.0};
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor (ss), var);
- EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,"));
+ EXPECT_EQ(std::string("0:42,1:1,2:a,3:6,"), ss.str());
var = test_validation::MyType{};
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor (ss), var);
- EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,4:MyType,"));
+ EXPECT_EQ(std::string("0:42,1:1,2:a,3:6,4:MyType,"), ss.str());
var = test_validation::MyClass{};
cv::util::visit(test_validation::MyVoidNoParamIndexedVisitor (ss), var);
- EXPECT_EQ(ss.str(), std::string("0:42,1:1,2:a,3:6,4:MyType,5:MyClass,"));
+ EXPECT_EQ(std::string("0:42,1:1,2:a,3:6,4:MyType,5:MyClass,"), ss.str());
}
{
cv::util::visit(cv::util::overload_lambdas(
[](int value) {
- EXPECT_EQ(value, 42);
+ EXPECT_EQ(42, value);
},
[](double) {
ADD_FAILURE() << "can't be called for `double`";
ADD_FAILURE() << "can't be called for `double`";
},
[](char value) {
- EXPECT_EQ(value, 'c');
+ EXPECT_EQ('c', value);
},
[](float) {
ADD_FAILURE() << "can't be called for `float`";