/* M/////////////////////////////////////////////////////////////////////////////////////
//
//  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
//  By downloading, copying, installing or using the software you agree to this
//  license. If you do not agree to this license, do not download, install, copy
//  or use the software.
//
//
//                           License Agreement
//                For Open Source Computer Vision Library
//
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science,
// all rights reserved. Copyright (C) 2010-2012, Advanced Micro Devices, Inc.,
// all rights reserved. Copyright (C) 2010-2012, Multicoreware, Inc., all rights
// reserved. Third party copyrights are property of their respective owners.
//
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistribution's of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//
//   * Redistribution's in binary form must reproduce the above copyright
//   notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//
//   * The name of the copyright holders may not be used to endorse or promote
//   products
//     derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is"
// and any express or implied warranties, including, but not limited to, the
// implied warranties of merchantability and fitness for a particular purpose
// are disclaimed. In no event shall the Intel Corporation or contributors be
// liable for any direct, indirect, incidental, special, exemplary, or
// consequential damages (including, but not limited to, procurement of
// substitute goods or services; loss of use, data, or profits; or business
// interruption) however caused and on any theory of liability, whether in
// contract, strict liability, or tort (including negligence or otherwise)
// arising in any way out of the use of this software, even if advised of the
// possibility of such damage.
//
// M */

#include "test_correctness.hpp"

#include "test_common.hpp"

using namespace cv;
using namespace cv::acl;
using namespace cvtest;
using namespace testing;
using namespace std;

AclMat_Test::AclMat_Test() {}

AclMat_Test::~AclMat_Test() {}

/* thread function */
void thread_handler(void) {
  aclCxt *acl_context_0 =
      set_device("/home/perfxlab4/OpenCV_ACL/modules/acl/test/acl.json", 0, 1);
  release_device(acl_context_0);
}

void AclMat_Test::Test_set_device() {
  /* Current thread */
  aclCxt *acl_context_0 =
      set_device("/home/perfxlab4/OpenCV_ACL/modules/acl/test/acl.json", 0, 1);

  /* Different scope */
  {
    aclCxt *acl_context_1 = set_device(
        "/home/perfxlab4/OpenCV_ACL/modules/acl/test/acl.json", 2, 3);
    release_device(acl_context_1);
  }

  release_device(acl_context_0);
  /* Different thread */
  thread t(thread_handler);
  t.join();
}

