diff --git a/acl/include/opencv2/acl/init_core.hpp b/acl/include/opencv2/acl/init_core.hpp
index 7d51ddc..8eeb46f 100644
--- a/acl/include/opencv2/acl/init_core.hpp
+++ b/acl/include/opencv2/acl/init_core.hpp
@@ -34,7 +34,7 @@ inline aclEnv::~aclEnv() {
 }
 
 /////////////////////////////////////////aclCxt////////////////////////////
-inline aclCxt::aclCxt(){};
+inline aclCxt::aclCxt() {};
 
 inline aclCxt::aclCxt(int device_id) : _device_id(device_id) {
   _context = static_cast<aclrtContext *>(fastMalloc(sizeof(*_context)));
diff --git a/acl/src/matrices.cpp b/acl/src/matrices.cpp
index 7124de9..3869ad6 100644
--- a/acl/src/matrices.cpp
+++ b/acl/src/matrices.cpp
@@ -5,7 +5,6 @@ using namespace cv;
 using namespace cv::acl;
 namespace cv {
 namespace acl {
-
 static int merge_type(int depth, int channels) {
   switch (depth) {
     case CV_8U:
@@ -36,28 +35,27 @@ void merge(const vector<aclMat> &mv, aclMat &dest, int stream_id) {
 
   for (size_t i = 0; i < mv.size(); ++i) {
     int cols = mv[i].step / mv[i].elemSize();
-    vector<int64_t> inputShape{1, mv[i].rows, cols, mv[i].channels()};
+    vector<int64_t> inputShape {1, mv[i].rows, cols, mv[i].channels()};
     opDesc.AddInputTensorDesc(dataType, inputShape.size(), inputShape.data(),
                               ACL_FORMAT_NHWC);
   }
 
   int cols = mv[0].step / mv[0].elemSize();
   int channels = mv.size();
-  vector<int64_t> outputShape{1, mv[0].rows, cols, channels};
+  vector<int64_t> outputShape {1, mv[0].rows, cols, channels};
   opDesc.AddOutputTensorDesc(dataType, outputShape.size(), outputShape.data(),
                              ACL_FORMAT_NHWC);
 
   ino64_t N = mv.size();
-  constexpr int index2 = 2;
-  constexpr int index3 = 3;
-  constexpr int index4 = 4;
+  constexpr int index0 = 0, index1 = 1;
+  constexpr int index2 = 2, index3 = 3, index4 = 4;
   constexpr int merge_size3 = 3;
   constexpr int merge_size4 = 4;
   aclopSetAttrInt(opDesc.opAttr, "N", N);
 
-  aclSetTensorDescName(opDesc.inputDesc[0], "concat_dim");
+  aclSetTensorDescName(opDesc.inputDesc[index0], "concat_dim");
 
-  aclSetTensorDescName(opDesc.inputDesc[1], "x0");
+  aclSetTensorDescName(opDesc.inputDesc[index1], "x0");
   aclSetTensorDescName(opDesc.inputDesc[index2], "x1");
   if (mv.size() == merge_size3)
     aclSetTensorDescName(opDesc.inputDesc[index3], "x2");
@@ -91,7 +89,7 @@ void merge(const vector<aclMat> &mv, aclMat &dest, int stream_id) {
   for (size_t i = 0; i < outputBuffers_.size(); i++)
     AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i]));
 
-  aclrtFree(dev);
+  AclSafeCall(aclrtFree(dev));
 }
 
 /**
@@ -123,18 +121,18 @@ void transpose(const aclMat &src, aclMat &dest, int stream_id) {
 
   void *dev;
   void *perm;
-  constexpr int dim0_t = 0;
-  constexpr int dim1_t = 1;
-  constexpr int dim2_t = 2;
-  constexpr int dim3_t = 3;
+  constexpr int dim0_t = 0, dim1_t = 1;
+  constexpr int dim2_t = 2, dim3_t = 3;
+  constexpr int index0 = 0, index1 = 1;
+  constexpr int index2 = 2, index3 = 3;
 
   size_t size = aclGetTensorDescSize(opDesc.inputDesc[1]);
   aclrtMalloc(&dev, size, ACL_MEM_MALLOC_NORMAL_ONLY);
   aclrtMallocHost(&perm, aclGetTensorDescSize(opDesc.inputDesc.data()[1]));
-  ((int *)perm)[0] = dim0_t;
-  ((int *)perm)[1] = dim2_t;
-  ((int *)perm)[2] = dim1_t;
-  ((int *)perm)[3] = dim3_t;
+  ((int *)perm)[index0] = dim0_t;
+  ((int *)perm)[index1] = dim2_t;
+  ((int *)perm)[index2] = dim1_t;
+  ((int *)perm)[index3] = dim3_t;
   aclrtMemcpy(dev, size, perm, size, ACL_MEMCPY_HOST_TO_DEVICE);
   inputBuffers_.emplace_back(aclCreateDataBuffer(dev, size));
 
diff --git a/acl/test/test_acl.cpp b/acl/test/test_acl.cpp
index d908752..e0a12d2 100644
--- a/acl/test/test_acl.cpp
+++ b/acl/test/test_acl.cpp
@@ -13,6 +13,7 @@ void PERF_TEST::Test_operator_add_perf(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int rand_data_range = 1;
   constexpr int min_format_flag = 128;
@@ -20,7 +21,7 @@ void PERF_TEST::Test_operator_add_perf(aclCxt *acl_context) {
   vector<int> type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1};
   for (size_t i = 0; i < type.size(); ++i) {
     test.PrintLog("Perf test : Function: operator+=()", type[i]);
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src(val, val, type[i]);
       Mat mat_dest(val, val, type[i]);
@@ -65,6 +66,7 @@ void PERF_TEST::Test_operator_sub_perf(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int rand_data_range1 = 4;
   constexpr int rand_data_range2 = 32;
@@ -73,7 +75,7 @@ void PERF_TEST::Test_operator_sub_perf(aclCxt *acl_context) {
   vector<int> type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1};
   for (size_t i = 0; i < type.size(); ++i) {
     test.PrintLog("Perf test : Function: operator-=()", type[i]);
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src(val, val, type[i]);
       Mat mat_dest(val, val, type[i]);
@@ -116,17 +118,16 @@ void PERF_TEST::Test_operator_div_perf(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
-  constexpr int s_val1 = 1;
-  constexpr int s_val2 = 2;
-  constexpr int s_val4 = 4;
-  constexpr int s_val8 = 8;
+  constexpr int s_val1 = 1, s_val2 = 2;
+  constexpr int s_val4 = 4, s_val8 = 8;
   constexpr int min_format_flag = 128;
 
   vector<int> type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1};
   for (size_t i = 0; i < type.size(); ++i) {
     test.PrintLog("Perf test : Function: operator/=()", type[i]);
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src(val, val, type[i], Scalar(s_val1, s_val2, s_val4));
       Mat mat_dest(val, val, type[i], Scalar(s_val2, s_val4, s_val8));
@@ -166,13 +167,14 @@ void PERF_TEST::Test_operator_mul_perf(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int rand_data_range = 1;
   constexpr int min_format_flag = 128;
 
   vector<int> type{CV_32FC1};
   for (size_t i = 0; i < type.size(); ++i) {
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src(val, val, type[i]);
       Mat mat_dest(val, val, type[i]);
diff --git a/acl/test/test_correctness.cpp b/acl/test/test_correctness.cpp
index 70aeaa9..67a211e 100644
--- a/acl/test/test_correctness.cpp
+++ b/acl/test/test_correctness.cpp
@@ -628,6 +628,8 @@ void AclMat_Test::Test_operator_sub(aclCxt *acl_context) {
   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};
@@ -635,8 +637,8 @@ void AclMat_Test::Test_operator_sub(aclCxt *acl_context) {
     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(1, 2, 3));
-        Mat mat_dest(rows, cols, type[i], Scalar(4, 6, 8));
+        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,
@@ -664,6 +666,8 @@ void AclMat_Test::Test_operator_div(aclCxt *acl_context) {
   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};
@@ -671,8 +675,8 @@ void AclMat_Test::Test_operator_div(aclCxt *acl_context) {
     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(1, 2, 4));
-        Mat mat_dest(rows, cols, type[i], Scalar(4, 6, 8));
+        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,
diff --git a/acl/test/test_gemm.cpp b/acl/test/test_gemm.cpp
index f489e95..73be690 100644
--- a/acl/test/test_gemm.cpp
+++ b/acl/test/test_gemm.cpp
@@ -14,12 +14,13 @@ void PERF_TEST::Test_MatMul(aclCxt *acl_context) {
   double begin, end, time, acltime;
   Common_Test test;
   vector<int> type{CV_32FC1};
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int rand_data_range = 32;
   constexpr int min_format_flag = 128;
 
   for (size_t i = 0; i < type.size(); ++i) {
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       Mat mat_src(val, val, type[i]);
       Mat mat_src1(val, val, type[i]);
       Mat mat_dest(val, val, type[i]);
@@ -68,17 +69,21 @@ void PERF_TEST::Test_Convolution(aclCxt *acl_context) {
   double begin, end, time, acltime;
   Common_Test test;
   vector<int> type{CV_32FC1};
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int min_format_flag = 128;
+  constexpr int s_val1 = 1, s_val2 = 2;
+  constexpr int s_val4 = 4, s_val6 = 6;
+  constexpr int kernel_val = 3;
 
   for (size_t i = 0; i < type.size(); ++i) {
-    for (val = start_val; val <= valmax; val *= 2) {
-      Mat mat_src(val, val, type[i], Scalar{1, 2});
-      Mat mat_kernel(3, 3, type[i], Scalar(1, 4));
-      Mat mat_dest(val, val, type[i], Scalar{6});
+    for (val = start_val; val <= valmax; val *= base) {
+      Mat mat_src(val, val, type[i], Scalar{s_val1, s_val2});
+      Mat mat_kernel(kernel_val, kernel_val, type[i], Scalar(s_val1, s_val4));
+      Mat mat_dest(val, val, type[i], Scalar{s_val6});
 
       aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context);
-      aclMat aclmat_kernel(3, 3, type[i], mat_kernel.data, acl_context);
+      aclMat aclmat_kernel(kernel_val, kernel_val, type[i], mat_kernel.data, acl_context);
       aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context);
 
       n = cycle_index;
diff --git a/acl/test/test_mathfuncs.cpp b/acl/test/test_mathfuncs.cpp
index e539417..cfba6e2 100644
--- a/acl/test/test_mathfuncs.cpp
+++ b/acl/test/test_mathfuncs.cpp
@@ -13,17 +13,19 @@ void PERF_TEST::Test_Abs(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
+  constexpr int s_val_2 = -2, s_val_4 = -4, s_val_6 = -6;
   constexpr int start_val = 8;
   constexpr int min_format_flag = 128;
 
   vector<int> type{CV_32FC1, CV_32SC1};
   for (size_t i = 0; i < type.size(); ++i) {
     test.PrintLog("Perf test : Function: Abs()", type[i]);
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
-      Mat mat_src(val, val, type[i], Scalar{-2});
-      Mat mat_dest(val, val, type[i], Scalar{-4});
-      Mat mat_dest1(val, val, type[i], Scalar{-6});
+      Mat mat_src(val, val, type[i], Scalar{s_val_2});
+      Mat mat_dest(val, val, type[i], Scalar{s_val_4});
+      Mat mat_dest1(val, val, type[i], Scalar{s_val_6});
 
       aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context);
       aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context);
@@ -61,20 +63,22 @@ void PERF_TEST::Test_Pow(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
+  constexpr int rand_data_range = 32;
   constexpr int min_format_flag = 128;
 
   vector<int> type{CV_8UC1, CV_32FC1, CV_32SC1};
   for (size_t i = 0; i < type.size(); ++i) {
     test.PrintLog("Perf test : Function: Pow()", type[i]);
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       int power = test.RandDom_(6);
       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, 32);
+      test.SetDataRange(mat_src, 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);
@@ -110,19 +114,21 @@ void PERF_TEST::Test_Sqrt(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int min_format_flag = 128;
+  constexpr int rand_data_range = 32;
 
   vector<int> type{CV_32FC1, CV_64FC1};
   for (size_t i = 0; i < type.size(); ++i) {
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       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, 32);
-      test.SetDataRange(mat_dest, 32);
+      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);
@@ -158,21 +164,23 @@ void PERF_TEST::Test_Add(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int min_format_flag = 128;
+  constexpr int rand_data_range = 32;
 
   vector<int> type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1};
   for (size_t i = 0; i < type.size(); ++i) {
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src1(val, val, type[i]);
       Mat mat_src2(val, val, type[i]);
       Mat mat_dest(val, val, type[i]);
       Mat mat_dest1(val, val, type[i]);
 
-      test.SetDataRange(mat_src1, 32);
-      test.SetDataRange(mat_src2, 32);
-      test.SetDataRange(mat_dest, 32);
+      test.SetDataRange(mat_src1, rand_data_range);
+      test.SetDataRange(mat_src2, rand_data_range);
+      test.SetDataRange(mat_dest, rand_data_range);
 
       aclMat aclmat_src1(val, val, type[i], mat_src1.data, acl_context);
       aclMat aclmat_src2(val, val, type[i], mat_src2.data, acl_context);
@@ -211,21 +219,24 @@ void PERF_TEST::Test_Divide(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int min_format_flag = 128;
+  constexpr int rand_data_range1 = 32;
+  constexpr int rand_data_range2 = 4;
 
   vector<int> type{CV_8UC1, CV_32FC1, CV_32SC1};
   for (size_t i = 0; i < type.size(); ++i) {
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src1(val, val, type[i]);
       Mat mat_src2(val, val, type[i]);
       Mat mat_dest(val, val, type[i]);
       Mat mat_dest1(val, val, type[i]);
 
-      test.SetDataRange(mat_src1, 32);
-      test.SetDataRange(mat_src2, 4);
-      test.SetDataRange(mat_dest, 32);
+      test.SetDataRange(mat_src1, rand_data_range1);
+      test.SetDataRange(mat_src2, rand_data_range2);
+      test.SetDataRange(mat_dest, rand_data_range1);
 
       aclMat aclmat_src1(val, val, type[i], mat_src1.data, acl_context);
       aclMat aclmat_src2(val, val, type[i], mat_src2.data, acl_context);
@@ -262,19 +273,22 @@ void PERF_TEST::Test_Exp(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int min_format_flag = 128;
+  constexpr int rand_data_range1 = 32;
+  constexpr int rand_data_range2 = 2;
 
   vector<int> type{CV_32FC1, CV_64FC1};
   for (size_t i = 0; i < type.size(); ++i) {
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       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, 32);
-      test.SetDataRange(mat_dest, 2);
+      test.SetDataRange(mat_src, rand_data_range1);
+      test.SetDataRange(mat_dest, rand_data_range2);
 
       aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context);
       aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context);
@@ -310,19 +324,21 @@ void PERF_TEST::Test_Log(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int min_format_flag = 128;
+  constexpr int rand_data_range = 32;
 
   vector<int> type{CV_32FC1, CV_64FC1};
   for (size_t i = 0; i < type.size(); ++i) {
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       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, 32);
-      test.SetDataRange(mat_dest, 32);
+      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);
@@ -358,21 +374,23 @@ void PERF_TEST::Test_Max(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int min_format_flag = 128;
+  constexpr int rand_data_range = 32;
 
   vector<int> type{CV_32FC2, CV_32SC2, CV_64FC2};
   for (size_t i = 0; i < type.size(); ++i) {
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src1(val, val, type[i]);
       Mat mat_src2(val, val, type[i]);
       Mat mat_dest(val, val, type[i]);
       Mat mat_dest1(val, val, type[i]);
 
-      test.SetDataRange(mat_src1, 32);
-      test.SetDataRange(mat_src2, 32);
-      test.SetDataRange(mat_dest, 32);
+      test.SetDataRange(mat_src1, rand_data_range);
+      test.SetDataRange(mat_src2, rand_data_range);
+      test.SetDataRange(mat_dest, rand_data_range);
 
       aclMat aclmat_src1(val, val, type[i], mat_src2.data, acl_context);
       aclMat aclmat_src2(val, val, type[i], mat_src1.data, acl_context);
@@ -411,21 +429,23 @@ void PERF_TEST::Test_Min(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int min_format_flag = 128;
+  constexpr int rand_data_range = 32;
 
   vector<int> type{CV_32FC3, CV_32SC3, CV_64FC3};
   for (size_t i = 0; i < type.size(); ++i) {
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src1(val, val, type[i]);
       Mat mat_src2(val, val, type[i]);
       Mat mat_dest(val, val, type[i]);
       Mat mat_dest1(val, val, type[i]);
 
-      test.SetDataRange(mat_src1, 32);
-      test.SetDataRange(mat_src2, 32);
-      test.SetDataRange(mat_dest, 32);
+      test.SetDataRange(mat_src1, rand_data_range);
+      test.SetDataRange(mat_src2, rand_data_range);
+      test.SetDataRange(mat_dest, rand_data_range);
 
       aclMat aclmat_src1(val, val, type[i], mat_src2.data, acl_context);
       aclMat aclmat_src2(val, val, type[i], mat_src1.data, acl_context);
diff --git a/acl/test/test_matrices.cpp b/acl/test/test_matrices.cpp
index d1dc595..1358812 100644
--- a/acl/test/test_matrices.cpp
+++ b/acl/test/test_matrices.cpp
@@ -13,9 +13,10 @@ void PERF_TEST::Test_Merge(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int rand_data_range = 32;
-  constexpr int s_val = 1;
+  constexpr int s_val1 = 1, s_val2 = 2, s_val3 = 3;
   constexpr int min_format_flag = 128;
 
   vector<int> srcType{CV_8UC1, CV_32FC1, CV_32SC1};
@@ -23,11 +24,11 @@ void PERF_TEST::Test_Merge(aclCxt *acl_context) {
   vector<int> destType{CV_8UC3, CV_32FC3, CV_32SC3};
   for (size_t i = 0; i < srcType.size(); ++i) {
     test.PrintLog("Perf test : Function: merge()", srcType[i]);
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
-      Mat mat_src1(val, val, srcType[i], Scalar(s_val));
-      Mat mat_src2(val, val, srcType[i], Scalar(s_val+1));
-      Mat mat_src3(val, val, srcType[i], Scalar(s_val+2));
+      Mat mat_src1(val, val, srcType[i], Scalar(s_val1));
+      Mat mat_src2(val, val, srcType[i], Scalar(s_val2));
+      Mat mat_src3(val, val, srcType[i], Scalar(s_val3));
       Mat mat_dest(val, val, destType[i]);
       Mat mat_dest1(val, val, destType[i]);
 
@@ -82,6 +83,7 @@ void PERF_TEST::Test_Transpose(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int rand_data_range = 32;
   constexpr int min_format_flag = 128;
@@ -89,7 +91,7 @@ void PERF_TEST::Test_Transpose(aclCxt *acl_context) {
   vector<int> type{CV_32FC1, CV_32SC1};
   for (size_t i = 0; i < type.size(); ++i) {
     test.PrintLog("Perf test : Function: transpose()", type[i]);
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src(val, val, type[i]);
       Mat mat_dest(val, val, type[i]);
@@ -133,15 +135,17 @@ void PERF_TEST::Test_Split(aclCxt *acl_context) {
   int cycle_index = 10;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int rand_data_range = 32;
   constexpr int min_format_flag = 128;
+  constexpr int index0 = 0, index1 = 1, index2 = 2;
 
   vector<int> srcType{CV_8UC3, CV_32FC3, CV_32SC3};
   vector<int> destType{CV_8UC1, CV_32FC1, CV_32SC1};
   for (size_t i = 0; i < srcType.size(); ++i) {
     test.PrintLog("Perf test : Function: split()", srcType[i]);
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src(val, val, srcType[i]);
       Mat mat_dest1(val, val, destType[i]);
@@ -179,13 +183,13 @@ void PERF_TEST::Test_Split(aclCxt *acl_context) {
       end = static_cast<double>(getTickCount());
       acltime = (end - begin) / getTickFrequency() / (cycle_index - 1);
 
-      (acl_dest.data())[0].download(mat_dest1);
-      (acl_dest.data())[1].download(mat_dest2);
-      (acl_dest.data())[2].download(mat_dest3);
+      (acl_dest.data())[index0].download(mat_dest1);
+      (acl_dest.data())[index1].download(mat_dest2);
+      (acl_dest.data())[index2].download(mat_dest3);
 
-      bool ret = test.Test_Diff((dest.data())[0], mat_dest1);
-      ret &= test.Test_Diff((dest.data())[1], mat_dest2);
-      ret &= test.Test_Diff((dest.data())[2], mat_dest3);
+      bool ret = test.Test_Diff((dest.data())[index0], mat_dest1);
+      ret &= test.Test_Diff((dest.data())[index1], mat_dest2);
+      ret &= test.Test_Diff((dest.data())[index2], mat_dest3);
       ASSERT_TRUE(ret);
       if (val < min_format_flag)
         cout << "Shape: " << val << " x " << val << "\t\t";
@@ -203,6 +207,7 @@ void PERF_TEST::Test_Flip(aclCxt *acl_context) {
   int cycle_index = 100;
   double begin, end, time, acltime;
   Common_Test test;
+  constexpr int base = 2;
   constexpr int start_val = 8;
   constexpr int rand_data_range = 32;
   constexpr int min_format_flag = 128;
@@ -210,7 +215,7 @@ void PERF_TEST::Test_Flip(aclCxt *acl_context) {
   vector<int> type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1};
   for (size_t i = 0; i < type.size(); ++i) {
     test.PrintLog("Perf test : Function: flip()", type[i]);
-    for (val = start_val; val <= valmax; val *= 2) {
+    for (val = start_val; val <= valmax; val *= base) {
       n = cycle_index;
       Mat mat_src(val, val, type[i]);
       Mat mat_dest(val, val, type[i]);