Example usage for java.text DecimalFormat toPattern

List of usage examples for java.text DecimalFormat toPattern

Introduction

In this page you can find the example usage for java.text DecimalFormat toPattern.

Prototype

public String toPattern() 

Source Link

Document

Synthesizes a pattern string that represents the current state of this Format object.

Usage

From source file:Main.java

public static void main(String[] argv) throws Exception {
    DecimalFormat format = new DecimalFormat();

    System.out.println(format.toPattern());

}

From source file:org.talend.dataprep.util.NumericHelper.java

/**
 * Checks whether <code>str</code> can be parsed by {@link BigDecimalParser} without throwing an exception.
 * @param str The string to be tested, can be <code>null</code> or empty.
 * @return <code>true</code> if string can be parsed by {@link BigDecimalParser}, <code>false</code> otherwise.
 *//*from   w  ww  .j ava2 s . c  o m*/
public static boolean isBigDecimal(String str) {
    if (StringUtils.isEmpty(str)) {
        return false;
    }
    // Check for (nnnn) values (negative values in accounting).
    String strForValidation = StringUtils.remove(str, ' ');
    if (strForValidation.lastIndexOf('(') == 0
            && strForValidation.lastIndexOf(')') == strForValidation.length() - 1) {
        strForValidation = strForValidation.substring(1, strForValidation.length() - 1); // Keep only nnnn
    }

    if (!StringUtils.containsOnly(strForValidation, ALLOWED_NUMERIC_CHARACTERS)
            && !isValid(strForValidation, new BigDecimalValidator())) {
        return false;
    }

    // Support for values that starts with ',' or '.' (like .5 or ,5).
    if (strForValidation.charAt(0) == ',' || strForValidation.charAt(0) == '.') {
        return true;
    }

    // Try custom decimal formats
    DecimalFormat[] supportedFormats = { BigDecimalParser.EU_DECIMAL_PATTERN,
            BigDecimalParser.EU_SCIENTIFIC_DECIMAL_PATTERN, BigDecimalParser.US_DECIMAL_PATTERN,
            BigDecimalParser.US_SCIENTIFIC_DECIMAL_PATTERN };
    for (DecimalFormat supportedFormat : supportedFormats) {
        try {
            if (supportedFormat.parse(strForValidation) != null) {
                return true;
            }
        } catch (ParseException e) {
            LOGGER.debug("Unable to parse '{}' using custom decimal format '{}'.", strForValidation,
                    supportedFormat.toPattern(), e);
        }
    }

    return false;
}

From source file:ca.sqlpower.dao.session.FormatConverter.java

public String convertToSimpleType(Format convertFrom, Object... additionalInfo) {
    if (convertFrom instanceof DecimalFormat) {
        DecimalFormat decimal = (DecimalFormat) convertFrom;
        return DecimalFormat.class.getSimpleName() + DELIMITER + decimal.toPattern();
    } else if (convertFrom instanceof SimpleDateFormat) {
        SimpleDateFormat date = (SimpleDateFormat) convertFrom;
        return SimpleDateFormat.class.getSimpleName() + DELIMITER + date.toPattern();
    } else {//from  ww w.ja va2 s .  co  m
        throw new IllegalStateException("Unknown format to convert from " + convertFrom.getClass());
    }
}

From source file:org.apache.cordova.core.Globalization.java

private JSONObject getCurrencyPattern(JSONArray options) throws GlobalizationError {
    JSONObject obj = new JSONObject();
    try {//  ww w  .  ja  v  a2  s .c om
        //get ISO 4217 currency code
        String code = options.getJSONObject(0).getString(CURRENCYCODE);

        //uses java.text.DecimalFormat to format value
        DecimalFormat fmt = (DecimalFormat) DecimalFormat.getCurrencyInstance(Locale.getDefault());

        //set currency format
        Currency currency = Currency.getInstance(code);
        fmt.setCurrency(currency);

        //return properties
        obj.put("pattern", fmt.toPattern());
        obj.put("code", currency.getCurrencyCode());
        obj.put("fraction", fmt.getMinimumFractionDigits());
        obj.put("rounding", new Integer(0));
        obj.put("decimal", String.valueOf(fmt.getDecimalFormatSymbols().getDecimalSeparator()));
        obj.put("grouping", String.valueOf(fmt.getDecimalFormatSymbols().getGroupingSeparator()));

        return obj;
    } catch (Exception ge) {
        throw new GlobalizationError(GlobalizationError.FORMATTING_ERROR);
    }
}

From source file:org.apache.cordova.globalization.Globalization.java

private JSONObject getCurrencyPattern(JSONArray options) throws GlobalizationError {
    JSONObject obj = new JSONObject();
    try {/*from   www.  j  a  va 2 s  .  c  o m*/
        //get ISO 4217 currency code
        String code = options.getJSONObject(0).getString(CURRENCYCODE);

        //uses java.text.DecimalFormat to format value
        DecimalFormat fmt = (DecimalFormat) DecimalFormat.getCurrencyInstance(Locale.getDefault());

        //set currency format
        Currency currency = Currency.getInstance(code);
        fmt.setCurrency(currency);

        //return properties
        obj.put("pattern", fmt.toPattern());
        obj.put("code", currency.getCurrencyCode());
        obj.put("fraction", fmt.getMinimumFractionDigits());
        obj.put("rounding", Integer.valueOf(0));
        obj.put("decimal", String.valueOf(fmt.getDecimalFormatSymbols().getDecimalSeparator()));
        obj.put("grouping", String.valueOf(fmt.getDecimalFormatSymbols().getGroupingSeparator()));

        return obj;
    } catch (Exception ge) {
        throw new GlobalizationError(GlobalizationError.FORMATTING_ERROR);
    }
}

From source file:org.glom.web.server.ReportGenerator.java

/**
 * @param x//from w w  w.j a va 2 s  . c  o  m
 * @param libglomLayoutItemField
 * @return
 */
private JRDesignTextField createFieldValueElement(final Position pos,
        final LayoutItemField libglomLayoutItemField) {
    final JRDesignTextField textField = new JRDesignTextField();

    // Make sure this field starts at the right of the previous field,
    // because JasperReports uses absolute positioning.
    textField.setY(pos.y);
    textField.setX(pos.x);
    textField.setWidth(width); // No data will be shown without this.

    // This only stretches vertically, but that is better than
    // nothing.
    textField.setStretchWithOverflow(true);
    textField.setHeight(height); // We must specify _some_ height.

    final JRDesignExpression expression = createFieldExpression(libglomLayoutItemField);
    textField.setExpression(expression);

    if (libglomLayoutItemField.getGlomType() == GlomFieldType.TYPE_NUMERIC) {
        // Numeric formatting:
        final Formatting formatting = libglomLayoutItemField.getFormattingUsed();
        final NumericFormat numericFormat = formatting.getNumericFormat();

        final DecimalFormat format = new DecimalFormat();
        format.setMaximumFractionDigits(numericFormat.getDecimalPlaces());
        format.setGroupingUsed(numericFormat.getUseThousandsSeparator());

        // TODO: Use numericFormat.get_currency_symbol(), possibly via format.setCurrency().
        textField.setPattern(format.toPattern());
    } else if (libglomLayoutItemField.getGlomType() == GlomFieldType.TYPE_DATE) {
        // Date formatting
        // TODO: Use a 4-digit-year short form, somehow.
        try // We use a try block because getDateInstance() is not guaranteed to return a SimpleDateFormat.
        {
            final SimpleDateFormat format = (SimpleDateFormat) DateFormat.getDateInstance(DateFormat.SHORT,
                    Locale.ROOT);

            textField.setPattern(format.toPattern());
        } catch (final Exception ex) {
            Log.info("ReportGenerator: The cast of SimpleDateFormat failed.");
        }
    } else if (libglomLayoutItemField.getGlomType() == GlomFieldType.TYPE_TIME) {
        // Time formatting
        try // We use a try block because getDateInstance() is not guaranteed to return a SimpleDateFormat.
        {
            final SimpleDateFormat format = (SimpleDateFormat) DateFormat.getTimeInstance(DateFormat.SHORT,
                    Locale.ROOT);

            textField.setPattern(format.toPattern());
        } catch (final Exception ex) {
            Log.info("ReportGenerator: The cast of SimpleDateFormat failed.");
        }
    }

    return textField;
}

From source file:ca.sqlpower.wabit.dao.WorkspaceXMLDAO.java

/**
 * This saves a layout. This will not close the print writer passed into the constructor.
 * If this save method is used to export the query cache somewhere then close should be 
 * called on it to flush the print writer and close it.
 *//* w  w w  .  ja v  a 2s . co m*/
private void saveLayout(Layout layout) {
    xml.print(out, "<layout");
    printCommonAttributes(layout);
    printAttribute("zoom", layout.getZoomLevel());
    printAttribute("template", (layout instanceof Template));
    xml.niprintln(out, ">");
    xml.indent++;

    Page page = layout.getPage();
    xml.print(out, "<layout-page");
    printCommonAttributes(page);
    printAttribute("height", page.getHeight());
    printAttribute("width", page.getWidth());
    printAttribute("orientation", page.getOrientation().name());
    xml.niprintln(out, ">");
    xml.indent++;
    saveFont(page.getDefaultFont());

    if (layout instanceof Report) {
        for (Selector selector : ((Report) layout).getSelectors()) {
            saveSelector(selector);
        }
    }

    for (WabitObject object : page.getChildren()) {
        if (object instanceof ContentBox) {
            ContentBox box = (ContentBox) object;
            xml.print(out, "<content-box");
            printCommonAttributes(box);
            printAttribute("width", box.getWidth());
            printAttribute("height", box.getHeight());
            printAttribute("xpos", box.getX());
            printAttribute("ypos", box.getY());
            xml.niprintln(out, ">");
            xml.indent++;
            saveFont(box.getFont());

            // Save ContentBox selectors.
            for (Selector selector : box.getChildren(Selector.class)) {
                saveSelector(selector);
            }

            if (box.getContentRenderer() != null) {
                if (box.getContentRenderer() instanceof WabitLabel) {
                    WabitLabel label = (WabitLabel) box.getContentRenderer();
                    xml.print(out, "<content-label");
                    printCommonAttributes(label);
                    printAttribute("horizontal-align", label.getHorizontalAlignment().name());
                    printAttribute("vertical-align", label.getVerticalAlignment().name());
                    if (label.getBackgroundColour() != null) {
                        printAttribute("bg-colour", label.getBackgroundColour().getRGB());
                    }
                    xml.niprintln(out, ">");
                    xml.indent++;
                    xml.print(out, "<text>");
                    xml.niprint(out, SQLPowerUtils.escapeXML(label.getText()));
                    xml.niprintln(out, "</text>");
                    saveFont(label.getFont());
                    xml.indent--;
                    xml.println(out, "</content-label>");
                } else if (box.getContentRenderer() instanceof ResultSetRenderer) {
                    ResultSetRenderer rsRenderer = (ResultSetRenderer) box.getContentRenderer();
                    xml.print(out, "<content-result-set");
                    printCommonAttributes(rsRenderer);
                    printAttribute("query-id", rsRenderer.getContent().getUUID());
                    printAttribute("null-string", rsRenderer.getNullString());
                    printAttribute("border", rsRenderer.getBorderType().name());
                    printAttribute("grand-totals", rsRenderer.isPrintingGrandTotals());
                    if (rsRenderer.getBackgroundColour() != null) {
                        printAttribute("bg-colour", rsRenderer.getBackgroundColour().getRGB());
                    }
                    printAttribute("header-colour", rsRenderer.getHeaderColour().getRGB());
                    printAttribute("data-colour", rsRenderer.getDataColour().getRGB());
                    xml.niprintln(out, ">");
                    xml.indent++;
                    saveFont(rsRenderer.getHeaderFont(), "header-font");
                    saveFont(rsRenderer.getBodyFont(), "body-font");
                    for (WabitObject rendererChild : rsRenderer.getChildren()) {
                        ColumnInfo ci = (ColumnInfo) rendererChild;
                        xml.print(out, "<column-info");
                        printCommonAttributes(ci);
                        printAttribute("width", ci.getWidth());
                        if (ci.getColumnInfoItem() != null) {
                            printAttribute("column-info-item-id", ci.getColumnInfoItem().getUUID());
                        }
                        printAttribute("column-alias", ci.getColumnAlias());
                        printAttribute("horizontal-align", ci.getHorizontalAlignment().name());
                        printAttribute("data-type", ci.getDataType().name());
                        printAttribute("group-or-break", ci.getWillGroupOrBreak().name());
                        printAttribute("will-subtotal", Boolean.toString(ci.getWillSubtotal()));
                        xml.niprintln(out, ">");
                        xml.indent++;
                        if (ci.getFormat() instanceof SimpleDateFormat) {
                            xml.print(out, "<date-format");
                            SimpleDateFormat dateFormat = (SimpleDateFormat) ci.getFormat();
                            printAttribute("format", dateFormat.toPattern());
                            xml.niprintln(out, "/>");
                        } else if (ci.getFormat() instanceof DecimalFormat) {
                            xml.print(out, "<decimal-format");
                            DecimalFormat decimalFormat = (DecimalFormat) ci.getFormat();
                            printAttribute("format", decimalFormat.toPattern());
                            xml.niprintln(out, "/>");
                        } else if (ci.getFormat() == null) {
                            // This is a default format
                        } else {
                            throw new ClassCastException("Cannot cast format of type "
                                    + ci.getFormat().getClass() + " to a known format type when saving.");
                        }
                        xml.indent--;
                        xml.println(out, "</column-info>");
                    }
                    xml.indent--;
                    xml.println(out, "</content-result-set>");
                } else if (box.getContentRenderer() instanceof ImageRenderer) {
                    ImageRenderer imgRenderer = (ImageRenderer) box.getContentRenderer();
                    xml.print(out, "<image-renderer");
                    printCommonAttributes(imgRenderer);
                    if (imgRenderer.getImage() != null) {
                        printAttribute("wabit-image-uuid", imgRenderer.getImage().getUUID());
                    }
                    printAttribute("preserving-aspect-ratio", imgRenderer.isPreservingAspectRatio());
                    printAttribute("h-align", imgRenderer.getHAlign().name());
                    printAttribute("v-align", imgRenderer.getVAlign().name());
                    xml.niprint(out, ">");
                    out.println("</image-renderer>");

                } else if (box.getContentRenderer() instanceof ChartRenderer) {
                    ChartRenderer chartRenderer = (ChartRenderer) box.getContentRenderer();
                    xml.print(out, "<chart-renderer");
                    printCommonAttributes(chartRenderer);
                    printAttribute("chart-uuid", chartRenderer.getContent().getUUID());
                    xml.println(out, " />");

                } else if (box.getContentRenderer() instanceof CellSetRenderer) {
                    CellSetRenderer renderer = (CellSetRenderer) box.getContentRenderer();
                    xml.print(out, "<cell-set-renderer");
                    printCommonAttributes(renderer);
                    printAttribute("olap-query-uuid", renderer.getContent().getUUID());
                    printAttribute("body-alignment", renderer.getBodyAlignment().toString());
                    if (renderer.getBodyFormat() != null) {
                        printAttribute("body-format-pattern", renderer.getBodyFormat().toPattern());
                    }
                    xml.println(out, ">");
                    xml.indent++;

                    saveFont(renderer.getHeaderFont(), "olap-header-font");
                    saveFont(renderer.getBodyFont(), "olap-body-font");

                    this.saveOlapQuery(renderer.getModifiedOlapQuery());

                    xml.indent--;
                    xml.println(out, "</cell-set-renderer>");

                } else {
                    throw new ClassCastException(
                            "Cannot save a content renderer of class " + box.getContentRenderer().getClass());
                }
            }

            xml.indent--;
            xml.println(out, "</content-box>");
        } else if (object instanceof Guide) {
            Guide guide = (Guide) object;
            xml.print(out, "<guide");
            printCommonAttributes(guide);
            printAttribute("axis", guide.getAxis().name());
            printAttribute("offset", guide.getOffset());
            xml.niprintln(out, "/>");
        } else {
            throw new ClassCastException("Cannot save page element of type " + object.getClass());
        }
    }

    xml.indent--;
    xml.println(out, "</layout-page>");

    xml.indent--;
    xml.println(out, "</layout>");
}

