Example usage for java.text DecimalFormatSymbols getInstance

List of usage examples for java.text DecimalFormatSymbols getInstance

Introduction

In this page you can find the example usage for java.text DecimalFormatSymbols getInstance.

Prototype

public static final DecimalFormatSymbols getInstance(Locale locale) 

Source Link

Document

Gets the DecimalFormatSymbols instance for the specified locale.

Usage

From source file:org.drools.planner.benchmark.core.measurement.ScoreDifferencePercentage.java

public String toString(Locale locale) {
    StringBuilder s = new StringBuilder(percentageLevels.length * 8);
    DecimalFormat decimalFormat = new DecimalFormat("0.00%", DecimalFormatSymbols.getInstance(locale));
    for (int i = 0; i < percentageLevels.length; i++) {
        if (i > 0) {
            s.append("/");
        }/*  w ww. j av  a 2 s  .  c om*/
        s.append(decimalFormat.format(percentageLevels[i]));
    }
    return s.toString();
}

From source file:org.mentawai.util.StringUtils.java

/**
* Convert Money value as String to a Number
* @param value/*w ww .ja  v a 2s .  c o m*/
* @param loc (Optional) Default is LocaleManager.DEFAULT_LOCALE
*/
public static Number parseCurrencyNumber(String value, Locale loc) throws ParseException {
    if (loc == null)
        loc = LocaleManager.DEFAULT_LOCALE;
    String symbol = DecimalFormatSymbols.getInstance(loc).getCurrencySymbol();
    if ("R$".equals(symbol))
        symbol += " "; // Caso seja a moeda Real.
    Number number = NumberFormat.getCurrencyInstance(loc).parse(symbol + value);
    return number;
}

From source file:com.norconex.commons.lang.unit.DataUnitFormatter.java

/**
 * Formats a data amount of the given unit to a human-readable 
 * representation./*from   w w w .  j  av a2  s  . c om*/
 * @param amount the amount to format
 * @param unit the data unit type of the amount
 * @return formatted string
 */
public String format(long amount, DataUnit unit) {

    // If no unit specified, return as string without a suffix
    if (unit == null) {
        return Long.toString(amount);
    }

    // Use coarser unit if applicable to make value more human-readable
    DataUnit finalUnit = unit;
    long finalAmount = amount;
    int ordinalShift = 0;
    if (!fixedUnit) {
        ordinalShift = (int) (Math.log(amount) / Math.log(K));
        if (ordinalShift > 0) {
            finalUnit = DATA_UNITS[Math.min(unit.ordinal() + ordinalShift, DATA_UNITS.length - 1)];
            finalAmount = finalUnit.convert(amount, unit);
        }
    }

    // Find out decimals
    long decimals = 0;
    if (decimalPrecision > 0 && unit.ordinal() < finalUnit.ordinal()) {
        int previousOrdinal = finalUnit.ordinal() - 1;
        if (previousOrdinal >= 0) {
            long originalBytes = unit.toBytes(amount);
            long finalBytes = finalUnit.toBytes(finalAmount);
            long diff = originalBytes - finalBytes;
            DataUnit previousUnit = DATA_UNITS[previousOrdinal];
            long remainder = previousUnit.convert(diff, DataUnit.B);
            long base = remainder * (long) Math.pow(D, decimalPrecision);
            decimals = base / K;
        }
    }

    Locale finalLocale = locale;
    if (finalLocale == null) {
        finalLocale = Locale.getDefault();
    }
    StringBuilder b = new StringBuilder();
    b.append(NumberFormat.getIntegerInstance(finalLocale).format(finalAmount));
    if (decimals > 0) {
        b.append(DecimalFormatSymbols.getInstance(finalLocale).getDecimalSeparator());
        b.append(StringUtils.left(Long.toString(decimals), decimalPrecision));
    }
    b.append('\u00A0').append(finalUnit.toString());
    return b.toString();
}

From source file:com.searchbox.framework.web.SystemController.java

