TestsPrinter: use parametrizedArrayParameters in printFunctionParameters

Use TestsPrinter::parametrizedArrayParameters method in
TestsPrinter::printFunctionParameters and call it for every parameter.
I decided to do it because TestsPrinter::parametrizedArrayParameters
also outputs the function parameters.

This change fix the appearance of two structs in generated tests.
The point of thing is that if we pass some pointer to a struct to
a function:
	bool OKrow(int x, const sudoku *a, int y, int v);
where:
	struct sudoku
	{
    	    unsigned int *a;
    	    unsigned int N;
    	    unsigned int N2;
	};

We have the pointer to the struct and this struct contains a lazy value.

Refs: #475

Author: elenaboldyreva

server/src/printers/TestsPrinter.cpp

@@ -348,7 +348,6 @@ void TestsPrinter::genParametrizedTestCase(const Tests::MethodDescription &metho
     openFiles(methodDescription, testCase);
     parametrizedInitializeGlobalVariables(methodDescription, testCase);
     parametrizedInitializeSymbolicStubs(methodDescription, testCase);
-    parametrizedArrayParameters(methodDescription, testCase);
     printClassObject(methodDescription, testCase);
     printStubVariables(methodDescription, testCase);
     printFunctionParameters(methodDescription, testCase, false);
@@ -453,20 +452,16 @@ void TestsPrinter::printFunctionParameters(const Tests::MethodDescription &metho
                                            const Tests::MethodTestCase &testCase,
                                            bool all) {
     for (auto i = 0; i < testCase.paramValues.size(); i++) {
-        bool containsLazy = !testCase.paramValues[i].lazyValues.empty() &&
-                            !methodDescription.params[i].isChangeable();
-        if (!methodDescription.params[i].type.isFilePointer() &&
-            (all || methodDescription.params[i].type.isLValueReference() || containsLazy)) {
-            Tests::MethodParam param = methodDescription.params[i];
-            auto value = testCase.paramValues[i];
+        parametrizedArrayParameters(methodDescription, testCase, i);
+        const Tests::MethodParam &param = methodDescription.params[i];
+        bool containsLazy = !testCase.paramValues[i].lazyValues.empty() && !param.isChangeable();
+        if (!param.type.isFilePointer() &&
+            (all || param.type.isLValueReference() || param.type.isSimple() && containsLazy)) {
+            Tests::TestCaseParamValue value = testCase.paramValues[i];
             Tests::MethodParam valueParam = getValueParam(param);
-            if (methodDescription.params[i].type.maybeJustPointer()) {
-                valueParam.type = valueParam.type.baseTypeObj();
-            }
             value.name = valueParam.name;
-            verboseParameter(methodDescription, valueParam, value, true);
-            if (param.type.isTwoDimensionalPointer()) {
-                gen2DPointer(param, true);
+            if (param.type.isLValueReference() || param.type.isSimple()) {
+                verboseParameter(methodDescription, valueParam, value, true);
             }
         }
     }
@@ -629,33 +624,37 @@ void TestsPrinter::globalParamsAsserts(const Tests::MethodDescription &methodDes
 }
 
 void TestsPrinter::parametrizedArrayParameters(const Tests::MethodDescription &methodDescription,
-                                               const Tests::MethodTestCase &testCase) {
-    for (auto i = 0; i < testCase.paramValues.size(); i++) {
-        const auto &param = methodDescription.params[i];
-        const auto &value = testCase.paramValues[i];
-        if (types::TypesHandler::isArrayOfPointersToFunction(param.type)) {
-            auto type = getTypedefFunctionPointer(methodDescription.name, param.name, false);
-            std::string stubName = PrinterUtils::getFunctionPointerStubName(
-                methodDescription.getClassTypeName(), methodDescription.name, param.name);
-            strDeclareArrayOfFunctionPointerVar(type, param.name, stubName);
-        } else if (types::TypesHandler::isCStringType(param.type)) {
-            strDeclareArrayVar(param.type, param.name, types::PointerUsage::PARAMETER, value.view->getEntryValue(this), param.alignment);
-        } else if (!param.type.isFilePointer() && (param.type.isObjectPointer() || param.type.isArray())) {
-            auto arrayType = types::TypesHandler::isVoid(param.type.baseTypeObj())
-                ? types::Type::minimalScalarPointerType(param.type.arraysSizes(types::PointerUsage::PARAMETER).size())
-                : param.type;
-            if (param.type.maybeJustPointer()) {
-                strDeclareVar(arrayType.baseType(), param.name, value.view->getEntryValue(this), param.alignment);
-            } else {
-                auto paramName = param.type.isTwoDimensionalPointer() ? param.underscoredName() : param.name;
-                strDeclareArrayVar(arrayType, paramName, types::PointerUsage::PARAMETER,
-                                   value.view->getEntryValue(this), param.alignment, true);
-            }
-        }
-        if (param.type.isTwoDimensionalPointer()) {
-            gen2DPointer(param, true);
+                                               const Tests::MethodTestCase &testCase,
+                                               int param_num) {
+    const auto &param = methodDescription.params[param_num];
+    const auto &value = testCase.paramValues[param_num];
+    if (types::TypesHandler::isArrayOfPointersToFunction(param.type)) {
+        auto type = getTypedefFunctionPointer(methodDescription.name, param.name, false);
+        std::string stubName = PrinterUtils::getFunctionPointerStubName(
+            methodDescription.getClassTypeName(), methodDescription.name, param.name);
+        strDeclareArrayOfFunctionPointerVar(type, param.name, stubName);
+    } else if (types::TypesHandler::isCStringType(param.type)) {
+        strDeclareArrayVar(param.type, param.name, types::PointerUsage::PARAMETER,
+                           value.view->getEntryValue(this), param.alignment);
+    } else if (!param.type.isFilePointer() &&
+               (param.type.isObjectPointer() || param.type.isArray())) {
+        auto arrayType = types::TypesHandler::isVoid(param.type.baseTypeObj())
+                             ? types::Type::minimalScalarPointerType(
+                                   param.type.arraysSizes(types::PointerUsage::PARAMETER).size())
+                             : param.type;
+        if (param.type.maybeJustPointer()) {
+            strDeclareVar(arrayType.baseType(), param.name, value.view->getEntryValue(this),
+                          param.alignment);
+        } else {
+            auto paramName =
+                param.type.isTwoDimensionalPointer() ? param.underscoredName() : param.name;
+            strDeclareArrayVar(arrayType, paramName, types::PointerUsage::PARAMETER,
+                               value.view->getEntryValue(this), param.alignment, true);
         }
     }
+    if (param.type.isTwoDimensionalPointer()) {
+        gen2DPointer(param, true);
+    }
 }
 
 void TestsPrinter::parametrizedAsserts(const Tests::MethodDescription &methodDescription,

server/src/printers/TestsPrinter.h

@@ -85,7 +85,8 @@ namespace printer {
                             const Tests::MethodTestCase &testCase);
 
         void parametrizedArrayParameters(const tests::Tests::MethodDescription &methodDescription,
-                                         const Tests::MethodTestCase &testCase);
+                                         const Tests::MethodTestCase &testCase,
+                                         int param_num);
 
         void parametrizedAsserts(const tests::Tests::MethodDescription &methodDescription,
                                  const Tests::MethodTestCase &testCase,