From source file:org.apache.cordova.core.Globalization.java

private JSONObject getNumberPattern(JSONArray options) throws GlobalizationError {
    JSONObject obj = new JSONObject();
    try {//from  www. j  a v a 2s .  c  o  m
        //uses java.text.DecimalFormat to format value
        DecimalFormat fmt = (DecimalFormat) DecimalFormat.getInstance(Locale.getDefault()); //default format
        String symbol = String.valueOf(fmt.getDecimalFormatSymbols().getDecimalSeparator());
        //get Date value + options (if available)
        if (options.getJSONObject(0).length() > 0) {
            //options were included
            if (!((JSONObject) options.getJSONObject(0).get(OPTIONS)).isNull(TYPE)) {
                String fmtOpt = (String) ((JSONObject) options.getJSONObject(0).get(OPTIONS)).get(TYPE);
                if (fmtOpt.equalsIgnoreCase(CURRENCY)) {
                    fmt = (DecimalFormat) DecimalFormat.getCurrencyInstance(Locale.getDefault());
                    symbol = fmt.getDecimalFormatSymbols().getCurrencySymbol();
                } else if (fmtOpt.equalsIgnoreCase(PERCENT)) {
                    fmt = (DecimalFormat) DecimalFormat.getPercentInstance(Locale.getDefault());
                    symbol = String.valueOf(fmt.getDecimalFormatSymbols().getPercent());
                }
            }
        }

        //return properties
        obj.put("pattern", fmt.toPattern());
        obj.put("symbol", symbol);
        obj.put("fraction", fmt.getMinimumFractionDigits());
        obj.put("rounding", new Integer(0));
        obj.put("positive", fmt.getPositivePrefix());
        obj.put("negative", fmt.getNegativePrefix());
        obj.put("decimal", String.valueOf(fmt.getDecimalFormatSymbols().getDecimalSeparator()));
        obj.put("grouping", String.valueOf(fmt.getDecimalFormatSymbols().getGroupingSeparator()));

        return obj;
    } catch (Exception ge) {
        throw new GlobalizationError(GlobalizationError.PATTERN_ERROR);
    }
}

From source file:org.apache.cordova.globalization.Globalization.java

private JSONObject getNumberPattern(JSONArray options) throws GlobalizationError {
    JSONObject obj = new JSONObject();
    try {//from  ww  w .  j a  v a2  s  .c  om
        //uses java.text.DecimalFormat to format value
        DecimalFormat fmt = (DecimalFormat) DecimalFormat.getInstance(Locale.getDefault()); //default format
        String symbol = String.valueOf(fmt.getDecimalFormatSymbols().getDecimalSeparator());
        //get Date value + options (if available)
        if (options.getJSONObject(0).length() > 0) {
            //options were included
            if (!((JSONObject) options.getJSONObject(0).get(OPTIONS)).isNull(TYPE)) {
                String fmtOpt = (String) ((JSONObject) options.getJSONObject(0).get(OPTIONS)).get(TYPE);
                if (fmtOpt.equalsIgnoreCase(CURRENCY)) {
                    fmt = (DecimalFormat) DecimalFormat.getCurrencyInstance(Locale.getDefault());
                    symbol = fmt.getDecimalFormatSymbols().getCurrencySymbol();
                } else if (fmtOpt.equalsIgnoreCase(PERCENT)) {
                    fmt = (DecimalFormat) DecimalFormat.getPercentInstance(Locale.getDefault());
                    symbol = String.valueOf(fmt.getDecimalFormatSymbols().getPercent());
                }
            }
        }

        //return properties
        obj.put("pattern", fmt.toPattern());
        obj.put("symbol", symbol);
        obj.put("fraction", fmt.getMinimumFractionDigits());
        obj.put("rounding", Integer.valueOf(0));
        obj.put("positive", fmt.getPositivePrefix());
        obj.put("negative", fmt.getNegativePrefix());
        obj.put("decimal", String.valueOf(fmt.getDecimalFormatSymbols().getDecimalSeparator()));
        obj.put("grouping", String.valueOf(fmt.getDecimalFormatSymbols().getGroupingSeparator()));

        return obj;
    } catch (Exception ge) {
        throw new GlobalizationError(GlobalizationError.PATTERN_ERROR);
    }
}

From source file:org.structr.schema.action.ActionContextTest.java