@ModelAttribute("jvmInfo")
public static Map<String, Object> getJvmInfo() {
    Map<String, Object> jvm = new HashMap<String, Object>();

    final String javaVersion = System.getProperty("java.specification.version", "unknown");
    final String javaVendor = System.getProperty("java.specification.vendor", "unknown");
    final String javaName = System.getProperty("java.specification.name", "unknown");
    final String jreVersion = System.getProperty("java.version", "unknown");
    final String jreVendor = System.getProperty("java.vendor", "unknown");
    final String vmVersion = System.getProperty("java.vm.version", "unknown");
    final String vmVendor = System.getProperty("java.vm.vendor", "unknown");
    final String vmName = System.getProperty("java.vm.name", "unknown");

    // Summary Info
    jvm.put("version", jreVersion + " " + vmVersion);
    jvm.put("name", jreVendor + " " + vmName);

    // details//from w  w w .j av a  2  s .  c  o  m
    Map<String, Object> java = new HashMap<String, Object>();
    java.put("vendor", javaVendor);
    java.put("name", javaName);
    java.put("version", javaVersion);
    jvm.put("spec", java);
    Map<String, Object> jre = new HashMap<String, Object>();
    jre.put("vendor", jreVendor);
    jre.put("version", jreVersion);
    jvm.put("jre", jre);
    Map<String, Object> vm = new HashMap<String, Object>();
    vm.put("vendor", vmVendor);
    vm.put("name", vmName);
    vm.put("version", vmVersion);
    jvm.put("vm", vm);

    Runtime runtime = Runtime.getRuntime();
    jvm.put("processors", runtime.availableProcessors());

    // not thread safe, but could be thread local
    DecimalFormat df = new DecimalFormat("#.#", DecimalFormatSymbols.getInstance(Locale.ROOT));

    Map<String, Object> mem = new HashMap<String, Object>();
    Map<String, Object> raw = new HashMap<String, Object>();
    long free = runtime.freeMemory();
    long max = runtime.maxMemory();
    long total = runtime.totalMemory();
    long used = total - free;
    double percentUsed = ((double) (used) / (double) max) * 100;
    raw.put("free", free);
    mem.put("free", humanReadableUnits(free, df));
    raw.put("total", total);
    mem.put("total", humanReadableUnits(total, df));
    raw.put("max", max);
    mem.put("max", humanReadableUnits(max, df));
    raw.put("used", used);
    mem.put("used", humanReadableUnits(used, df) + " (%" + df.format(percentUsed) + ")");
    raw.put("used%", percentUsed);

    mem.put("raw", raw);
    jvm.put("memory", mem);

    // JMX properties -- probably should be moved to a different handler
    Map<String, Object> jmx = new HashMap<String, Object>();
    try {
        RuntimeMXBean mx = ManagementFactory.getRuntimeMXBean();
        jmx.put("bootclasspath", mx.getBootClassPath());
        jmx.put("classpath", mx.getClassPath());

        // the input arguments passed to the Java virtual machine
        // which does not include the arguments to the main method.
        jmx.put("commandLineArgs", mx.getInputArguments());

        jmx.put("startTime", new Date(mx.getStartTime()));
        jmx.put("upTimeMS", mx.getUptime());

    } catch (Exception e) {
        LOGGER.warn("Error getting JMX properties", e);
    }
    jvm.put("jmx", jmx);
    return jvm;
}

From source file:MondrianConnector.java