void AclMat_Test::Test_constructor_UNALIGNED(aclCxt *acl_context) {
  Common_Test test;
  int rows, cols, type;
  bool ret;
  constexpr int rand_data_range = 32;
  const int rowsMax = 128;
  const int colsMax = 128;
  const int typeMax = 7;

  for (type = 0; type < typeMax; type++) {
    for (rows = 1; rows < rowsMax; rows++) {
      for (cols = 1; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type);
        aclMat aclmat_src(rows, cols, type, acl_context);
        test.SetDataRange(mat_src, rand_data_range);
        aclmat_src.upload(mat_src);
        ret = test.Test_Diff(aclmat_src, mat_src);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_constructor_UNALIGNED: -> aclMat(rows, cols, type, "
          "acl_context, config, policy) <- is success"
       << endl;

  for (type = 0; type < typeMax; type++) {
    for (rows = 1; rows < rowsMax; rows++) {
      for (cols = 1; cols < colsMax; cols++) {
        Mat mat_src(cv::Size(cols, rows), type);
        test.SetDataRange(mat_src, rand_data_range);
        aclMat aclmat_src(cv::Size(cols, rows), type, acl_context);
        aclmat_src.upload(mat_src);
        ret = test.Test_Diff(aclmat_src, mat_src);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_constructor_UNALIGNED: -> aclMat(size, type, acl_context, "
          "config, policy) <- is success"
       << endl;
}

void AclMat_Test::Test_constructor_ALIGN(aclCxt *acl_context) {
  Common_Test test;
  int rows, cols, type;
  bool ret;
  constexpr int rand_data_range = 32;
  const int rowsMax = 128;
  const int colsMax = 128;
  const int typeMax = 7;

  for (type = 0; type < typeMax; type++) {
    for (rows = 1; rows < rowsMax; rows++) {
      for (cols = 1; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type);
        test.SetDataRange(mat_src, rand_data_range);
        aclMat aclmat_src(rows, cols, type, acl_context, MEMORY_ALIGN);
        aclmat_src.upload(mat_src, MEMORY_ALIGN);
        ret = test.Test_Diff(aclmat_src, mat_src, MEMORY_ALIGN);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_constructor_ALIGN: -> aclMat(rows, cols, type, acl_context, "
          "config, policy) <- is success"
       << endl;

  for (type = 0; type < typeMax; type++) {
    for (rows = 1; rows < rowsMax; rows++) {
      for (cols = 1; cols < colsMax; cols++) {
        Mat mat_src(cv::Size(cols, rows), type);
        test.SetDataRange(mat_src, rand_data_range);
        aclMat aclmat_src(cv::Size(cols, rows), type, acl_context,
                          MEMORY_ALIGN);
        aclmat_src.upload(mat_src, MEMORY_ALIGN);
        ret = test.Test_Diff(aclmat_src, mat_src, MEMORY_ALIGN);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_constructor_ALIGN: -> aclMat(size, type, acl_context, config, "
          "policy) <- is success"
       << endl;
}

void AclMat_Test::Test_constructor(aclCxt *acl_context_0) {
  Common_Test test;
  int rows, cols, type;
  bool ret;
  const int rowsMax = 128;
  const int colsMax = 128;
  const int typeMax = 7;

  for (type = 0; type < typeMax; type++) {
    for (rows = 1; rows < rowsMax; rows++) {
      for (cols = 1; cols < colsMax; cols++) {
        aclMat aclmat_src(rows, cols, type, acl_context_0);
        aclMat aclmat_dest(aclmat_src);
        ret = test.Test_Diff(aclmat_src, aclmat_dest);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_constructor: -> aclMat(aclmat_src) <- is success" << endl;

  for (type = 0; type < typeMax; type++) {
    for (rows = 1; rows < rowsMax; rows++) {
      for (cols = 1; cols < colsMax; cols++) {
        aclMat aclmat_src(cv::Size(cols, rows), type, acl_context_0,
                          MEMORY_ALIGN);
        aclMat aclmat_dest(aclmat_src);
        ret = test.Test_Diff(aclmat_src, aclmat_dest);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_constructor: -> aclMat(const aclMat& other) <- is success"
       << endl;
}

void AclMat_Test::Test_constructor_DATA(aclCxt *acl_context_0) {
  Common_Test test;
  int rows, cols, type;
  bool ret;
  const int rowsMax = 128;
  const int colsMax = 128;
  const int typeMax = 7;

  for (type = 0; type < typeMax; type++) {
    for (rows = 1; rows < rowsMax; rows++) {
      for (cols = 1; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type);
        Mat mat_dest(rows, cols, type);
        test.SetDataRange(mat_src);

        aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0);
        aclmat_src.download(mat_dest);
        ret = test.Test_Diff(mat_src, mat_dest);
        ASSERT_TRUE(ret);
      }
    }
  }
  cerr << "Test_constructor_DATA: -> aclMat(rows, cols, type, data, "
          "acl_context)) <- is success"
       << endl;

  for (type = 0; type < typeMax; type++) {
    for (rows = 1; rows < rowsMax; rows++) {
      for (cols = 1; cols < colsMax; cols++) {
        Mat mat_src(cv::Size(cols, rows), type);
        Mat mat_dest(cv::Size(cols, rows), type);
        test.SetDataRange(mat_src);

        aclMat aclmat_src(cv::Size(cols, rows), type, mat_src.data,
                          acl_context_0);
        aclmat_src.download(mat_dest);
        ret = test.Test_Diff(mat_src, mat_dest);
        ASSERT_TRUE(ret);
      }
    }
  }

  cerr << "Test_constructor_DATA: -> aclMat(size, type, data, acl_context)) <- "
          "is success"
       << endl;
}

void AclMat_Test::Test_constructor_RANGE(aclCxt *acl_context_0) {
  Common_Test test;
  int type;
  bool ret;
  int rangerows, rangecols;
  int rows = 64, cols = 64;
  const int rangerowsMax = 64;
  const int rangecolsMax = 64;
  const int typeMax = 7;
  constexpr int large_mat_range = 4;
  constexpr int small_mat_range = 2;

  for (type = 0; type < typeMax; type++) {
    for (rangerows = large_mat_range; rangerows < rangerowsMax; rangerows++) {
      for (rangecols = large_mat_range; rangecols < rangecolsMax; rangecols++) {
        Mat mat_src(rows, cols, type);
        Mat mat_dest(rows, cols, type);
        test.SetDataRange(mat_src);
        test.SetDataRange(mat_dest);

        Mat mat_rangesrc(mat_src, cv::Range(small_mat_range, rangerows),
                         cv::Range(small_mat_range, rangecols));
        Mat mat_rangedest(mat_dest, cv::Range(small_mat_range, rangerows),
                          cv::Range(small_mat_range, rangecols));
        aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0);
        aclMat aclmat_range(aclmat_src, cv::Range(small_mat_range, rangerows),
                            cv::Range(small_mat_range, rangecols));
        aclmat_range.download(mat_rangedest);
        ret = test.Test_Diff(mat_rangesrc, mat_rangedest);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_constructor_RANGE: -> aclMat(aclmat_src, rowragne, colrange)) "
          "<- is success"
       << endl;
}

void AclMat_Test::Test_constructor_ROI(aclCxt *acl_context_0) {
  Common_Test test;
  {
    int rows = 6, cols = 8;
    int type = CV_8UC1;
    constexpr int test_val_1 = 1;
    constexpr int test_val_2 = 2;
    cv::Rect roi(test_val_2, test_val_2, test_val_1, test_val_1);
    bool ret;
    Mat mat_src(rows, cols, type);
    Mat mat_dest(rows, cols, type);

    test.SetDataRange(mat_src);
    test.SetDataRange(mat_dest);

    Mat mat_roi1(mat_src, roi);
    Mat mat_roi(mat_dest, roi);

    aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0);
    aclMat aclmat_roi(aclmat_src, roi);
    aclmat_roi.download(mat_roi);
    ret = test.Test_Diff(mat_roi1, mat_roi);
    ASSERT_TRUE(ret);
  }

  {
    int rows = 12, cols = 61;
    constexpr int test_val_2 = 2;
    constexpr int test_val_8 = 8;
    int type = CV_16UC3;
    cv::Rect roi(test_val_8, test_val_8, test_val_2, test_val_2);
    bool ret;
    Mat mat_src(rows, cols, type);
    Mat mat_dest(rows, cols, type);

    test.SetDataRange(mat_src);
    test.SetDataRange(mat_dest);

    Mat mat_roi1(mat_src, roi);
    Mat mat_roi(mat_dest, roi);

    aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0);
    aclMat aclmat_roi(aclmat_src, roi);
    aclmat_roi.download(mat_roi);
    ret = test.Test_Diff(mat_roi1, mat_roi);
    ASSERT_TRUE(ret);
  }

  {
    int rows = 16, cols = 80;
    int type = CV_32FC3;
    constexpr int test_val_1 = 1;
    constexpr int test_val_3 = 3;
    constexpr int test_val_4 = 4;
    constexpr int test_val_8 = 8;
    cv::Rect roi(test_val_8, test_val_4, test_val_1, test_val_3);
    bool ret;
    Mat mat_src(rows, cols, type);
    Mat mat_dest(rows, cols, type);

    test.SetDataRange(mat_src);
    test.SetDataRange(mat_dest);

    Mat mat_roi1(mat_src, roi);
    Mat mat_roi(mat_dest, roi);

    aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0);
    aclMat aclmat_roi(aclmat_src, roi);
    aclmat_roi.download(mat_roi);
    ret = test.Test_Diff(mat_roi1, mat_roi);
    ASSERT_TRUE(ret);
  }

  clog << "Test_constructor_ROI: -> aclMat(aclmat_src, roi)) <- is success"
       << endl;
}

void AclMat_Test::Test_constructor_MAT(aclCxt *acl_context_0) {
  Common_Test test;
  int rows, cols, type;
  bool ret;
  const int rowsMax = 1048;
  const int colsMax = 1048;
  const int typeMax = 7;
  constexpr int lval = 1000;

  for (type = 0; type < typeMax; type++) {
    for (rows = lval; rows < rowsMax; rows++) {
      for (cols = lval; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type);
        Mat mat_dest(rows, cols, type);
        test.SetDataRange(mat_src);

        aclMat aclmat_src(mat_src, acl_context_0);
        aclmat_src.download(mat_dest);
        ret = test.Test_Diff(mat_src, mat_dest);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_constructor_MAT: -> aclMat(mat_src, acl_context_0)) <- is "
          "success"
       << endl;
}

void AclMat_Test::Test_DATA_TRANSFER(aclCxt *acl_context_0) {
  Common_Test test;
  int rows, cols, type;
  bool ret;
  const int rowsMax = 1048;
  const int colsMax = 1048;
  constexpr int lval = 1024;
  const int typeMax = 7;

  for (type = 0; type < typeMax; type++) {
    for (rows = lval; rows < rowsMax; rows++) {
      for (cols = lval; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type);
        Mat mat_dest(rows, cols, type);

        test.SetDataRange(mat_src);
        test.SetDataRange(mat_dest);

        aclMat aclmat_src(rows, cols, type, acl_context_0);
        aclmat_src.upload(mat_src);
        aclmat_src.download(mat_dest);
        ret = test.Test_Diff(mat_src, mat_dest);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_DATA_TRANSFER_UNALIGNED: -> upload(), download() <- is success"
       << endl;

  for (type = 0; type < typeMax; type++) {
    for (rows = lval; rows < rowsMax; rows++) {
      for (cols = lval; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type);
        Mat mat_dest(rows, cols, type);

        test.SetDataRange(mat_src);
        test.SetDataRange(mat_dest);

        aclMat aclmat_src(rows, cols, type, acl_context_0, MEMORY_ALIGN);
        aclmat_src.upload(mat_src, MEMORY_ALIGN);
        aclmat_src.download(mat_dest, MEMORY_ALIGN);
        ret = test.Test_Diff(mat_src, mat_dest);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_DATA_TRANSFER_ALIGN: -> upload(), download() <- is success"
       << endl;
}

void AclMat_Test::Test_DATA_TRANSFERASYNC(aclCxt *acl_context_0) {
  Common_Test test;
  int rows, cols, type;
  bool ret;
  const int rowsMax = 1048;
  const int colsMax = 1048;
  const int typeMax = 7;
  constexpr int lval = 1024;

  for (type = 0; type < typeMax; type++) {
    for (rows = lval; rows < rowsMax; rows++) {
      for (cols = lval; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type);
        Mat mat_dest(rows, cols, type);

        test.SetDataRange(mat_src);
        test.SetDataRange(mat_dest);

        aclMat aclmat_src(rows, cols, type, acl_context_0);
        aclmat_src.upload(mat_src, aclmat_src.acl_context->get_stream(0));
        aclmat_src.download(mat_dest, aclmat_src.acl_context->get_stream(0));
        ret = test.Test_Diff(mat_src, mat_dest);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_DATA_TRANSFERASYNC_UNALIGNED: -> upload(), download() <- is "
          "success"
       << endl;

  for (type = 0; type < typeMax; type++) {
    for (rows = lval; rows < rowsMax; rows++) {
      for (cols = lval; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type);
        Mat mat_dest(rows, cols, type);

        test.SetDataRange(mat_src);
        test.SetDataRange(mat_dest);

        aclMat aclmat_src(rows, cols, type, acl_context_0, MEMORY_ALIGN);
        aclmat_src.upload(mat_src, aclmat_src.acl_context->get_stream(0),
                          MEMORY_ALIGN);
        aclmat_src.download(mat_dest, aclmat_src.acl_context->get_stream(0),
                            MEMORY_ALIGN);
        ret = test.Test_Diff(mat_src, mat_dest);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_DATA_TRANSFERASYNC_ALIGN: -> upload(), download() <- is success"
       << endl;
}

static inline void dataSwap(int &data1, int &data2) {
  Common_Test test;
  int temp;
  if (data1 < data2) {
    temp = data1;
    data1 = data2;
    data2 = temp;
  }
}

void AclMat_Test::Test_locateROI(aclCxt *acl_context_0) {
  Common_Test test;
  int rows = 256, cols = 256;
  int type = CV_8UC1;
  int rangex, rangey;
  int rangex1, rangey1;
  cv::Size size, size1;
  cv::Point ofs, ofs1;

  for (int x = 0; x < rows * cols; ++x) {
    rangex = (rangex = test.RandDom_()) > 0 ? rangex : 1;
    rangey = (rangey = test.RandDom_()) > 0 ? rangey : 1;
    rangex1 = (rangex1 = test.RandDom_()) > 0 ? rangex1 : 1;
    rangey1 = (rangey1 = test.RandDom_()) > 0 ? rangey1 : 1;

    dataSwap(rangex, rangex1);
    dataSwap(rangey, rangey1);

    Mat mat_src(rows, cols, type);
    Mat mat_range(mat_src, cv::Range(rangex1, rangex + 1),
                  cv::Range(rangey1, rangey + 1));
    mat_range.locateROI(size, ofs);

    aclMat aclmat_src(rows, cols, type, acl_context_0);
    aclMat aclmat_range(aclmat_src, cv::Range(rangex1, rangex + 1),
                        cv::Range(rangey1, rangey + 1));
    aclmat_range.locateROI(size1, ofs1);

    ASSERT_EQ(size.height, size1.height);
    ASSERT_EQ(size.width, size1.width);
    ASSERT_EQ(ofs.x, ofs1.x);
    ASSERT_EQ(ofs.y, ofs1.y);
  }
  clog << "Test_loacteROI: -> locateROI() <- is success" << endl;
}

void AclMat_Test::Test_swap(aclCxt *acl_context_0) {
  Common_Test test;
  int rows, cols, type;
  bool ret;
  const int rowsMax = 1048;
  const int colsMax = 1048;
  const int typeMax = 7;
  constexpr int lval = 1024;

  for (type = 0; type < typeMax; type++) {
    for (rows = lval; rows < rowsMax; rows++) {
      for (cols = lval; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type);
        Mat mat_dest(rows, cols, type);

        test.SetDataRange(mat_src);
        test.SetDataRange(mat_dest);

        Mat mat_dest1(rows, cols, type);
        Mat mat_dest2(rows, cols, type);

        aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0);
        aclMat aclmat_src1(rows, cols, type, mat_dest.data, acl_context_0);
        aclmat_src.swap(aclmat_src1);

        aclmat_src.download(mat_dest1);
        aclmat_src1.download(mat_dest2);

        ret = test.Test_Diff(mat_dest1, mat_dest);
        ASSERT_TRUE(ret);

        ret = test.Test_Diff(mat_dest2, mat_src);
        ASSERT_TRUE(ret);
      }
    }
  }
  clog << "Test_Swap: -> swap() <- is success" << endl;
}

void AclMat_Test::Test_operator_add(aclCxt *acl_context) {
  Common_Test test;
  int rows, cols;
  bool ret;
  constexpr int rand_data_range = 32;
  constexpr int lval = 1024;
  const int rowsMax = 1048;
  const int colsMax = 1048;

  vector<int> type{CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3, CV_32SC1, CV_32SC3};
  for (size_t i = 0; i < type.size(); ++i) {
    test.PrintLog("Correctness test: Functoin: operator+=()", type[i]);
    for (rows = lval; rows < rowsMax; rows++) {
      for (cols = lval; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type[i]);
        Mat mat_dest(rows, cols, type[i]);
        Mat mat_dest1(rows, cols, type[i]);

        test.SetDataRange(mat_src, rand_data_range);
        test.SetDataRange(mat_dest, rand_data_range);

        aclMat aclmat_src(rows, cols, type[i], mat_src.data, acl_context,
                          MEMORY_ALIGN);
        aclMat aclmat_dest(rows, cols, type[i], mat_dest.data, acl_context,
                           MEMORY_ALIGN);

        mat_dest += mat_src;

        aclmat_dest += aclmat_src;
        wait_stream(acl_context);
        aclmat_dest.download(mat_dest1, MEMORY_ALIGN);

        ret = test.Test_Diff(mat_dest, mat_dest1);
        ASSERT_TRUE(ret);
      }
    }
  }
}

void AclMat_Test::Test_operator_sub(aclCxt *acl_context) {
  Common_Test test;
  int rows, cols;
  bool ret;
  const int rowsMax = 1048;
  const int colsMax = 1048;
  constexpr int lval = 1024;
  constexpr int s_val1 = 1, s_val2 = 2, s_val3 = 3;
  constexpr int s_val4 = 4, s_val6 = 6, s_val8 = 8;

  vector<int> type{CV_8UC1,  CV_8UC3,  CV_32FC1, CV_32FC3,
                   CV_32SC1, CV_32SC3, CV_64FC1};
  for (size_t i = 0; i < type.size(); ++i) {
    test.PrintLog("Correctness test: Functoin: operator-=()", type[i]);
    for (rows = lval; rows < rowsMax; rows++) {
      for (cols = lval; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type[i], Scalar(s_val1, s_val2, s_val3));
        Mat mat_dest(rows, cols, type[i], Scalar(s_val4, s_val6, s_val8));
        Mat mat_dest1(rows, cols, type[i]);

        aclMat aclmat_src(rows, cols, type[i], mat_src.data, acl_context,
                          MEMORY_ALIGN);
        aclMat aclmat_dest(rows, cols, type[i], mat_dest.data, acl_context,
                           MEMORY_ALIGN);

        mat_dest -= mat_src;

        aclmat_dest -= aclmat_src;
        wait_stream(acl_context);
        aclmat_dest.download(mat_dest1, MEMORY_ALIGN);

        ret = test.Test_Diff(mat_dest, mat_dest1);
        ASSERT_TRUE(ret);
      }
    }
  }
}

void AclMat_Test::Test_operator_div(aclCxt *acl_context) {
  Common_Test test;
  int rows, cols;
  bool ret;
  const int rowsMax = 1048;
  const int colsMax = 1048;
  constexpr int lval = 1024;
  constexpr int s_val1 = 1, s_val2 = 2;
  constexpr int s_val4 = 4, s_val6 = 6, s_val8 = 8;

  vector<int> type{CV_8UC1,  CV_8UC3,  CV_32FC1, CV_32FC3,
                   CV_32SC1, CV_32SC3, CV_64FC1};
  for (size_t i = 0; i < type.size(); ++i) {
    test.PrintLog("Correctness test: Functoin: operator/=()", type[i]);
    for (rows = lval; rows < rowsMax; rows++) {
      for (cols = lval; cols < colsMax; cols++) {
        Mat mat_src(rows, cols, type[i], Scalar(s_val1, s_val2, s_val4));
        Mat mat_dest(rows, cols, type[i], Scalar(s_val4, s_val6, s_val8));
        Mat mat_dest1(rows, cols, type[i]);

        aclMat aclmat_src(rows, cols, type[i], mat_src.data, acl_context,
                          MEMORY_ALIGN);
        aclMat aclmat_dest(rows, cols, type[i], mat_dest.data, acl_context,
                           MEMORY_ALIGN);

        mat_dest /= mat_src;

        aclmat_dest /= aclmat_src;
        wait_stream(acl_context);
        aclmat_dest.download(mat_dest1, MEMORY_ALIGN);

        ret = test.Test_Diff(mat_dest, mat_dest1);
        ASSERT_TRUE(ret);
      }
    }
  }
}

void AclMat_Test::Test_operator_mul(aclCxt *acl_context) {
  Common_Test test;
  int val;
  bool ret;
  constexpr int rand_data_range = 32;
  const int valMax = 1048;
  constexpr int lval = 1024;

  vector<int> type{CV_32FC1};
  for (size_t i = 0; i < type.size(); ++i) {
    test.PrintLog("Correctness test: Functoin: operator*=()", type[i]);
    for (val = lval; val < valMax; val++) {
      Mat mat_src(val, val, type[i]);
      Mat mat_dest(val, val, type[i]);
      Mat mat_dest1(val, val, type[i]);

      test.SetDataRange(mat_src, rand_data_range);
      test.SetDataRange(mat_dest, rand_data_range);

      aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context);
      aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context);

      mat_dest *= mat_src;

      aclmat_dest *= aclmat_src;
      wait_stream(acl_context);
      aclmat_dest.download(mat_dest1);

      ret = test.Test_Diff(mat_dest, mat_dest1);
      ASSERT_TRUE(ret);
    }
  }
}