public void testVariableReplacement() {

    final Date now = new Date();
    final SimpleDateFormat format1 = new SimpleDateFormat("dd.MM.yyyy");
    final SimpleDateFormat format2 = new SimpleDateFormat("HH:mm:ss");
    final SimpleDateFormat format3 = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
    final String nowString1 = format1.format(now);
    final String nowString2 = format2.format(now);
    final String nowString3 = format3.format(now);
    final DecimalFormat numberFormat1 = new DecimalFormat("###0.00",
            DecimalFormatSymbols.getInstance(Locale.ENGLISH));
    final DecimalFormat numberFormat2 = new DecimalFormat("0000.0000",
            DecimalFormatSymbols.getInstance(Locale.GERMAN));
    final DecimalFormat numberFormat3 = new DecimalFormat("####",
            DecimalFormatSymbols.getInstance(Locale.SIMPLIFIED_CHINESE));
    final String numberString1 = numberFormat1.format(2.234);
    final String numberString2 = numberFormat2.format(2.234);
    final String numberString3 = numberFormat3.format(2.234);
    MailTemplate template = null;/* w  w  w . j  av  a2s  .  c o m*/
    MailTemplate template2 = null;
    TestOne testOne = null;
    TestTwo testTwo = null;
    TestThree testThree = null;
    TestFour testFour = null;
    List<TestSix> testSixs = null;
    int index = 0;
    final Object nullValue1 = null;
    final Object nullValue2 = null;
    final String nullString1 = null;
    final String nullString2 = null;
    final String emptyString1 = "";
    final String emptyString2 = "";

    try (final Tx tx = app.tx()) {

        testOne = createTestNode(TestOne.class);
        testTwo = createTestNode(TestTwo.class);
        testThree = createTestNode(TestThree.class);
        testFour = createTestNode(TestFour.class);
        testSixs = createTestNodes(TestSix.class, 20);

        // set string array on test four
        testFour.setProperty(TestFour.stringArrayProperty, new String[] { "one", "two", "three", "four" });

        for (final TestSix testSix : testSixs) {

            testSix.setProperty(TestSix.name, "TestSix" + StringUtils.leftPad(Integer.toString(index), 2, "0"));
            testSix.setProperty(TestSix.index, index);

            index++;
        }

        // create mail template
        template = createTestNode(MailTemplate.class);
        template.setProperty(MailTemplate.name, "TEST");
        template.setProperty(MailTemplate.locale, "en_EN");
        template.setProperty(MailTemplate.text, "This is a template for ${this.name}");

        // create mail template
        template2 = createTestNode(MailTemplate.class);
        template2.setProperty(MailTemplate.name, "TEST2");
        template2.setProperty(MailTemplate.locale, "en_EN");
        template2.setProperty(MailTemplate.text, "${this.aDouble}");

        // check existance
        assertNotNull(testOne);

        testOne.setProperty(TestOne.name, "A-nice-little-name-for-my-test-object");
        testOne.setProperty(TestOne.anInt, 1);
        testOne.setProperty(TestOne.aString, "String");
        testOne.setProperty(TestOne.anotherString, "{\n\ttest: test,\n\tnum: 3\n}");
        testOne.setProperty(TestOne.replaceString, "${this.name}");
        testOne.setProperty(TestOne.aLong, 235242522552L);
        testOne.setProperty(TestOne.aDouble, 2.234);
        testOne.setProperty(TestOne.aDate, now);
        testOne.setProperty(TestOne.anEnum, TestOne.Status.One);
        testOne.setProperty(TestOne.aBoolean, true);
        testOne.setProperty(TestOne.testTwo, testTwo);
        testOne.setProperty(TestOne.testThree, testThree);
        testOne.setProperty(TestOne.testFour, testFour);
        testOne.setProperty(TestOne.manyToManyTestSixs, testSixs);
        testOne.setProperty(TestOne.cleanTestString,
                "a<b>c.d'e?f(g)h{i}j[k]l+m/no\\p\\q|r's!t,u-v_w`x-y-zABCDEFGH");
        testOne.setProperty(TestOne.stringWithQuotes, "A'B\"C");

        testTwo.setProperty(TestTwo.name, "testTwo_name");
        testThree.setProperty(TestThree.name, "testThree_name");

        tx.success();

    } catch (FrameworkException fex) {

        fex.printStackTrace();

        fail("Unexpected exception");
    }

    try (final Tx tx = app.tx()) {

        final ActionContext ctx = new ActionContext(securityContext, null);

        // test quotes etc.
        assertEquals("Invalid result for quoted template expression", "''",
                Scripting.replaceVariables(ctx, testOne, "'${err}'"));
        assertEquals("Invalid result for quoted template expression", " '' ",
                Scripting.replaceVariables(ctx, testOne, " '${err}' "));
        assertEquals("Invalid result for quoted template expression", "\"\"",
                Scripting.replaceVariables(ctx, testOne, "\"${this.error}\""));
        assertEquals("Invalid result for quoted template expression", "''''''",
                Scripting.replaceVariables(ctx, testOne, "'''${this.this.this.error}'''"));
        assertEquals("Invalid result for quoted template expression", "''",
                Scripting.replaceVariables(ctx, testOne, "'${parent.error}'"));
        assertEquals("Invalid result for quoted template expression", "''",
                Scripting.replaceVariables(ctx, testOne, "'${this.owner}'"));
        assertEquals("Invalid result for quoted template expression", "''",
                Scripting.replaceVariables(ctx, testOne, "'${this.alwaysNull}'"));
        assertEquals("Invalid result for quoted template expression", "''",
                Scripting.replaceVariables(ctx, testOne, "'${parent.owner}'"));

        // test for "empty" return value
        assertEquals("Invalid expressions should yield an empty result", "",
                Scripting.replaceVariables(ctx, testOne, "${err}"));
        assertEquals("Invalid expressions should yield an empty result", "",
                Scripting.replaceVariables(ctx, testOne, "${this.error}"));
        assertEquals("Invalid expressions should yield an empty result", "",
                Scripting.replaceVariables(ctx, testOne, "${this.this.this.error}"));
        assertEquals("Invalid expressions should yield an empty result", "",
                Scripting.replaceVariables(ctx, testOne, "${parent.error}"));
        assertEquals("Invalid expressions should yield an empty result", "",
                Scripting.replaceVariables(ctx, testOne, "${this.owner}"));
        assertEquals("Invalid expressions should yield an empty result", "",
                Scripting.replaceVariables(ctx, testOne, "${this.alwaysNull}"));
        assertEquals("Invalid expressions should yield an empty result", "",
                Scripting.replaceVariables(ctx, testOne, "${parent.owner}"));

        assertEquals("${this} should evaluate to the current node", testOne.toString(),
                Scripting.replaceVariables(ctx, testOne, "${this}"));
        //assertEquals("${parent} should evaluate to the context parent node", testOne.toString(), Scripting.replaceVariables(ctx, testOne, "${parent}"));

        assertEquals("${this} should evaluate to the current node", testTwo.toString(),
                Scripting.replaceVariables(ctx, testTwo, "${this}"));
        //assertEquals("${parent} should evaluate to the context parent node", testOne.toString(), Scripting.replaceVariables(ctx, testOne, "${parent}"));

        assertEquals("Invalid variable reference", testTwo.toString(),
                Scripting.replaceVariables(ctx, testOne, "${this.testTwo}"));
        assertEquals("Invalid variable reference", testThree.toString(),
                Scripting.replaceVariables(ctx, testOne, "${this.testThree}"));
        assertEquals("Invalid variable reference", testFour.toString(),
                Scripting.replaceVariables(ctx, testOne, "${this.testFour}"));

        assertEquals("Invalid variable reference", testTwo.getUuid(),
                Scripting.replaceVariables(ctx, testOne, "${this.testTwo.id}"));
        assertEquals("Invalid variable reference", testThree.getUuid(),
                Scripting.replaceVariables(ctx, testOne, "${this.testThree.id}"));
        assertEquals("Invalid variable reference", testFour.getUuid(),
                Scripting.replaceVariables(ctx, testOne, "${this.testFour.id}"));

        assertEquals("Invalid size result", "20",
                Scripting.replaceVariables(ctx, testOne, "${this.manyToManyTestSixs.size}"));

        try {

            Scripting.replaceVariables(ctx, testOne, "${(this.alwaysNull.size}");
            fail("A mismatched opening bracket should throw an exception.");

        } catch (FrameworkException fex) {
            assertEquals("Invalid expression: mismatched closing bracket after this.alwaysNull.size",
                    fex.getMessage());
        }

        assertEquals("Invalid size result", "",
                Scripting.replaceVariables(ctx, testOne, "${this.alwaysNull.size}"));

        assertEquals("Invalid variable reference", "1",
                Scripting.replaceVariables(ctx, testOne, "${this.anInt}"));
        assertEquals("Invalid variable reference", "String",
                Scripting.replaceVariables(ctx, testOne, "${this.aString}"));
        assertEquals("Invalid variable reference", "235242522552",
                Scripting.replaceVariables(ctx, testOne, "${this.aLong}"));
        assertEquals("Invalid variable reference", "2.234",
                Scripting.replaceVariables(ctx, testOne, "${this.aDouble}"));

        // test with property
        assertEquals("Invalid md5() result", "27118326006d3829667a400ad23d5d98",
                Scripting.replaceVariables(ctx, testOne, "${md5(this.aString)}"));
        assertEquals("Invalid upper() result", "27118326006D3829667A400AD23D5D98",
                Scripting.replaceVariables(ctx, testOne, "${upper(md5(this.aString))}"));
        assertEquals("Invalid upper(lower() result", "27118326006D3829667A400AD23D5D98",
                Scripting.replaceVariables(ctx, testOne, "${upper(lower(upper(md5(this.aString))))}"));

        assertEquals("Invalid md5() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${md5(this.alwaysNull)}"));
        assertEquals("Invalid upper() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${upper(this.alwaysNull)}"));
        assertEquals("Invalid lower() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${lower(this.alwaysNull)}"));

        // test literal value as well
        assertEquals("Invalid md5() result", "cc03e747a6afbbcbf8be7668acfebee5",
                Scripting.replaceVariables(ctx, testOne, "${md5(\"test123\")}"));

        assertEquals("Invalid lower() result", "string",
                Scripting.replaceVariables(ctx, testOne, "${lower(this.aString)}"));
        assertEquals("Invalid upper() result", "STRING",
                Scripting.replaceVariables(ctx, testOne, "${upper(this.aString)}"));

        // merge
        assertEquals("Invalid merge() result", "[one, two, three]",
                Scripting.replaceVariables(ctx, testOne, "${merge('one', 'two', 'three')}"));
        assertEquals("Invalid merge() result", "[one, two, three, two, one, two, three]",
                Scripting.replaceVariables(ctx, testOne,
                        "${merge(merge('one', 'two', 'three'), 'two', merge('one', 'two', 'three'))}"));
        assertEquals("Invalid merge() result", "[1, 2, 3, 4, 5, 6, 7, 8]", Scripting.replaceVariables(ctx,
                testOne, "${merge(merge('1', '2', '3'), merge('4', '5', merge('6', '7', '8')))}"));
        assertEquals("Invalid merge() result", "[1, 2, 3, 4, 5, 6, 1, 2, 3, 8]", Scripting.replaceVariables(ctx,
                testOne,
                "${ ( store('list', merge('1', '2', '3')), merge(retrieve('list'), merge('4', '5', merge('6', retrieve('list'), '8'))) )}"));

        // merge_unique
        assertEquals("Invalid merge_unique() result", "[one, two, three]",
                Scripting.replaceVariables(ctx, testOne, "${merge_unique('one', 'two', 'three', 'two')}"));
        assertEquals("Invalid merge_unique() result", "[one, two, three]", Scripting.replaceVariables(ctx,
                testOne,
                "${merge_unique(merge_unique('one', 'two', 'three'), 'two', merge_unique('one', 'two', 'three'))}"));
        assertEquals("Invalid merge_unique() result", "[1, 2, 3, 4, 5, 6, 7, 8]", Scripting.replaceVariables(
                ctx, testOne,
                "${merge_unique(merge_unique('1', '2', '3'), merge_unique('4', '5', merge_unique('6', '7', '8')))}"));
        assertEquals("Invalid merge_unique() result", "[1, 2, 3, 4, 5, 6, 8]", Scripting.replaceVariables(ctx,
                testOne,
                "${ ( store('list', merge_unique('1', '2', '3')), merge_unique(retrieve('list'), merge_unique('4', '5', merge_unique('6', retrieve('list'), '8'))) )}"));

        // complement
        assertEquals("Invalid complement() result", "[]", Scripting.replaceVariables(ctx, testOne,
                "${complement(merge('one', 'two', 'three'), 'one', merge('two', 'three', 'four'))}"));
        assertEquals("Invalid complement() result", "[two]", Scripting.replaceVariables(ctx, testOne,
                "${complement(merge('one', 'two', 'three'), merge('one', 'four', 'three'))}"));

        // join
        assertEquals("Invalid join() result", "one,two,three",
                Scripting.replaceVariables(ctx, testOne, "${join(merge(\"one\", \"two\", \"three\"), \",\")}"));

        // concat
        assertEquals("Invalid concat() result", "onetwothree",
                Scripting.replaceVariables(ctx, testOne, "${concat(\"one\", \"two\", \"three\")}"));
        assertEquals("Invalid concat() result", "oneStringthree",
                Scripting.replaceVariables(ctx, testOne, "${concat(\"one\", this.aString, \"three\")}"));
        assertEquals("Invalid concat() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${concat(this.alwaysNull, this.alwaysNull)}"));

        // split
        assertEquals("Invalid split() result", "onetwothree",
                Scripting.replaceVariables(ctx, testOne, "${concat(split(\"one,two,three\"))}"));
        assertEquals("Invalid split() result", "onetwothree",
                Scripting.replaceVariables(ctx, testOne, "${concat(split(\"one;two;three\"))}"));
        assertEquals("Invalid split() result", "onetwothree",
                Scripting.replaceVariables(ctx, testOne, "${concat(split(\"one;two;three\", \";\"))}"));
        assertEquals("Invalid split() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${split(this.alwaysNull)}"));

        // abbr
        assertEquals("Invalid abbr() result", "oneStringt", Scripting.replaceVariables(ctx, testOne,
                "${abbr(concat(\"one\", this.aString, \"three\"), 10)}"));
        assertEquals("Invalid abbr() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${abbr(this.alwaysNull, 10)}"));

        // capitalize..
        assertEquals("Invalid capitalize() result", "One_two_three", Scripting.replaceVariables(ctx, testOne,
                "${capitalize(concat(\"one_\", \"two_\", \"three\"))}"));
        assertEquals("Invalid capitalize() result", "One_Stringthree", Scripting.replaceVariables(ctx, testOne,
                "${capitalize(concat(\"one_\", this.aString, \"three\"))}"));
        assertEquals("Invalid capitalize() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${capitalize(this.alwaysNull)}"));

        // titleize
        assertEquals("Invalid titleize() result", "One Two Three", Scripting.replaceVariables(ctx, testOne,
                "${titleize(concat(\"one_\", \"two_\", \"three\"), \"_\")}"));
        assertEquals("Invalid titleize() result", "One Stringthree", Scripting.replaceVariables(ctx, testOne,
                "${titleize(concat(\"one_\", this.aString, \"three\"), \"_\")}"));
        assertEquals("Invalid titleize() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${titleize(this.alwaysNull)}"));

        // num (explicit number conversion)
        assertEquals("Invalid num() result", "2.234",
                Scripting.replaceVariables(ctx, testOne, "${num(2.234)}"));
        assertEquals("Invalid num() result", "2.234",
                Scripting.replaceVariables(ctx, testOne, "${num(this.aDouble)}"));
        assertEquals("Invalid num() result", "1.0",
                Scripting.replaceVariables(ctx, testOne, "${num(this.anInt)}"));
        assertEquals("Invalid num() result", "", Scripting.replaceVariables(ctx, testOne, "${num(\"abc\")}"));
        assertEquals("Invalid num() result", "",
                Scripting.replaceVariables(ctx, testOne, "${num(this.aString)}"));
        assertEquals("Invalid num() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${num(this.alwaysNull)}"));

        // index_of
        assertEquals("Invalid index_of() result", "19",
                Scripting.replaceVariables(ctx, testOne, "${index_of(this.name, 'for')}"));
        assertEquals("Invalid index_of() result", "-1",
                Scripting.replaceVariables(ctx, testOne, "${index_of(this.name, 'entity')}"));
        assertEquals("Invalid index_of() result", "19", Scripting.replaceVariables(ctx, testOne,
                "${index_of('a-nice-little-name-for-my-test-object', 'for')}"));
        assertEquals("Invalid index_of() result", "-1", Scripting.replaceVariables(ctx, testOne,
                "${index_of('a-nice-little-name-for-my-test-object', 'entity')}"));

        // contains
        assertEquals("Invalid contains() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${contains(this.name, 'for')}"));
        assertEquals("Invalid contains() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${contains(this.name, 'entity')}"));
        assertEquals("Invalid contains() result", "true", Scripting.replaceVariables(ctx, testOne,
                "${contains('a-nice-little-name-for-my-test-object', 'for')}"));
        assertEquals("Invalid contains() result", "false", Scripting.replaceVariables(ctx, testOne,
                "${contains('a-nice-little-name-for-my-test-object', 'entity')}"));

        // contains with collection / entity
        assertEquals("Invalid contains() result", "true", Scripting.replaceVariables(ctx, testOne,
                "${contains(this.manyToManyTestSixs, first(find('TestSix')))}"));
        assertEquals("Invalid contains() result", "false", Scripting.replaceVariables(ctx, testOne,
                "${contains(this.manyToManyTestSixs, first(find('TestFive')))}"));

        // substring
        assertEquals("Invalid substring() result", "for",
                Scripting.replaceVariables(ctx, testOne, "${substring(this.name, 19, 3)}"));
        assertEquals("Invalid substring() result", "",
                Scripting.replaceVariables(ctx, testOne, "${substring(this.name, -1, -1)}"));
        assertEquals("Invalid substring() result", "",
                Scripting.replaceVariables(ctx, testOne, "${substring(this.name, 100, -1)}"));
        assertEquals("Invalid substring() result", "",
                Scripting.replaceVariables(ctx, testOne, "${substring(this.name, 5, -2)}"));
        assertEquals("Invalid substring() result", "for", Scripting.replaceVariables(ctx, testOne,
                "${substring('a-nice-little-name-for-my-test-object', 19, 3)}"));
        assertEquals("Invalid substring() result", "ice-little-name-for-my-test-object", Scripting
                .replaceVariables(ctx, testOne, "${substring('a-nice-little-name-for-my-test-object', 3)}"));
        assertEquals("Invalid substring() result", "ice", Scripting.replaceVariables(ctx, testOne,
                "${substring('a-nice-little-name-for-my-test-object', 3, 3)}"));
        assertEquals("Invalid substring() result", "", Scripting.replaceVariables(ctx, testOne,
                "${substring('a-nice-little-name-for-my-test-object', -1, -1)}"));
        assertEquals("Invalid substring() result", "", Scripting.replaceVariables(ctx, testOne,
                "${substring('a-nice-little-name-for-my-test-object', 100, -1)}"));
        assertEquals("Invalid substring() result", "", Scripting.replaceVariables(ctx, testOne,
                "${substring('a-nice-little-name-for-my-test-object', 5, -2)}"));

        // length
        assertEquals("Invalid length() result", "37",
                Scripting.replaceVariables(ctx, testOne, "${length(this.name)}"));
        assertEquals("Invalid length() result", "37",
                Scripting.replaceVariables(ctx, testOne, "${length('a-nice-little-name-for-my-test-object')}"));
        assertEquals("Invalid length() result", "4",
                Scripting.replaceVariables(ctx, testOne, "${length('test')}"));
        assertEquals("Invalid length() result", "",
                Scripting.replaceVariables(ctx, testOne, "${length(this.alwaysNull)}"));

        // clean
        assertEquals("Invalid clean() result", "abcd-efghijkl-m-n-o-p-q-r-stu-v-w-x-y-zoauabcdefgh",
                Scripting.replaceVariables(ctx, testOne, "${clean(this.cleanTestString)}"));
        assertEquals("Invalid clean() result", "abcd-efghijkl-m-n-o-p-q-r-stu-v-w-x-y-zoauabcdefgh",
                Scripting.replaceVariables(ctx, testOne, "${clean(get(this, \"cleanTestString\"))}"));
        assertEquals("Invalid clean() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${clean(this.alwaysNull)}"));

        // urlencode
        assertEquals("Invalid urlencode() result",
                "a%3Cb%3Ec.d%27e%3Ff%28g%29h%7Bi%7Dj%5Bk%5Dl%2Bm%2Fn%E2%80%93o%5Cp%5Cq%7Cr%27s%21t%2Cu-v_w%60x-y-z%C3%B6%C3%A4%C3%BC%C3%9FABCDEFGH",
                Scripting.replaceVariables(ctx, testOne, "${urlencode(this.cleanTestString)}"));
        assertEquals("Invalid urlencode() result",
                "a%3Cb%3Ec.d%27e%3Ff%28g%29h%7Bi%7Dj%5Bk%5Dl%2Bm%2Fn%E2%80%93o%5Cp%5Cq%7Cr%27s%21t%2Cu-v_w%60x-y-z%C3%B6%C3%A4%C3%BC%C3%9FABCDEFGH",
                Scripting.replaceVariables(ctx, testOne, "${urlencode(get(this, \"cleanTestString\"))}"));
        assertEquals("Invalid urlencode() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${urlencode(this.alwaysNull)}"));

        // escape_javascript
        assertEquals("Invalid escape_javascript() result", "A\\'B\\\"C",
                Scripting.replaceVariables(ctx, testOne, "${escape_javascript(this.stringWithQuotes)}"));
        assertEquals("Invalid escape_javascript() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${escape_javascript(this.alwaysNull)}"));

        // escape_json
        assertEquals("Invalid escape_json() result", "A'B\\\"C",
                Scripting.replaceVariables(ctx, testOne, "${escape_json(this.stringWithQuotes)}"));
        assertEquals("Invalid escape_json() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${escape_json(this.alwaysNull)}"));

        // if etc.
        assertEquals("Invalid if() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(\"true\", \"true\", \"false\")}"));
        assertEquals("Invalid if() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(\"false\", \"true\", \"false\")}"));

        // empty
        assertEquals("Invalid empty() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${empty(\"\")}"));
        assertEquals("Invalid empty() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${empty(\" \")}"));
        assertEquals("Invalid empty() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${empty(\"   \")}"));
        assertEquals("Invalid empty() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${empty(\"xyz\")}"));
        assertEquals("Invalid empty() result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${empty(this.alwaysNull)}"));

        assertEquals("Invalid if(empty()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(empty(\"test\"), true, false)}"));
        assertEquals("Invalid if(empty()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(empty(\"test\n\"), true, false)}"));

        // functions can NOT handle literal strings containing newlines  (disabled for now, because literal strings pose problems in the matching process)
        assertEquals("Invalid if(empty()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(empty(\"\n\"), true, false)}"));
        assertEquals("Invalid if(empty()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(empty(\"\n\"), \"true\", \"false\")}"));

        // functions CAN handle variable values with newlines!
        assertEquals("Invalid if(empty()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(empty(this.anotherString), \"true\", \"false\")}"));

        // equal
        assertEquals("Invalid equal() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(this.id, this.id)}"));
        assertEquals("Invalid equal() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(\"1\", this.anInt)}"));
        assertEquals("Invalid equal() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(1, this.anInt)}"));
        assertEquals("Invalid equal() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(1.0, this.anInt)}"));
        assertEquals("Invalid equal() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(this.anInt, \"1\")}"));
        assertEquals("Invalid equal() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(this.anInt, 1)}"));
        assertEquals("Invalid equal() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(this.anInt, 1.0)}"));
        assertEquals("Invalid equal() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(this.aBoolean, \"true\")}"));
        assertEquals("Invalid equal() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${equal(this.aBoolean, \"false\")}"));
        assertEquals("Invalid equal() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(this.aBoolean, true)}"));
        assertEquals("Invalid equal() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${equal(this.aBoolean, false)}"));
        assertEquals("Invalid equal() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(this.anEnum, 'One')}"));

        // if + equal
        assertEquals("Invalid if(equal()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(this.id, this.id), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"abc\", \"abc\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(3, 3), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(\"3\", \"3\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(3.1414, 3.1414), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"3.1414\", \"3.1414\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(23.44242222243633337234623462, 23.44242222243633337234623462), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"23.44242222243633337234623462\", \"23.44242222243633337234623462\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(13, 013), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(13, \"013\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(\"13\", \"013\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"13\", \"00013\"), \"true\", \"false\")}"));

        // disabled: java StreamTokenizer can NOT handle scientific notation
        //         assertEquals("Invalid if(equal()) result", "true",  Scripting.replaceVariables(ctx, testOne, "${equal(23.4462, 2.34462e1)}"));
        //         assertEquals("Invalid if(equal()) result", "true",  Scripting.replaceVariables(ctx, testOne, "${equal(0.00234462, 2.34462e-3)}"));
        //         assertEquals("Invalid if(equal()) result with null value", "false",  Scripting.replaceVariables(ctx, testOne, "${equal(this.alwaysNull, 2.34462e-3)}"));
        assertEquals("Invalid if(equal()) result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${equal(0.00234462, this.alwaysNull)}"));
        assertEquals("Invalid if(equal()) result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${equal(this.alwaysNull, this.alwaysNull)}"));

        // if + equal + add
        assertEquals("Invalid if(equal(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"2\", add(\"1\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, add(\"1\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(2, add(1, 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, add(\"1\", 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, add(1, \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(2, add(1, 1.0)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.0, add(\"1\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(2.0, add(1, 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.0, add(\"1\", 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.0, add(1, \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.0, add(1, 1.0)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(20, add(\"10\", \"10\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(20, add(\"10\", \"010\")), \"true\", \"false\")}"));

        // eq
        assertEquals("Invalideq) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.id, this.id)}"));
        assertEquals("Invalid eq() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(\"1\", this.anInt)}"));
        assertEquals("Invalid eq() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(1, this.anInt)}"));
        assertEquals("Invalid eq() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(1.0, this.anInt)}"));
        assertEquals("Invalid eq() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.anInt, \"1\")}"));
        assertEquals("Invalid eq() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.anInt, 1)}"));
        assertEquals("Invalid eq() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.anInt, 1.0)}"));
        assertEquals("Invalid eq() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.aBoolean, \"true\")}"));
        assertEquals("Invalid eq() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.aBoolean, \"false\")}"));
        assertEquals("Invalid eq() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.aBoolean, true)}"));
        assertEquals("Invalid eq() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.aBoolean, false)}"));
        assertEquals("Invalid eq() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.anEnum, 'One')}"));
        assertEquals("Invalid eq() result", "true", Scripting.replaceVariables(ctx, testOne, "${eq('', '')}"));

        // eq with empty string and number
        assertEquals("Invalid eq() result", "false", Scripting.replaceVariables(ctx, testOne, "${eq(3, '')}"));
        assertEquals("Invalid eq() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${eq('', 12.3456)}"));

        // eq with null
        assertEquals("Invalid eq() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.alwaysNull, this.alwaysNull)}"));
        assertEquals("Invalid eq() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.alwaysNull, 'xyz')}"));
        assertEquals("Invalid eq() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${eq('xyz', this.alwaysNull)}"));

        // if + eq
        assertEquals("Invalid if(eq()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(this.id, this.id), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(\"abc\", \"abc\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(3, 3), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(\"3\", \"3\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(3.1414, 3.1414), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(eq(\"3.1414\", \"3.1414\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(eq(23.44242222243633337234623462, 23.44242222243633337234623462), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(eq(\"23.44242222243633337234623462\", \"23.44242222243633337234623462\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(13, 013), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(13, \"013\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(\"13\", \"013\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(\"13\", \"00013\"), \"true\", \"false\")}"));

        // disabled: java StreamTokenizer can NOT handle scientific notation
        //         assertEquals("Invalid if(eq()) result", "true",  Scripting.replaceVariables(ctx, testOne, "${eq(23.4462, 2.34462e1)}"));
        //         assertEquals("Invalid if(eq()) result", "true",  Scripting.replaceVariables(ctx, testOne, "${eq(0.00234462, 2.34462e-3)}"));
        //         assertEquals("Invalid if(eq()) result with null value", "false",  Scripting.replaceVariables(ctx, testOne, "${eq(this.alwaysNull, 2.34462e-3)}"));
        assertEquals("Invalid if(eq()) result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${eq(0.00234462, this.alwaysNull)}"));
        assertEquals("Invalid if(eq()) result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${eq(this.alwaysNull, this.alwaysNull)}"));

        // if + eq + add
        assertEquals("Invalid if(eq(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(eq(\"2\", add(\"1\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(eq(\"2\", add(\"2\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(eq(2, add(\"1\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(2, add(1, 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(2, add(\"1\", 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(2, add(1, \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(2, add(1, 1.0)), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(eq(2.0, add(\"1\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(2.0, add(1, 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(2.0, add(\"1\", 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(2.0, add(1, \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(eq(2.0, add(1, 1.0)), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(eq(20, add(\"10\", \"10\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(eq(add())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(eq(20, add(\"10\", \"010\")), \"true\", \"false\")}"));

        // add with null
        assertEquals("Invalid add() result with null value", "10.0",
                Scripting.replaceVariables(ctx, testOne, "${add(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid add() result with null value", "11.0",
                Scripting.replaceVariables(ctx, testOne, "${add(this.alwaysNull, \"11\")}"));
        assertEquals("Invalid add() result with null value", "0.0",
                Scripting.replaceVariables(ctx, testOne, "${add(this.alwaysNull, this.alwaysNull)}"));

        // if + lt
        assertEquals("Invalid if(lt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(\"2\", \"2\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(\"2\", \"3\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(lt(\"2000000\", \"3000000\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(\"2.0\", \"3.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(lt(\"2000000.0\", \"3000000.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(\"12\", \"3\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(lt(\"12000000\", \"3000000\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(\"12.0\", \"3.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(lt(\"12000000.0\", \"3000000.0\"), \"true\", \"false\")}"));

        assertEquals("Invalid if(lt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(2, 2), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(2, 3), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(2000000, 3000000), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(2.0, 3.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(lt(2000000.0, 3000000.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(12, 3), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(1200000, 3000000), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(12000000, 3000000), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(lt(12.0, 3.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(lt()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(lt(12000000.0, 3000000.0), \"true\", \"false\")}"));

        // compare numbers written as strings as numbers
        assertEquals("Invalid if(lt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${lt(\"1200\", \"30\")}"));

        // lt with numbers and empty string
        assertEquals("Invalid lt() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${lt(10, '')}"));
        assertEquals("Invalid lt() result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${lt('', 11)}"));
        assertEquals("Invalid lt() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${lt('', '')}"));

        // lt with null
        assertEquals("Invalid lt() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${lt(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid lt() result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${lt(this.alwaysNull, \"11\")}"));
        assertEquals("Invalid lt() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${lt(this.alwaysNull, this.alwaysNull)}"));

        // if + gt
        assertEquals("Invalid if(gt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(\"2\", \"2\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(\"2\", \"3\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(gt(\"2000000\", \"3000000\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(\"2.0\", \"3.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(gt(\"2000000.0\", \"3000000.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(\"12\", \"3\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(gt(\"12000000\", \"3000000\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(\"12.0\", \"3.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(gt(\"12000000.0\", \"3000000.0\"), \"true\", \"false\")}"));

        assertEquals("Invalid if(gt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(2, 2), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(2, 3), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(2000000, 3000000), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(2.0, 3.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(gt(2000000.0, 3000000.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(12, 3), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(12000000, 3000000), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(gt(12.0, 3.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(gt()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(gt(12000000.0, 3000000.0), \"true\", \"false\")}"));

        // gt with null
        assertEquals("Invalid gt() result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${gt(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid gt() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${gt(this.alwaysNull, \"11\")}"));
        assertEquals("Invalid gt() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${gt(this.alwaysNull, this.alwaysNull)}"));

        // gt with numbers and empty string
        assertEquals("Invalid gt() result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${gt(10, '')}"));
        assertEquals("Invalid gt() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${gt('', 11)}"));
        assertEquals("Invalid gt() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${gt('', '')}"));

        // if + lte
        assertEquals("Invalid if(lte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(\"2\", \"2\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(\"2\", \"3\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(lte(\"2000000\", \"3000000\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(\"2.0\", \"3.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(lte(\"2000000.0\", \"3000000.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(\"12\", \"3\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(lte(\"12000000\", \"3000000\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(\"12.0\", \"3.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(lte(\"12000000.0\", \"3000000.0\"), \"true\", \"false\")}"));

        assertEquals("Invalid if(lte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(2, 2), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(2, 3), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(2000000, 3000000), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(2.0, 3.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(lte(2000000.0, 3000000.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(12, 3), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(12000000, 3000000), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(lte(12.0, 3.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(lte()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(lte(12000000.0, 3000000.0), \"true\", \"false\")}"));

        // lte with null
        assertEquals("Invalid lte() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${lte(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid lte() result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${lte(this.alwaysNull, \"11\")}"));
        assertEquals("Invalid lte() result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${lte(this.alwaysNull, this.alwaysNull)}"));

        // if + gte
        assertEquals("Invalid if(gte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(\"2\", \"2\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(\"2\", \"3\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(gte(\"2000000\", \"3000000\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(\"2.0\", \"3.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(gte(\"2000000.0\", \"3000000.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(\"12\", \"3\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(gte(\"12000000\", \"3000000\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(\"12.0\", \"3.0\"), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(gte(\"12000000.0\", \"3000000.0\"), \"true\", \"false\")}"));

        assertEquals("Invalid if(gte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(2, 2), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(2, 3), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(2000000, 3000000), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(2.0, 3.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(gte(2000000.0, 3000000.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(12, 3), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(12000000, 3000000), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(gte(12.0, 3.0), \"true\", \"false\")}"));
        assertEquals("Invalid if(gte()) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(gte(12000000.0, 3000000.0), \"true\", \"false\")}"));

        // gte with null
        assertEquals("Invalid gte() result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${gte(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid gte() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${gte(this.alwaysNull, \"11\")}"));
        assertEquals("Invalid gte() result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${gte(this.alwaysNull, this.alwaysNull)}"));

        // if + equal + subt
        assertEquals("Invalid if(equal(subt())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"2\", subt(\"3\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"2\", subt(\"4\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, subt(\"3\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(2, subt(3, 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, subt(\"3\", 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, subt(3, \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(2, subt(3, 1.0)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.0, subt(\"3\", \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(2.0, subt(3, 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.0, subt(\"3\", 1)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.0, subt(3, \"1\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.0, subt(3, 1.0)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(20, subt(\"30\", \"10\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(subt())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(20, subt(\"30\", \"010\")), \"true\", \"false\")}"));

        // subt with null
        assertEquals("Invalid subt() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${subt(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid subt() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${subt(this.alwaysNull, \"11\")}"));
        assertEquals("Invalid subt() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${subt(this.alwaysNull, this.alwaysNull)}"));

        // if + equal + mult
        assertEquals("Invalid if(equal(mult())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"6\", mult(\"3\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"6\", mult(\"4\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(6, mult(\"3\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(6, mult(3, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(6, mult(\"3\", 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(6, mult(3, \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(6, mult(3, 2.0)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(6.0, mult(\"3\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(6.0, mult(3, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(6.0, mult(\"3\", 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(6.0, mult(3, \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(6.0, mult(3, 2.0)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(600, mult(\"30\", \"20\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(mult())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(600, mult(\"30\", \"020\")), \"true\", \"false\")}"));

        // mult with null
        assertEquals("Invalid mult() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${mult(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid mult() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${mult(this.alwaysNull, \"11\")}"));
        assertEquals("Invalid mult() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${mult(this.alwaysNull, this.alwaysNull)}"));

        // if + equal + quot
        assertEquals("Invalid if(equal(quot())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"1.5\", quot(\"3\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(quot())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"1.5\", quot(\"5\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(quot())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(1.5, quot(\"3\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(quot())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(1.5, quot(3, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(quot())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(1.5, quot(\"3\", 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(quot())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(1.5, quot(3, \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(quot())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(1.5, quot(3, 2.0)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(quot())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(15, quot(\"30\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(quot())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(15, quot(\"30\", \"02\")), \"true\", \"false\")}"));

        // quot with null
        assertEquals("Invalid quot() result with null value", "10.0",
                Scripting.replaceVariables(ctx, testOne, "${quot(10, this.alwaysNull)}"));
        assertEquals("Invalid quot() result with null value", "10.0",
                Scripting.replaceVariables(ctx, testOne, "${quot(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid quot() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${quot(this.alwaysNull, \"11\")}"));
        assertEquals("Invalid quot() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${quot(this.alwaysNull, this.alwaysNull)}"));

        // if + equal + round
        assertEquals("Invalid if(equal(round())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"1.9\", round(\"1.9\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"2\", round(\"2.5\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"2\", round(\"1.999999\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"2\", round(\"2.499999\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, round(1.9, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, round(2.5, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, round(1.999999, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, round(2.499999, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(2, round(2, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.4, round(2.4, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.23, round(2.225234, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, round(1.9, 8)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, round(2.5, 8)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, round(1.999999, 8)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "false", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, round(2.499999, 8)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(1.999999, round(1.999999, 8)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.499999, round(2.499999, 8)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, round(1.999999999, 8)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(2, round(2, 8)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.4, round(2.4, 8)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(round())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.225234, round(2.225234, 8)), \"true\", \"false\")}"));

        // disabled because scientific notation is not supported :(
        //assertEquals("Invalid if(equal(round())) result", "true",  Scripting.replaceVariables(ctx, testOne, "${if(equal(0.00245, round(2.45e-3, 8)), \"true\", \"false\")}"));
        //assertEquals("Invalid if(equal(round())) result", "true",  Scripting.replaceVariables(ctx, testOne, "${if(equal(245, round(2.45e2, 8)), \"true\", \"false\")}"));

        // round with null
        assertEquals("Invalid round() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${round(\"10\")}"));
        assertEquals("Invalid round() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${round(this.alwaysNull)}"));
        assertEquals("Invalid round() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${round(this.alwaysNull, this.alwaysNull)}"));

        // if + equal + max
        assertEquals("Invalid if(equal(max())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"2\", max(\"1.9\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(max())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(2, max(1.9, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(max())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2.0, max(1.9, 2)), \"true\", \"false\")}"));

        // max with null
        assertEquals("Invalid max() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${max(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid max() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${max(this.alwaysNull, \"11\")}"));
        assertEquals("Invalid max() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${max(this.alwaysNull, this.alwaysNull)}"));

        // if + equal + min
        assertEquals("Invalid if(equal(min())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(\"1.9\", min(\"1.9\", \"2\")), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(min())) result", "true", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(1.9, min(1.9, 2)), \"true\", \"false\")}"));
        assertEquals("Invalid if(equal(min())) result", "true",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(1, min(1, 2)), \"true\", \"false\")}"));

        // min with null
        assertEquals("Invalid min() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${min(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid min() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${min(this.alwaysNull, \"11\")}"));
        assertEquals("Invalid min() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${min(this.alwaysNull, this.alwaysNull)}"));

        // date_format
        assertEquals("Invalid date_format() result", nowString1, Scripting.replaceVariables(ctx, testOne,
                "${date_format(this.aDate, \"" + format1.toPattern() + "\")}"));
        assertEquals("Invalid date_format() result", nowString2, Scripting.replaceVariables(ctx, testOne,
                "${date_format(this.aDate, \"" + format2.toPattern() + "\")}"));
        assertEquals("Invalid date_format() result", nowString3, Scripting.replaceVariables(ctx, testOne,
                "${date_format(this.aDate, \"" + format3.toPattern() + "\")}"));

        // date_format with null
        assertEquals("Invalid date_format() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${date_format(\"10\", this.alwaysNull)}"));
        assertEquals("Invalid date_format() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${date_format(this.alwaysNull, this.alwaysNull)}"));

        // date_format error messages
        assertEquals("Invalid date_format() result for wrong number of parameters",
                DateFormatFunction.ERROR_MESSAGE_DATE_FORMAT,
                Scripting.replaceVariables(ctx, testOne, "${date_format()}"));
        assertEquals("Invalid date_format() result for wrong number of parameters",
                DateFormatFunction.ERROR_MESSAGE_DATE_FORMAT,
                Scripting.replaceVariables(ctx, testOne, "${date_format(this.aDouble)}"));
        assertEquals("Invalid date_format() result for wrong number of parameters",
                DateFormatFunction.ERROR_MESSAGE_DATE_FORMAT, Scripting.replaceVariables(ctx, testOne,
                        "${date_format(this.aDouble, this.aDouble, this.aDouble)}"));

        // number_format error messages
        assertEquals("Invalid date_format() result for wrong number of parameters",
                NumberFormatFunction.ERROR_MESSAGE_NUMBER_FORMAT,
                Scripting.replaceVariables(ctx, testOne, "${number_format()}"));
        assertEquals("Invalid date_format() result for wrong number of parameters",
                NumberFormatFunction.ERROR_MESSAGE_NUMBER_FORMAT,
                Scripting.replaceVariables(ctx, testOne, "${number_format(this.aDouble)}"));
        assertEquals("Invalid date_format() result for wrong number of parameters",
                NumberFormatFunction.ERROR_MESSAGE_NUMBER_FORMAT,
                Scripting.replaceVariables(ctx, testOne, "${number_format(this.aDouble, this.aDouble)}"));
        assertEquals("Invalid date_format() result for wrong number of parameters",
                NumberFormatFunction.ERROR_MESSAGE_NUMBER_FORMAT, Scripting.replaceVariables(ctx, testOne,
                        "${number_format(this.aDouble, this.aDouble, \"\", \"\")}"));
        assertEquals("Invalid date_format() result for wrong number of parameters",
                NumberFormatFunction.ERROR_MESSAGE_NUMBER_FORMAT, Scripting.replaceVariables(ctx, testOne,
                        "${number_format(this.aDouble, this.aDouble, \"\", \"\", \"\")}"));

        assertEquals("Invalid date_format() result", numberString1, Scripting.replaceVariables(ctx, testOne,
                "${number_format(this.aDouble, \"en\", \"" + numberFormat1.toPattern() + "\")}"));
        assertEquals("Invalid date_format() result", numberString2, Scripting.replaceVariables(ctx, testOne,
                "${number_format(this.aDouble, \"de\", \"" + numberFormat2.toPattern() + "\")}"));
        assertEquals("Invalid date_format() result", numberString3, Scripting.replaceVariables(ctx, testOne,
                "${number_format(this.aDouble, \"zh\", \"" + numberFormat3.toPattern() + "\")}"));
        assertEquals("Invalid date_format() result", "123456.79",
                Scripting.replaceVariables(ctx, testOne, "${number_format(123456.789012, \"en\", \"0.00\")}"));
        assertEquals("Invalid date_format() result", "123456.7890", Scripting.replaceVariables(ctx, testOne,
                "${number_format(123456.789012, \"en\", \"0.0000\")}"));
        assertEquals("Invalid date_format() result", "123456,79",
                Scripting.replaceVariables(ctx, testOne, "${number_format(123456.789012, \"de\", \"0.00\")}"));
        assertEquals("Invalid date_format() result", "123456,7890", Scripting.replaceVariables(ctx, testOne,
                "${number_format(123456.789012, \"de\", \"0.0000\")}"));
        assertEquals("Invalid date_format() result", "123456.79",
                Scripting.replaceVariables(ctx, testOne, "${number_format(123456.789012, \"zh\", \"0.00\")}"));
        assertEquals("Invalid date_format() result", "123456.7890", Scripting.replaceVariables(ctx, testOne,
                "${number_format(123456.789012, \"zh\", \"0.0000\")}"));

        // number_format with null
        assertEquals("Invalid number_format() result with null value", "", Scripting.replaceVariables(ctx,
                testOne, "${number_format(this.alwaysNull, this.alwaysNull, this.alwaysNull)}"));
        assertEquals("Invalid number_format() result with null value", "", Scripting.replaceVariables(ctx,
                testOne, "${number_format(\"10\", this.alwaysNull, this.alwaysNull)}"));
        assertEquals("Invalid number_format() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${number_format(\"10\", \"de\", this.alwaysNull)}"));

        // not
        assertEquals("Invalid not() result", "true", Scripting.replaceVariables(ctx, testOne, "${not(false)}"));
        assertEquals("Invalid not() result", "false", Scripting.replaceVariables(ctx, testOne, "${not(true)}"));
        assertEquals("Invalid not() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${not(\"false\")}"));
        assertEquals("Invalid not() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${not(\"true\")}"));

        // not with null
        assertEquals("Invalid not() result with null value", "true",
                Scripting.replaceVariables(ctx, testOne, "${not(this.alwaysNull)}"));

        // and
        assertEquals("Invalid and() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${and(true, true)}"));
        assertEquals("Invalid and() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${and(true, false)}"));
        assertEquals("Invalid and() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${and(false, true)}"));
        assertEquals("Invalid and() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${and(false, false)}"));

        // and with null
        assertEquals("Invalid and() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${and(this.alwaysNull, this.alwaysNull)}"));

        // or
        assertEquals("Invalid or() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${or(true, true)}"));
        assertEquals("Invalid or() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${or(true, false)}"));
        assertEquals("Invalid or() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${or(false, true)}"));
        assertEquals("Invalid or() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${and(false, false)}"));

        // or with null
        assertEquals("Invalid or() result with null value", "false",
                Scripting.replaceVariables(ctx, testOne, "${or(this.alwaysNull, this.alwaysNull)}"));

        // get
        assertEquals("Invalid get() result", "1",
                Scripting.replaceVariables(ctx, testOne, "${get(this, \"anInt\")}"));
        assertEquals("Invalid get() result", "String",
                Scripting.replaceVariables(ctx, testOne, "${get(this, \"aString\")}"));
        assertEquals("Invalid get() result", "2.234",
                Scripting.replaceVariables(ctx, testOne, "${get(this, \"aDouble\")}"));
        assertEquals("Invalid get() result", testTwo.toString(),
                Scripting.replaceVariables(ctx, testOne, "${get(this, \"testTwo\")}"));
        assertEquals("Invalid get() result", testTwo.getUuid(),
                Scripting.replaceVariables(ctx, testOne, "${get(get(this, \"testTwo\"), \"id\")}"));
        assertEquals("Invalid get() result", testSixs.get(0).getUuid(), Scripting.replaceVariables(ctx, testOne,
                "${get(first(get(this, \"manyToManyTestSixs\")), \"id\")}"));

        // size
        assertEquals("Invalid size() result", "20",
                Scripting.replaceVariables(ctx, testOne, "${size(this.manyToManyTestSixs)}"));
        assertEquals("Invalid size() result", "0", Scripting.replaceVariables(ctx, testOne, "${size(null)}"));
        assertEquals("Invalid size() result", "0", Scripting.replaceVariables(ctx, testOne, "${size(xyz)}"));

        // is_collection
        assertEquals("Invalid is_collection() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${is_collection(this.manyToManyTestSixs)}"));
        assertEquals("Invalid is_collection() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${is_collection(this.name)}"));
        assertEquals("Invalid is_collection() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${is_collection(null)}"));
        assertEquals("Invalid is_collection() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${is_collection(xyz)}"));

        // is_entity
        assertEquals("Invalid is_entity() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${is_entity(this.testFour)}"));
        assertEquals("Invalid is_entity() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${is_entity(this.manyToManyTestSixs)}"));
        assertEquals("Invalid is_entity() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${is_entity(this.name)}"));
        assertEquals("Invalid is_entity() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${is_entity(null)}"));
        assertEquals("Invalid is_entity() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${is_entity(xyz)}"));

        // first / last / nth
        assertEquals("Invalid first() result", testSixs.get(0).toString(),
                Scripting.replaceVariables(ctx, testOne, "${first(this.manyToManyTestSixs)}"));
        assertEquals("Invalid last() result", testSixs.get(19).toString(),
                Scripting.replaceVariables(ctx, testOne, "${last(this.manyToManyTestSixs)}"));
        assertEquals("Invalid nth() result", testSixs.get(2).toString(),
                Scripting.replaceVariables(ctx, testOne, "${nth(this.manyToManyTestSixs,  2)}"));
        assertEquals("Invalid nth() result", testSixs.get(7).toString(),
                Scripting.replaceVariables(ctx, testOne, "${nth(this.manyToManyTestSixs,  7)}"));
        assertEquals("Invalid nth() result", testSixs.get(9).toString(),
                Scripting.replaceVariables(ctx, testOne, "${nth(this.manyToManyTestSixs,  9)}"));
        assertEquals("Invalid nth() result", testSixs.get(12).toString(),
                Scripting.replaceVariables(ctx, testOne, "${nth(this.manyToManyTestSixs, 12)}"));
        assertEquals("Invalid nth() result", "",
                Scripting.replaceVariables(ctx, testOne, "${nth(this.manyToManyTestSixs, 21)}"));

        // first / last / nth with null
        assertEquals("Invalid first() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${first(this.alwaysNull)}"));
        assertEquals("Invalid last() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${last(this.alwaysNull)}"));
        assertEquals("Invalid nth() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${nth(this.alwaysNull,  2)}"));
        assertEquals("Invalid nth() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${nth(this.alwaysNull,  7)}"));
        assertEquals("Invalid nth() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${nth(this.alwaysNull,  9)}"));
        assertEquals("Invalid nth() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${nth(this.alwaysNull, 12)}"));
        assertEquals("Invalid nth() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${nth(this.alwaysNull, this.alwaysNull)}"));
        assertEquals("Invalid nth() result with null value", "",
                Scripting.replaceVariables(ctx, testOne, "${nth(this.alwaysNull, blah)}"));

        // each with null

        // get with null

        // set with null

        // set date (JS scripting)
        assertEquals("Setting the current date/time should not produce output (JS)", "", Scripting
                .replaceVariables(ctx, testOne, "${{var t = Structr.get('this'); t.aDate = new Date();}}"));

        try {

            // set date (old scripting)
            Scripting.replaceVariables(ctx, testOne, "${set(this, 'aDate', now)}");

        } catch (FrameworkException fex) {
            fail("Setting the current date/time should not cause an Exception (StructrScript)");
        }

        Scripting.replaceVariables(ctx, testOne,
                "${if(empty(this.alwaysNull), set(this, \"doResult\", true), set(this, \"doResult\", false))}");
        assertEquals("Invalid do() result", "true",
                Scripting.replaceVariables(ctx, testOne, "${this.doResult}"));

        Scripting.replaceVariables(ctx, testOne,
                "${if(empty(this.name), set(this, \"doResult\", true), set(this, \"doResult\", false))}");
        assertEquals("Invalid do() result", "false",
                Scripting.replaceVariables(ctx, testOne, "${this.doResult}"));

        // template method
        assertEquals("Invalid template() result",
                "This is a template for A-nice-little-name-for-my-test-object",
                Scripting.replaceVariables(ctx, testOne, "${template(\"TEST\", \"en_EN\", this)}"));

        // more complex tests
        Scripting.replaceVariables(ctx, testOne,
                "${each(split(\"setTestInteger1,setTestInteger2,setTestInteger3\"), set(this, data, 1))}");
        assertEquals("Invalid each() result", "1",
                Scripting.replaceVariables(ctx, testOne, "${get(this, \"setTestInteger1\")}"));
        assertEquals("Invalid each() result", "1",
                Scripting.replaceVariables(ctx, testOne, "${get(this, \"setTestInteger2\")}"));
        assertEquals("Invalid each() result", "1",
                Scripting.replaceVariables(ctx, testOne, "${get(this, \"setTestInteger3\")}"));

        // complex each expression, sets the value of "testString" to the concatenated IDs of all testSixs that are linked to "this"
        Scripting.replaceVariables(ctx, testOne,
                "${each(this.manyToManyTestSixs, set(this, \"testString\", concat(get(this, \"testString\"), data.id)))}");
        assertEquals("Invalid each() result", "640",
                Scripting.replaceVariables(ctx, testOne, "${length(this.testString)}"));

        assertEquals("Invalid if(equal()) result", "String", Scripting.replaceVariables(ctx, testOne,
                "${if(empty(this.alwaysNull), titleize(this.aString, '-'), this.alwaysNull)}"));
        assertEquals("Invalid if(equal()) result", "String", Scripting.replaceVariables(ctx, testOne,
                "${if(empty(this.aString), titleize(this.alwaysNull, '-'), this.aString)}"));

        assertNull("Invalid result for special null value",
                Scripting.replaceVariables(ctx, testOne, "${null}"));
        assertNull("Invalid result for special null value",
                Scripting.replaceVariables(ctx, testOne, "${if(equal(this.anInt, 15), \"selected\", null)}"));

        // tests from real-life examples
        assertEquals("Invalid replacement result", "tile plan ",
                Scripting.replaceVariables(ctx, testOne, "tile plan ${plan.bannerTag}"));

        // more tests with pre- and postfixes
        assertEquals("Invalid replacement result", "abcdefghijklmnop",
                Scripting.replaceVariables(ctx, testOne, "abcdefgh${blah}ijklmnop"));
        assertEquals("Invalid replacement result", "abcdefghStringijklmnop",
                Scripting.replaceVariables(ctx, testOne, "abcdefgh${this.aString}ijklmnop"));
        assertEquals("Invalid replacement result", "#String",
                Scripting.replaceVariables(ctx, testOne, "#${this.aString}"));
        assertEquals("Invalid replacement result",
                "doc_sections/" + testOne.getUuid() + "/childSections?sort=pos",
                Scripting.replaceVariables(ctx, testOne, "doc_sections/${this.id}/childSections?sort=pos"));
        assertEquals("Invalid replacement result", "A Nice Little Name For My Test Object",
                Scripting.replaceVariables(ctx, testOne, "${titleize(this.name, '-')}"));
        assertEquals("Invalid replacement result", "STRINGtrueFALSE", Scripting.replaceVariables(ctx, testOne,
                "${upper(this.aString)}${lower(true)}${upper(false)}"));

        // test store and retrieve
        assertEquals("Invalid store() result", "",
                Scripting.replaceVariables(ctx, testOne, "${store('tmp', this.name)}"));
        assertEquals("Invalid stored value", "A-nice-little-name-for-my-test-object", ctx.retrieve("tmp"));
        assertEquals("Invalid retrieve() result", "A-nice-little-name-for-my-test-object",
                Scripting.replaceVariables(ctx, testOne, "${retrieve('tmp')}"));
        assertEquals("Invalid retrieve() result", "",
                Scripting.replaceVariables(new ActionContext(securityContext), testOne, "${retrieve('tmp')}"));

        // test store and retrieve within filter expression
        assertEquals("Invalid store() result", "",
                Scripting.replaceVariables(ctx, testOne, "${store('tmp', 10)}"));
        assertEquals("Invalid retrieve() result in filter expression", "9", Scripting.replaceVariables(ctx,
                testOne, "${size(filter(this.manyToManyTestSixs, gt(data.index, 10)))}"));
        assertEquals("Invalid retrieve() result in filter expression", "9", Scripting.replaceVariables(ctx,
                testOne, "${size(filter(this.manyToManyTestSixs, gt(data.index, retrieve('tmp'))))}"));

        // retrieve object and access attribute
        assertEquals("Invalid store() result", "",
                Scripting.replaceVariables(ctx, testOne, "${store('testOne', this)}"));
        assertEquals("Invalid retrieve() result", "A-nice-little-name-for-my-test-object",
                Scripting.replaceVariables(ctx, testOne, "${retrieve('testOne').name}"));

        // retrieve stored object attribute in if() expression via get() function
        assertEquals("Invalid retrieve() result", "A-nice-little-name-for-my-test-object", Scripting
                .replaceVariables(ctx, testOne, "${if(false,'true', get(retrieve('testOne'), 'name'))}"));

        // retrieve stored object attribute in if() expression via 'dot-name'
        assertEquals("Invalid retrieve() result", "A-nice-little-name-for-my-test-object",
                Scripting.replaceVariables(ctx, testOne, "${if(false,'true', retrieve('testOne').name)}"));

        // test replace() method
        assertEquals("Invalid replace() result", "A-nice-little-name-for-my-test-object",
                Scripting.replaceVariables(ctx, testOne, "${replace(this.replaceString, this)}"));

        // test error method
        try {
            Actions.execute(securityContext, testTwo, "${error(\"base\", \"test1\")}");
            fail("error() should throw an exception.");

        } catch (FrameworkException fex) {
        }

        try {
            Actions.execute(securityContext, testTwo, "${error(\"base\", \"test1\", \"test2\")}");
            fail("error() should throw an exception.");

        } catch (FrameworkException fex) {
        }

        // test multiline statements
        assertEquals("Invalid replace() result", "equal", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, 2),\n    (\"equal\"),\n    (\"not equal\")\n)}"));
        assertEquals("Invalid replace() result", "not equal", Scripting.replaceVariables(ctx, testOne,
                "${if(equal(2, 3),\n    (\"equal\"),\n    (\"not equal\")\n)}"));

        assertEquals("Invalid keys() / join() result",
                "id,name,owner,type,createdBy,deleted,hidden,createdDate,lastModifiedDate,visibleToPublicUsers,visibleToAuthenticatedUsers,visibilityStartDate,visibilityEndDate",
                Scripting.replaceVariables(ctx, testOne, "${join(keys(this, 'ui'), ',')}"));

        // test default values
        assertEquals("Invalid string default value", "blah",
                Scripting.replaceVariables(ctx, testOne, "${this.alwaysNull!blah}"));
        assertEquals("Invalid numeric default value", "12",
                Scripting.replaceVariables(ctx, testOne, "${this.alwaysNull!12}"));

        // Number default value
        assertEquals("true", Scripting.replaceVariables(ctx, testOne, "${equal(42, this.alwaysNull!42)}"));

        // complex multi-statement tests
        Scripting.replaceVariables(ctx, testOne,
                "${(set(this, \"isValid\", true), each(this.manyToManyTestSixs, set(this, \"isValid\", and(this.isValid, equal(length(data.id), 32)))))}");
        assertEquals("Invalid multiline statement test result", "true",
                Scripting.replaceVariables(ctx, testOne, "${this.isValid}"));

        Scripting.replaceVariables(ctx, testOne,
                "${(set(this, \"isValid\", true), each(this.manyToManyTestSixs, set(this, \"isValid\", and(this.isValid, gte(now, data.createdDate)))))}");
        assertEquals("Invalid multiline statement test result", "true",
                Scripting.replaceVariables(ctx, testOne, "${this.isValid}"));

        Scripting.replaceVariables(ctx, testOne,
                "${(set(this, \"isValid\", false), each(this.manyToManyTestSixs, set(this, \"isValid\", and(this.isValid, gte(now, data.createdDate)))))}");
        assertEquals("Invalid multiline statement test result", "false",
                Scripting.replaceVariables(ctx, testOne, "${this.isValid}"));

        // test multiple nested dot-separated properties (this.parent.parent.parent)
        assertEquals("Invalid multilevel property expression result", "false",
                Scripting.replaceVariables(ctx, testOne, "${empty(this.testThree.testOne.testThree)}"));

        // test extract() with additional evaluation function
        assertEquals("Invalid filter() result", "1", Scripting.replaceVariables(ctx, testOne,
                "${size(filter(this.manyToManyTestSixs, equal(data.index, 4)))}"));
        assertEquals("Invalid filter() result", "9", Scripting.replaceVariables(ctx, testOne,
                "${size(filter(this.manyToManyTestSixs, gt(data.index, 10)))}"));
        assertEquals("Invalid filter() result", "10", Scripting.replaceVariables(ctx, testOne,
                "${size(filter(this.manyToManyTestSixs, gte(data.index, 10)))}"));

        // test complex multiline statement replacement
        final String test = "${if(lte(template('TEST2', 'en_EN', this), 2), '<2', '>2')}\n" + // first expression should evaluate to ">2"
                "${if(lte(template('TEST2', 'en_EN', this), 3), '<3', '>3')}" // second expression should evaluate to "<3"
        ;

        final String result = Scripting.replaceVariables(ctx, testOne, test);

        assertEquals("Invalid multiline and template() result", ">2\n<3", result);

        // incoming
        assertEquals("Invalid number of incoming relationships", "20",
                Scripting.replaceVariables(ctx, testOne, "${size(incoming(this))}"));
        assertEquals("Invalid number of incoming relationships", "20",
                Scripting.replaceVariables(ctx, testOne, "${size(incoming(this, 'MANY_TO_MANY'))}"));
        assertEquals("Invalid number of incoming relationships", "1",
                Scripting.replaceVariables(ctx, testTwo, "${size(incoming(this))}"));
        assertEquals("Invalid number of incoming relationships", "1",
                Scripting.replaceVariables(ctx, testThree, "${size(incoming(this))}"));
        assertEquals("Invalid relationship type", "IS_AT",
                Scripting.replaceVariables(ctx, testTwo, "${get(incoming(this), 'relType')}"));
        assertEquals("Invalid relationship type", "OWNS",
                Scripting.replaceVariables(ctx, testThree, "${get(incoming(this), 'relType')}"));

        // outgoing
        assertEquals("Invalid number of outgoing relationships", "3",
                Scripting.replaceVariables(ctx, testOne, "${size(outgoing(this))}"));
        assertEquals("Invalid number of outgoing relationships", "2",
                Scripting.replaceVariables(ctx, testOne, "${size(outgoing(this, 'IS_AT'))}"));
        assertEquals("Invalid number of outgoing relationships", "1",
                Scripting.replaceVariables(ctx, testOne, "${size(outgoing(this, 'OWNS' ))}"));
        assertEquals("Invalid relationship type", "IS_AT",
                Scripting.replaceVariables(ctx, testOne, "${get(first(outgoing(this, 'IS_AT')), 'relType')}"));
        assertEquals("Invalid relationship type", "OWNS",
                Scripting.replaceVariables(ctx, testOne, "${get(outgoing(this, 'OWNS'), 'relType')}"));

        // has_relationships
        assertEquals("Invalid result of has_relationship", "false",
                Scripting.replaceVariables(ctx, testOne, "${has_relationship(this, this)}"));

        assertEquals("Invalid result of has_relationship", "true", Scripting.replaceVariables(ctx, testOne,
                "${has_relationship(this, first(find('TestTwo', 'name', 'testTwo_name')))}"));
        assertEquals("Invalid result of has_relationship", "true", Scripting.replaceVariables(ctx, testOne,
                "${has_relationship(this, first(find('TestTwo', 'name', 'testTwo_name')), 'IS_AT')}"));
        assertEquals("Invalid result of has_relationship", "true", Scripting.replaceVariables(ctx, testOne,
                "${has_relationship(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT')}"));
        assertEquals("Invalid result of has_relationship", "false", Scripting.replaceVariables(ctx, testOne,
                "${has_relationship(this, first(find('TestTwo', 'name', 'testTwo_name')), 'THIS_DOES_NOT_EXIST')}"));

        assertEquals("Invalid result of has_relationship", "true", Scripting.replaceVariables(ctx, testTwo,
                "${has_relationship(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this)}"));
        assertEquals("Invalid result of has_relationship", "true", Scripting.replaceVariables(ctx, testTwo,
                "${has_relationship(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')))}"));

        assertEquals("Invalid result of has_relationship", "true", Scripting.replaceVariables(ctx, testOne,
                "${has_relationship(this, first(find('TestThree', 'name', 'testThree_name')))}"));
        assertEquals("Invalid result of has_relationship", "true", Scripting.replaceVariables(ctx, testOne,
                "${has_relationship(this, first(find('TestThree', 'name', 'testThree_name')), 'OWNS')}"));

        assertEquals("Invalid result of has_relationship", "false", Scripting.replaceVariables(ctx, testTwo,
                "${has_relationship(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this, 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_relationship", "false", Scripting.replaceVariables(ctx, testOne,
                "${has_relationship(this, first(find('TestThree', 'name', 'testThree_name')), 'THIS_DOES_NOT_EXIST')}"));

        // has_incoming_relationship
        assertEquals("Invalid result of has_incoming_relationship", "false",
                Scripting.replaceVariables(ctx, testOne, "${has_incoming_relationship(this, this)}"));

        assertEquals("Invalid result of has_incoming_relationship", "true", Scripting.replaceVariables(ctx,
                testOne, "${has_incoming_relationship(first(find('TestTwo', 'name', 'testTwo_name')), this)}"));
        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testOne, "${has_incoming_relationship(this, first(find('TestTwo', 'name', 'testTwo_name')))}"));

        assertEquals("Invalid result of has_incoming_relationship", "true", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT')}"));
        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(this, first(find('TestTwo', 'name', 'testTwo_name')), 'IS_AT')}"));

        assertEquals("Invalid result of has_incoming_relationship", "true", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT')}"));
        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(this, first(find('TestTwo', 'name', 'testTwo_name')), 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(first(find('TestTwo', 'name', 'testTwo_name')), this, 'THIS_DOES_NOT_EXIST')}"));

        assertEquals("Invalid result of has_incoming_relationship", "true", Scripting.replaceVariables(ctx,
                testTwo,
                "${has_incoming_relationship(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')))}"));
        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testTwo,
                "${has_incoming_relationship(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this)}"));

        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(this, first(find('TestThree', 'name', 'testThree_name')))}"));
        assertEquals("Invalid result of has_incoming_relationship", "true", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(first(find('TestThree', 'name', 'testThree_name')), this)}"));

        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(this, first(find('TestThree', 'name', 'testThree_name')), 'OWNS')}"));
        assertEquals("Invalid result of has_incoming_relationship", "true", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(first(find('TestThree', 'name', 'testThree_name')), this, 'OWNS')}"));

        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(this, first(find('TestThree', 'name', 'testThree_name')), 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(first(find('TestThree', 'name', 'testThree_name')), this, 'THIS_DOES_NOT_EXIST')}"));

        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testTwo,
                "${has_incoming_relationship(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this, 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testTwo,
                "${has_incoming_relationship(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(this, first(find('TestThree', 'name', 'testThree_name')), 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_incoming_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_incoming_relationship(first(find('TestThree', 'name', 'testThree_name')), this, 'THIS_DOES_NOT_EXIST')}"));

        // has_outgoing_relationship (since has_outgoing_relationship is just the inverse method to has_outgoing_relationship we can basically reuse the tests and just invert the result - except for the always-false or always-true tests)
        assertEquals("Invalid result of has_outgoing_relationship", "false",
                Scripting.replaceVariables(ctx, testOne, "${has_outgoing_relationship(this, this)}"));

        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne, "${has_outgoing_relationship(first(find('TestTwo', 'name', 'testTwo_name')), this)}"));
        assertEquals("Invalid result of has_outgoing_relationship", "true", Scripting.replaceVariables(ctx,
                testOne, "${has_outgoing_relationship(this, first(find('TestTwo', 'name', 'testTwo_name')))}"));

        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT')}"));
        assertEquals("Invalid result of has_outgoing_relationship", "true", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(this, first(find('TestTwo', 'name', 'testTwo_name')), 'IS_AT')}"));

        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT')}"));
        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(this, first(find('TestTwo', 'name', 'testTwo_name')), 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(first(find('TestTwo', 'name', 'testTwo_name')), this, 'THIS_DOES_NOT_EXIST')}"));

        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testTwo,
                "${has_outgoing_relationship(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')))}"));
        assertEquals("Invalid result of has_outgoing_relationship", "true", Scripting.replaceVariables(ctx,
                testTwo,
                "${has_outgoing_relationship(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this)}"));

        assertEquals("Invalid result of has_outgoing_relationship", "true", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(this, first(find('TestThree', 'name', 'testThree_name')))}"));
        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(first(find('TestThree', 'name', 'testThree_name')), this)}"));

        assertEquals("Invalid result of has_outgoing_relationship", "true", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(this, first(find('TestThree', 'name', 'testThree_name')), 'OWNS')}"));
        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(first(find('TestThree', 'name', 'testThree_name')), this, 'OWNS')}"));

        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(this, first(find('TestThree', 'name', 'testThree_name')), 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(first(find('TestThree', 'name', 'testThree_name')), this, 'THIS_DOES_NOT_EXIST')}"));

        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testTwo,
                "${has_outgoing_relationship(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this, 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testTwo,
                "${has_outgoing_relationship(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(this, first(find('TestThree', 'name', 'testThree_name')), 'THIS_DOES_NOT_EXIST')}"));
        assertEquals("Invalid result of has_outgoing_relationship", "false", Scripting.replaceVariables(ctx,
                testOne,
                "${has_outgoing_relationship(first(find('TestThree', 'name', 'testThree_name')), this, 'THIS_DOES_NOT_EXIST')}"));

        // get_relationships (CAUTION! If the method returns a string (error-case) the size-method returns "1" => it seems like there is one relationsh)
        assertEquals("Invalid number of relationships", "0",
                Scripting.replaceVariables(ctx, testOne, "${size(get_relationships(this, this))}"));

        // non-existent relType between nodes which have a relationship
        assertEquals("Invalid number of relationships", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(get_relationships(first(find('TestTwo', 'name', 'testTwo_name')), this, 'THIS_DOES_NOT_EXIST'))}"));
        // non-existent relType between a node and itself
        assertEquals("Invalid number of relationships", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(get_relationships(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this, 'THIS_DOES_NOT_EXIST'))}"));

        // identical result test (from and to are just switched around)
        assertEquals("Invalid number of relationships", "1", Scripting.replaceVariables(ctx, testTwo,
                "${size(get_relationships(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this, 'IS_AT'))}"));
        assertEquals("Invalid number of relationships", "1", Scripting.replaceVariables(ctx, testTwo,
                "${size(get_relationships(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), 'IS_AT'))}"));

        // get_incoming_relationships (CAUTION! If the method returns a string (error-case) the size-method returns "1" => it seems like there is one relationsh)
        assertEquals("Invalid number of incoming relationships", "0",
                Scripting.replaceVariables(ctx, testOne, "${size(get_incoming_relationships(this, this))}"));

        assertEquals("Invalid number of incoming relationships", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(get_incoming_relationships(this, first(find('TestTwo', 'name', 'testTwo_name'))))}"));
        assertEquals("Invalid number of incoming relationships", "1", Scripting.replaceVariables(ctx, testOne,
                "${size(get_incoming_relationships(first(find('TestTwo', 'name', 'testTwo_name')), this))}"));
        assertEquals("Invalid number of incoming relationships", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(get_incoming_relationships(this, first(find('TestTwo', 'name', 'testTwo_name')), 'IS_AT'))}"));
        assertEquals("Invalid number of incoming relationships", "1", Scripting.replaceVariables(ctx, testOne,
                "${size(get_incoming_relationships(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT'))}"));

        assertEquals("Invalid number of incoming relationships", "1", Scripting.replaceVariables(ctx, testTwo,
                "${size(get_incoming_relationships(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object'))))}"));
        assertEquals("Invalid number of incoming relationships", "1", Scripting.replaceVariables(ctx, testThree,
                "${size(get_incoming_relationships(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object'))))}"));
        assertEquals("Invalid relationship type", "IS_AT", Scripting.replaceVariables(ctx, testTwo,
                "${get(first(get_incoming_relationships(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')))), 'relType')}"));

        assertEquals("Invalid relationship type", "OWNS", Scripting.replaceVariables(ctx, testThree,
                "${get(first(get_incoming_relationships(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')))), 'relType')}"));

        // get_outgoing_relationships (CAUTION! If the method returns a string (error-case) the size-method returns "1" => it seems like there is one relationsh)
        assertEquals("Invalid number of outgoing relationships", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(get_outgoing_relationships(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this))}"));

        assertEquals("Invalid number of outgoing relationships", "0", Scripting.replaceVariables(ctx, testTwo,
                "${size(get_outgoing_relationships(this, first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object'))))}"));

        assertEquals("Invalid number of outgoing relationships", "1", Scripting.replaceVariables(ctx, testTwo,
                "${size(get_outgoing_relationships(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this))}"));
        assertEquals("Invalid number of outgoing relationships", "0", Scripting.replaceVariables(ctx, testTwo,
                "${size(get_outgoing_relationships(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this, 'THIS_DOES_NOT_EXIST'))}"));

        assertEquals("Invalid number of outgoing relationships", "1", Scripting.replaceVariables(ctx, testThree,
                "${size(get_outgoing_relationships(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this))}"));
        assertEquals("Invalid relationship type", "IS_AT", Scripting.replaceVariables(ctx, testTwo,
                "${get(first(get_outgoing_relationships(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this)), 'relType')}"));

        assertEquals("Invalid relationship type", "OWNS", Scripting.replaceVariables(ctx, testThree,
                "${get(first(get_outgoing_relationships(first(find('TestOne', 'name', 'A-nice-little-name-for-my-test-object')), this)), 'relType')}"));

        // create_relationship
        // lifecycle for relationship t1-[:NEW_RELATIONSHIP_NAME]->t1
        assertEquals("Invalid number of relationships", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(get_outgoing_relationships(this, this, 'IS_AT'))}"));
        assertEquals("unexpected result of create_relationship", "",
                Scripting.replaceVariables(ctx, testOne, "${create_relationship(this, this, 'IS_AT')}"));
        assertEquals("Invalid number of relationships", "1", Scripting.replaceVariables(ctx, testOne,
                "${size(get_outgoing_relationships(this, this, 'IS_AT'))}"));
        assertEquals("unexpected result of delete", "", Scripting.replaceVariables(ctx, testOne,
                "${delete(first(get_outgoing_relationships(this, this, 'IS_AT')))}"));
        assertEquals("Invalid number of relationships", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(get_outgoing_relationships(this, this, 'IS_AT'))}"));

        // lifecycle for relationship t2-[:NEW_RELATIONSHIP_NAME]->t1
        assertEquals("Invalid number of relationships", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(get_outgoing_relationships(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT'))}"));
        assertEquals("unexpected result of create_relationship", "", Scripting.replaceVariables(ctx, testOne,
                "${create_relationship(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT')}"));
        assertEquals("Invalid number of relationships", "1", Scripting.replaceVariables(ctx, testOne,
                "${size(get_outgoing_relationships(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT'))}"));
        assertEquals("unexpected result of delete", "", Scripting.replaceVariables(ctx, testOne,
                "${delete(first(get_outgoing_relationships(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT')))}"));
        assertEquals("Invalid number of relationships", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(get_outgoing_relationships(first(find('TestTwo', 'name', 'testTwo_name')), this, 'IS_AT'))}"));

        // array index access
        assertEquals("Invalid array index accessor result", testSixs.get(0).getUuid(),
                Scripting.replaceVariables(ctx, testOne, "${this.manyToManyTestSixs[0]}"));
        assertEquals("Invalid array index accessor result", testSixs.get(2).getUuid(),
                Scripting.replaceVariables(ctx, testOne, "${this.manyToManyTestSixs[2]}"));
        assertEquals("Invalid array index accessor result", testSixs.get(4).getUuid(),
                Scripting.replaceVariables(ctx, testOne, "${this.manyToManyTestSixs[4]}"));

        // test new dot notation
        assertEquals("Invalid dot notation result", testSixs.get(0).getProperty(AbstractNode.name),
                Scripting.replaceVariables(ctx, testOne, "${this.manyToManyTestSixs[0].name}"));
        assertEquals("Invalid dot notation result", testSixs.get(0).getProperty(AbstractNode.name),
                Scripting.replaceVariables(ctx, testOne, "${sort(find('TestSix'), 'name')[0].name}"));
        assertEquals("Invalid dot notation result", testSixs.get(15).getProperty(AbstractNode.name),
                Scripting.replaceVariables(ctx, testOne, "${sort(find('TestSix'), 'name')[15].name}"));
        assertEquals("Invalid dot notation result", "20",
                Scripting.replaceVariables(ctx, testOne, "${this.manyToManyTestSixs.size}"));

        // test array property access
        assertEquals("Invalid string array access result", "one",
                Scripting.replaceVariables(ctx, testFour, "${this.stringArrayProperty[0]}"));
        assertEquals("Invalid string array access result", "two",
                Scripting.replaceVariables(ctx, testFour, "${this.stringArrayProperty[1]}"));
        assertEquals("Invalid string array access result", "three",
                Scripting.replaceVariables(ctx, testFour, "${this.stringArrayProperty[2]}"));
        assertEquals("Invalid string array access result", "four",
                Scripting.replaceVariables(ctx, testFour, "${this.stringArrayProperty[3]}"));

        // test string array property support in collection access methods
        assertEquals("Invalid string array access result with join()", "one,two,three,four",
                Scripting.replaceVariables(ctx, testFour, "${join(this.stringArrayProperty, ',')}"));
        assertEquals("Invalid string array access result with concat()", "onetwothreefour",
                Scripting.replaceVariables(ctx, testFour, "${concat(this.stringArrayProperty)}"));
        assertEquals("Invalid string array access result with first()", "one",
                Scripting.replaceVariables(ctx, testFour, "${first(this.stringArrayProperty)}"));
        assertEquals("Invalid string array access result with last()", "four",
                Scripting.replaceVariables(ctx, testFour, "${last(this.stringArrayProperty)}"));
        assertEquals("Invalid string array access result with size()", "4",
                Scripting.replaceVariables(ctx, testFour, "${size(this.stringArrayProperty)}"));
        assertEquals("Invalid string array access result with .size", "4",
                Scripting.replaceVariables(ctx, testFour, "${this.stringArrayProperty.size}"));
        assertEquals("Invalid string array access result with nth", "one",
                Scripting.replaceVariables(ctx, testFour, "${nth(this.stringArrayProperty, 0)}"));
        assertEquals("Invalid string array access result with nth", "two",
                Scripting.replaceVariables(ctx, testFour, "${nth(this.stringArrayProperty, 1)}"));
        assertEquals("Invalid string array access result with nth", "three",
                Scripting.replaceVariables(ctx, testFour, "${nth(this.stringArrayProperty, 2)}"));
        assertEquals("Invalid string array access result with nth", "four",
                Scripting.replaceVariables(ctx, testFour, "${nth(this.stringArrayProperty, 3)}"));
        assertEquals("Invalid string array access result with contains()", "true",
                Scripting.replaceVariables(ctx, testFour, "${contains(this.stringArrayProperty, 'two')}"));
        assertEquals("Invalid string array access result with contains()", "false",
                Scripting.replaceVariables(ctx, testFour, "${contains(this.stringArrayProperty, 'five')}"));

        // find
        assertEquals("Invalid find() result for empty values", testThree.getUuid(), Scripting
                .replaceVariables(ctx, testOne, "${first(find('TestThree', 'oneToOneTestSix', null))}"));
        assertEquals("Invalid find() result for empty values", testThree.getUuid(), Scripting
                .replaceVariables(ctx, testOne, "${first(find('TestThree', 'oneToManyTestSix', null))}"));

        // search
        assertEquals("Invalid search() result", testOne.getUuid(), Scripting.replaceVariables(ctx, testTwo,
                "${first(search('TestOne', 'name', 'A-nice-little-name-for-my-test-object'))}"));
        assertEquals("Invalid search() result", testOne.getUuid(), Scripting.replaceVariables(ctx, testTwo,
                "${first(search('TestOne', 'name', '*little-name-for-my-test-object'))}"));
        assertEquals("Invalid search() result", testOne.getUuid(), Scripting.replaceVariables(ctx, testTwo,
                "${first(search('TestOne', 'name', 'A-nice-little-name-for*'))}"));

        // negative test for find()
        assertEquals("Invalid find() result", "", Scripting.replaceVariables(ctx, testTwo,
                "${first(find('TestOne', 'name', '*little-name-for-my-test-object'))}"));
        assertEquals("Invalid find() result", "", Scripting.replaceVariables(ctx, testTwo,
                "${first(find('TestOne', 'name', 'A-nice-little-name-for*'))}"));

        // create
        Integer noOfOnes = 1;
        assertEquals("Invalid number of TestOne's", "" + noOfOnes,
                Scripting.replaceVariables(ctx, testOne, "${size(find('TestOne'))}"));

        // currently the creation of nodes must take place in a node of another type
        Scripting.replaceVariables(ctx, testFour, "${create('TestOne', 'name', 'createTestOne1')}");
        noOfOnes++;
        assertEquals("Invalid number of TestOne's", "" + noOfOnes,
                Scripting.replaceVariables(ctx, testOne, "${size(find('TestOne'))}"));
        assertEquals("Invalid number of TestOne's", "1",
                Scripting.replaceVariables(ctx, testOne, "${size(find('TestOne', 'name', 'createTestOne1'))}"));

        Scripting.replaceVariables(ctx, testFour, "${create('TestOne', 'name', 'createTestOne1')}");
        noOfOnes++;
        assertEquals("Invalid number of TestOne's", "" + noOfOnes,
                Scripting.replaceVariables(ctx, testOne, "${size(find('TestOne'))}"));
        assertEquals("Invalid number of TestOne's", "2",
                Scripting.replaceVariables(ctx, testOne, "${size(find('TestOne', 'name', 'createTestOne1'))}"));

        // currently this must be executed on another node type
        Scripting.replaceVariables(ctx, testFour,
                "${create('TestOne', 'name', 'createTestOne2', 'aCreateString', 'newCreateString1')}");
        noOfOnes++;
        assertEquals("Invalid number of TestOne's", "" + noOfOnes,
                Scripting.replaceVariables(ctx, testOne, "${size(find('TestOne'))}"));
        assertEquals("Invalid number of TestOne's", "1",
                Scripting.replaceVariables(ctx, testOne, "${size(find('TestOne', 'name', 'createTestOne2'))}"));
        assertEquals("Invalid number of TestOne's", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(find('TestOne', 'aCreateString', 'DOES_NOT_EXIST'))}"));
        assertEquals("Invalid number of TestOne's", "1", Scripting.replaceVariables(ctx, testOne,
                "${size(find('TestOne', 'aCreateString', 'newCreateString1'))}"));
        assertEquals("Invalid number of TestOne's", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(find('TestOne', 'name', 'createTestOne2', 'aCreateString', 'NOT_newCreateString1'))}"));
        assertEquals("Invalid number of TestOne's", "1", Scripting.replaceVariables(ctx, testOne,
                "${size(find('TestOne', 'name', 'createTestOne2', 'aCreateString', 'newCreateString1'))}"));

        // currently this must be executed on another node type
        Scripting.replaceVariables(ctx, testFour,
                "${create('TestOne', 'name', 'createTestOne2', 'aCreateInt', '256')}");
        noOfOnes++;
        assertEquals("Invalid number of TestOne's", "" + noOfOnes,
                Scripting.replaceVariables(ctx, testOne, "${size(find('TestOne'))}"));
        assertEquals("Invalid number of TestOne's", "2",
                Scripting.replaceVariables(ctx, testOne, "${size(find('TestOne', 'name', 'createTestOne2'))}"));
        assertEquals("Invalid number of TestOne's", "1",
                Scripting.replaceVariables(ctx, testOne, "${size(find('TestOne', 'aCreateInt', '256'))}"));
        assertEquals("Invalid number of TestOne's", "0", Scripting.replaceVariables(ctx, testOne,
                "${size(find('TestOne', 'name', 'createTestOne2', 'aCreateInt', '255'))}"));
        assertEquals("Invalid number of TestOne's", "1", Scripting.replaceVariables(ctx, testOne,
                "${size(find('TestOne', 'name', 'createTestOne2', 'aCreateInt', '256'))}"));

        tx.success();

    } catch (FrameworkException fex) {

        fex.printStackTrace();

        fail(fex.getMessage());
    }
}