public ArrayList<ArrayList<String>> ExecuteQuery2(Query queryObject) throws Exception {
    System.setProperty("mondrian.olap.SsasCompatibleNaming", "true");
    String connectionString = getConnectionString(queryObject);
    RolapConnection connection = (RolapConnection) DriverManager.getConnection(connectionString, null);
    mondrian.olap.Query query = connection.parseQuery(queryObject.getMdxQuery());
    Result result = connection.execute(query);
    ArrayList<ArrayList<String>> data = new ArrayList<ArrayList<String>>();
    DecimalFormat df = new DecimalFormat("0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
    df.setMaximumFractionDigits(340); //340 = DecimalFormat.DOUBLE_FRACTION_DIGITS
    if (result.getAxes().length == 1) {
        //Only One Axis has come so
        ArrayList<String> measures = new ArrayList<String>();
        for (Position p : result.getAxes()[0].getPositions()) {
            measures.add(p.get(0).getUniqueName().toString());
        }//ww w  .  j  a v  a  2s .  c  o  m
        data.add(measures);

        ArrayList<String> row = new ArrayList<String>();
        for (int i = 0; i < measures.size(); i++) {

            Object value = result.getCell(new int[] { i }).getValue();
            if (value == null) {
                row.add(null);
            } else if (value instanceof Integer) {
                row.add(((Integer) value).toString());
            } else if (value instanceof Double) {
                row.add(df.format(value));
            } else {
                row.add(value.toString());
            }
        }
        data.add(row);
    } else if (result.getAxes().length == 2) {
        ArrayList<String> measures = new ArrayList<String>();
        for (Position p : result.getAxes()[0].getPositions()) {
            measures.add(p.get(0).getUniqueName().toString());
        }
        ArrayList<String> headers = new ArrayList<String>();
        ArrayList<ArrayList<DimensionItem>> dimensionItems = new ArrayList<ArrayList<DimensionItem>>();
        for (Position p : result.getAxes()[1].getPositions()) {
            ArrayList<DimensionItem> itemsAtRow = new ArrayList<DimensionItem>();
            for (Object item : p.toArray()) {
                RolapMemberBase member = (RolapMemberBase) item;
                itemsAtRow.add(new DimensionItem(member.getLevel().getHierarchy().toString(),
                        member.getCaption().toString()));
            }
            dimensionItems.add(itemsAtRow);
        }
        for (int ix = 0; ix < dimensionItems.size(); ix++) {
            ArrayList<String> row = new ArrayList<String>();
            for (DimensionItem item : dimensionItems.get(ix)) {
                if (ix == 0)
                    headers.add(item.getLevel());
                row.add(item.getCaption());
            }
            for (int i = 0; i < measures.size(); i++) {
                if (ix == 0)
                    headers.add(measures.get(i));
                Object value = result.getCell(new int[] { i, ix }).getValue();
                if (value == null) {
                    row.add("0");
                } else {
                    if (value instanceof Integer) {
                        row.add(((Integer) value).toString());
                    } else if (value instanceof Double) {
                        row.add(df.format(value));
                    } else {
                        row.add(value.toString());
                    }
                }
            }
            if (ix == 0)
                data.add(headers);
            data.add(row);
        }
    }
    return data;
}

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;//  ww  w.ja  va2  s.  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());
    }
}

From source file:org.locationtech.udig.tools.internal.CursorPosition.java

/**
 * transforms a String value to a Coordinate considering Locale setting and the supplied crs.
 * //from  ww  w  . ja va  2s.  co m
 * @param value
 * @param crs
 * @return
 */
