static BlockStmt getNormContinuousVariableDeclaration(final String variableName,
                                                          final NormContinuous normContinuous) {
        final MethodDeclaration methodDeclaration =
                NORMCONTINUOUS_TEMPLATE.getMethodsByName(GETKIEPMMLNORMCONTINUOUS).get(0).clone();
        final BlockStmt toReturn =
                methodDeclaration.getBody().orElseThrow(() -> new KiePMMLException(String.format(MISSING_BODY_TEMPLATE, methodDeclaration)));
        final VariableDeclarator variableDeclarator =
                getVariableDeclarator(toReturn, NORM_CONTINUOUS).orElseThrow(() -> new KiePMMLException(String.format(MISSING_VARIABLE_IN_BODY, NORM_CONTINUOUS, toReturn)));
        variableDeclarator.setName(variableName);
        final ObjectCreationExpr objectCreationExpr = variableDeclarator.getInitializer()
                .orElseThrow(() -> new KiePMMLException(String.format(MISSING_VARIABLE_INITIALIZER_TEMPLATE,
                                                                      NORM_CONTINUOUS, toReturn)))
                .asObjectCreationExpr();

        final StringLiteralExpr nameExpr = new StringLiteralExpr(normContinuous.getField());
        final OUTLIER_TREATMENT_METHOD outlierTreatmentMethod =
                OUTLIER_TREATMENT_METHOD.byName(normContinuous.getOutliers().value());
        final NameExpr outlierTreatmentMethodExpr =
                new NameExpr(OUTLIER_TREATMENT_METHOD.class.getName() + "." + outlierTreatmentMethod.name());

        NodeList<Expression> arguments = new NodeList<>();
        int counter = 0;
        for (LinearNorm linearNorm : normContinuous.getLinearNorms()) {
            arguments.add(getNewKiePMMLLinearNormExpression(linearNorm, "LinearNorm-" + counter));
        }
        final Expression mapMissingToExpr = getExpressionForObject(normContinuous.getMapMissingTo());
        objectCreationExpr.getArguments().set(0, nameExpr);
        objectCreationExpr.getArguments().get(2).asMethodCallExpr().setArguments(arguments);
        objectCreationExpr.getArguments().set(3, outlierTreatmentMethodExpr);
        objectCreationExpr.getArguments().set(4, mapMissingToExpr);
        return toReturn;
    }
@Test
    void getNormContinuousVariableDeclaration() throws IOException {
        String variableName = "variableName";
        NormContinuous normContinuous = getRandomNormContinuous();
        List<LinearNorm> linearNorms = normContinuous.getLinearNorms();

        BlockStmt retrieved =
                org.kie.pmml.compiler.commons.codegenfactories.KiePMMLNormContinuousFactory.getNormContinuousVariableDeclaration(variableName,
                                                                                                                                               normContinuous);
        String outlierString =
                OUTLIER_TREATMENT_METHOD.class.getName() + "." + OUTLIER_TREATMENT_METHOD.byName(normContinuous.getOutliers().value()).name();
        String text = getFileContent(TEST_01_SOURCE);
        Statement expected = JavaParserUtils.parseBlock(String.format(text, variableName,normContinuous.getField(),
                                                                      linearNorms.get(0).getOrig(),
                                                                      linearNorms.get(0).getNorm(),
                                                                      linearNorms.get(1).getOrig(),
                                                                      linearNorms.get(1).getNorm(),
                                                                      linearNorms.get(2).getOrig(),
                                                                      linearNorms.get(2).getNorm(),
                                                                      outlierString, normContinuous.getMapMissingTo()));
        assertThat(JavaParserUtils.equalsNode(expected, retrieved)).isTrue();
        List<Class<?>> imports = Arrays.asList(Arrays.class, Collections.class, KiePMMLLinearNorm.class,
                                               KiePMMLNormContinuous.class, OUTLIER_TREATMENT_METHOD.class);
        commonValidateCompilationWithImports(retrieved, imports);
    }