public static Coordinate parse(String value, CoordinateReferenceSystem crs) {

    char decimalSeparator = DecimalFormatSymbols.getInstance(Locale.getDefault()).getDecimalSeparator();

    String modifiedvalue = value.trim();
    boolean latlong = false;
    String upperCase = modifiedvalue.toUpperCase();
    String tmp = modifiedvalue;
    modifiedvalue = stripCode(modifiedvalue, upperCase);
    if (tmp.length() != modifiedvalue.length())
        latlong = true;

    modifiedvalue = StringUtils.removeStart(modifiedvalue.trim(), "(");
    modifiedvalue = StringUtils.removeStart(modifiedvalue.trim(), "[");
    modifiedvalue = StringUtils.removeEnd(modifiedvalue.trim(), ")");
    modifiedvalue = StringUtils.removeEnd(modifiedvalue.trim(), "]");

    String[] components = StringUtils.split(modifiedvalue, decimalSeparator == ',' ? " " : ","); //$NON-NLS-1$
    if (components.length == 1) {
        components = StringUtils.split(modifiedvalue, " "); //$NON-NLS-1$
    }
    if (components.length == 1) {
        components = StringUtils.split(modifiedvalue, ",");
    }
    if (components.length <= 1) {
        return null;
    }

    try {
        components[0] = StringUtils.stripEnd(components[0].trim(), ", ");
        double arg1 = components[0].contains(".") ? Double.parseDouble(components[0])
                : NumberFormat.getInstance().parse(components[0]).doubleValue();

        components[1] = StringUtils.stripEnd(components[1].trim(), ", ");
        double arg0 = components[1].contains(".") ? Double.parseDouble(components[1])
                : NumberFormat.getInstance().parse(components[1]).doubleValue();
        Coordinate coord = new Coordinate(arg1, arg0);
        if (latlong && crs != null) {
            try {
                JTS.transform(coord, coord, CRS.findMathTransform(DefaultGeographicCRS.WGS84, crs, true));
            } catch (Exception e) {
                ToolsPlugin.log(Messages.CursorPosition_transformError, e);
            }
        }
        return coord;
    } catch (NumberFormatException e) {
        return null;
    } catch (ParseException e1) {
        return null;
    } catch (Exception e1) {
        return null;
    }
}

From source file:de.sub.goobi.forms.SpracheForm.java

/**
 * The function getGroupingSeparator() returns the character used for
 * thousands separator for the current locale as read-only property
 * "groupingSeparator"./*from   ww w  .  j  a va  2s  .  co m*/
 *
 * @return the character used for thousands separator
 */
public char getGroupingSeparator() {
    return DecimalFormatSymbols.getInstance(getLocale()).getGroupingSeparator();
}

From source file:net.sf.jasperreports.charts.util.ChartUtil.java

public TickUnitSource createIntegerTickUnits(Locale locale) {
    DecimalFormatSymbols formatSymbols = DecimalFormatSymbols.getInstance(locale);

    // copied from NumberAxis.createIntegerTickUnits() to preserve backward behaviour
    TickUnits units = new TickUnits();
    DecimalFormat df0 = new DecimalFormat("0", formatSymbols);
    DecimalFormat df1 = new DecimalFormat("#,##0", formatSymbols);
    units.add(new NumberTickUnit(1, df0));
    units.add(new NumberTickUnit(2, df0));
    units.add(new NumberTickUnit(5, df0));
    units.add(new NumberTickUnit(10, df0));
    units.add(new NumberTickUnit(20, df0));
    units.add(new NumberTickUnit(50, df0));
    units.add(new NumberTickUnit(100, df0));
    units.add(new NumberTickUnit(200, df0));
    units.add(new NumberTickUnit(500, df0));
    units.add(new NumberTickUnit(1000, df1));
    units.add(new NumberTickUnit(2000, df1));
    units.add(new NumberTickUnit(5000, df1));
    units.add(new NumberTickUnit(10000, df1));
    units.add(new NumberTickUnit(20000, df1));
    units.add(new NumberTickUnit(50000, df1));
    units.add(new NumberTickUnit(100000, df1));
    units.add(new NumberTickUnit(200000, df1));
    units.add(new NumberTickUnit(500000, df1));
    units.add(new NumberTickUnit(1000000, df1));
    units.add(new NumberTickUnit(2000000, df1));
    units.add(new NumberTickUnit(5000000, df1));
    units.add(new NumberTickUnit(10000000, df1));
    units.add(new NumberTickUnit(20000000, df1));
    units.add(new NumberTickUnit(50000000, df1));
    units.add(new NumberTickUnit(100000000, df1));
    units.add(new NumberTickUnit(200000000, df1));
    units.add(new NumberTickUnit(500000000, df1));
    units.add(new NumberTickUnit(1000000000, df1));
    units.add(new NumberTickUnit(2000000000, df1));
    units.add(new NumberTickUnit(5000000000.0, df1));
    units.add(new NumberTickUnit(10000000000.0, df1));

    // adding further values by default because 1E10 is not enough for some people
    // using getNumberInstance because that's what NumberAxis.createIntegerTickUnits does
    units.add(new NumberTickUnit(20000000000L, df1));
    units.add(new NumberTickUnit(50000000000L, df1));
    units.add(new NumberTickUnit(100000000000L, df1));
    units.add(new NumberTickUnit(200000000000L, df1));
    units.add(new NumberTickUnit(500000000000L, df1));
    units.add(new NumberTickUnit(1000000000000L, df1));
    units.add(new NumberTickUnit(2000000000000L, df1));
    units.add(new NumberTickUnit(5000000000000L, df1));
    units.add(new NumberTickUnit(10000000000000L, df1));
    units.add(new NumberTickUnit(20000000000000L, df1));
    units.add(new NumberTickUnit(50000000000000L, df1));
    units.add(new NumberTickUnit(100000000000000L, df1));
    units.add(new NumberTickUnit(200000000000000L, df1));
    units.add(new NumberTickUnit(500000000000000L, df1));
    units.add(new NumberTickUnit(1000000000000000L, df1));
    units.add(new NumberTickUnit(2000000000000000L, df1));
    units.add(new NumberTickUnit(5000000000000000L, df1));
    units.add(new NumberTickUnit(10000000000000000L, df1));
    units.add(new NumberTickUnit(20000000000000000L, df1));
    units.add(new NumberTickUnit(50000000000000000L, df1));
    units.add(new NumberTickUnit(100000000000000000L, df1));
    units.add(new NumberTickUnit(200000000000000000L, df1));
    units.add(new NumberTickUnit(500000000000000000L, df1));
    units.add(new NumberTickUnit(1000000000000000000L, df1));
    units.add(new NumberTickUnit(2000000000000000000L, df1));
    units.add(new NumberTickUnit(5000000000000000000L, df1));

    return units;
}

From source file:org.structr.rest.servlet.CsvServlet.java

@Override
protected void doGet(final HttpServletRequest request, final HttpServletResponse response)
        throws UnsupportedEncodingException {

    SecurityContext securityContext = null;
    Authenticator authenticator = null;
    Result result = null;/*from w  w w. j av  a2  s .c o  m*/
    Resource resource = null;

    try {

        // isolate request authentication in a transaction
        try (final Tx tx = StructrApp.getInstance().tx()) {
            authenticator = config.getAuthenticator();
            securityContext = authenticator.initializeAndExamineRequest(request, response);
            tx.success();
        }
        final App app = StructrApp.getInstance(securityContext);

        //                      logRequest("GET", request);
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("text/csv; charset=utf-8");

        // set default value for property view
        propertyView.set(securityContext, defaultPropertyView);

        // evaluate constraints and measure query time
        double queryTimeStart = System.nanoTime();

        // isolate resource authentication
        try (final Tx tx = app.tx()) {

            resource = ResourceHelper.optimizeNestedResourceChain(
                    ResourceHelper.parsePath(securityContext, request, resourceMap, propertyView));
            authenticator.checkResourceAccess(securityContext, request, resource.getResourceSignature(),
                    propertyView.get(securityContext));

            tx.success();
        }

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

            String resourceSignature = resource.getResourceSignature();

            // let authenticator examine request again
            authenticator.checkResourceAccess(securityContext, request, resourceSignature,
                    propertyView.get(securityContext));

            // add sorting & paging
            String pageSizeParameter = request.getParameter(JsonRestServlet.REQUEST_PARAMETER_PAGE_SIZE);
            String pageParameter = request.getParameter(JsonRestServlet.REQUEST_PARAMETER_PAGE_NUMBER);
            String offsetId = request.getParameter(JsonRestServlet.REQUEST_PARAMETER_OFFSET_ID);
            String sortOrder = request.getParameter(JsonRestServlet.REQUEST_PARAMETER_SORT_ORDER);
            String sortKeyName = request.getParameter(JsonRestServlet.REQUEST_PARAMETER_SORT_KEY);
            boolean sortDescending = (sortOrder != null && "desc".equals(sortOrder.toLowerCase()));
            int pageSize = Services.parseInt(pageSizeParameter, NodeFactory.DEFAULT_PAGE_SIZE);
            int page = Services.parseInt(pageParameter, NodeFactory.DEFAULT_PAGE);
            PropertyKey sortKey = null;

            // set sort key
            if (sortKeyName != null) {

                Class<? extends GraphObject> type = resource.getEntityClass();

                sortKey = StructrApp.getConfiguration().getPropertyKeyForDatabaseName(type, sortKeyName, false);

            }

            // Should line breaks be removed?
            removeLineBreaks = StringUtils.equals(request.getParameter(REMOVE_LINE_BREAK_PARAM), "1");

            // Should a leading BOM be written?
            writeBom = StringUtils.equals(request.getParameter(WRITE_BOM), "1");

            // do action
            result = resource.doGet(sortKey, sortDescending, pageSize, page, offsetId);

            result.setIsCollection(resource.isCollectionResource());
            result.setIsPrimitiveArray(resource.isPrimitiveArray());

            // Integer rawResultCount = (Integer) Services.getAttribute(NodeFactory.RAW_RESULT_COUNT + Thread.currentThread().getId());
            PagingHelper.addPagingParameter(result, pageSize, page);

            // Services.removeAttribute(NodeFactory.RAW_RESULT_COUNT + Thread.currentThread().getId());
            // timing..
            double queryTimeEnd = System.nanoTime();

            // commit response
            if (result != null) {

                // store property view that will be used to render the results
                result.setPropertyView(propertyView.get(securityContext));

                // allow resource to modify result set
                resource.postProcessResultSet(result);

                DecimalFormat decimalFormat = new DecimalFormat("0.000000000",
                        DecimalFormatSymbols.getInstance(Locale.ENGLISH));

                result.setQueryTime(decimalFormat.format((queryTimeEnd - queryTimeStart) / 1000000000.0));

                Writer writer = response.getWriter();

                if (writeBom) {
                    writeUtf8Bom(writer);
                }

                // gson.toJson(result, writer);
                writeCsv(result, writer, propertyView.get(securityContext));
                response.setStatus(HttpServletResponse.SC_OK);
                writer.flush();
                writer.close();
            } else {

                logger.log(Level.WARNING, "Result was null!");

                int code = HttpServletResponse.SC_NO_CONTENT;

                response.setStatus(code);

                Writer writer = response.getWriter();

                // writer.append(jsonError(code, "Result was null!"));
                writer.flush();
                writer.close();

            }
            tx.success();
        }
    } catch (FrameworkException frameworkException) {

        // set status
        response.setStatus(frameworkException.getStatus());

        // gson.toJson(frameworkException, response.getWriter());
        //                      response.getWriter().println();
        //                      response.getWriter().flush();
        //                      response.getWriter().close();
    } catch (JsonSyntaxException jsex) {

        logger.log(Level.WARNING, "JsonSyntaxException in GET", jsex);

        int code = HttpServletResponse.SC_BAD_REQUEST;

        response.setStatus(code);

        // response.getWriter().append(jsonError(code, "JsonSyntaxException in GET: " + jsex.getMessage()));
    } catch (JsonParseException jpex) {

        logger.log(Level.WARNING, "JsonParseException in GET", jpex);

        int code = HttpServletResponse.SC_BAD_REQUEST;

        response.setStatus(code);

        // response.getWriter().append(jsonError(code, "JsonSyntaxException in GET: " + jpex.getMessage()));
    } catch (Throwable t) {

        logger.log(Level.WARNING, "Exception in GET", t);

        int code = HttpServletResponse.SC_INTERNAL_SERVER_ERROR;

        response.setStatus(code);

        // response.getWriter().append(jsonError(code, "JsonSyntaxException in GET: " + t.getMessage()));
    }

}