/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.commons.jexl3;

import org.apache.commons.jexl3.internal.Debugger;
import org.apache.commons.jexl3.internal.TemplateDebugger;
import org.apache.commons.jexl3.internal.TemplateScript;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.PrintWriter;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

/**
 * Test cases for the UnifiedEL.
 */
@SuppressWarnings({"UnnecessaryBoxing", "AssertEqualsBetweenInconvertibleTypes"})
@RunWith(Parameterized.class)
public class JXLTTest extends JexlTestCase {
    private static final Log LOGGER = LogFactory.getLog(JxltEngine.class);
    private final MapContext vars = new MapContext();
    private JexlEvalContext context = null;
    private final JexlEngine ENGINE;
    private final JxltEngine JXLT;
    
    public JXLTTest(JexlEngine jexl) {
        super("JXLTTest");
        ENGINE = jexl;
        JXLT = ENGINE.createJxltEngine();
    }
   

   @Parameterized.Parameters
   public static List<JexlEngine> engines() {
       JexlFeatures f = new JexlFeatures();
       f.lexical(true).lexicalShade(true);
      return Arrays.<JexlEngine>asList(new JexlEngine[] {
         new JexlBuilder().silent(false)
            .lexical(true).lexicalShade(true)
            .cache(128).strict(true).create(),
          
         new JexlBuilder().features(f).silent(false)
            .cache(128).strict(true).create(),
         
         new JexlBuilder().silent(false)
            .cache(128).strict(true).create(),
      });
   }
    
    @Before
    @Override
    public void setUp() throws Exception {
        // ensure jul logging is only error
        java.util.logging.Logger.getLogger(org.apache.commons.jexl3.JexlEngine.class.getName()).setLevel(java.util.logging.Level.SEVERE);
        context = new JexlEvalContext(vars);
    }

    @After
    @Override
    public void tearDown() throws Exception {
        debuggerCheck(ENGINE);
        super.tearDown();
    }
    
    private boolean isLexicalShade() {
        JexlOptions options = context.getEngineOptions();
        if (options.isLexicalShade()) {
            return true;
        }
        options = new JexlOptions().set(ENGINE);
        return options.isLexicalShade();
    }

    private static String refactor(TemplateDebugger td, JxltEngine.Template ts) {
        boolean dbg = td.debug((TemplateScript)ts);
        if (dbg) {
            return td.toString();
        } else {
            return "";
        }
    }

    /** Extract the source from a toString-ed expression. */
    private String getSource(String tostring) {
        int len = tostring.length();
        int sc = tostring.lastIndexOf(" /*= ");
        if (sc >= 0) {
            sc += " /*= ".length();
        }
        int ec = tostring.lastIndexOf(" */");
        if (sc >= 0 && ec >= 0 && ec > sc && ec < len) {
            return tostring.substring(sc, ec);
        } else {
            return tostring;
        }

    }

    public static class Froboz {
        int value;

        public Froboz(int v) {
            value = v;
        }

        public void setValue(int v) {
            value = v;
        }

        public int getValue() {
            return value;
        }

        public int plus10() {
            int i = value;
            value += 10;
            return i;
        }
    }

    @Test
    public void testStatement() throws Exception {
        Froboz froboz = new Froboz(32);
        context.set("froboz", froboz);
        JxltEngine.Expression check = JXLT.createExpression("${ froboz.plus10() }");
        Object o = check.evaluate(context);
        Assert.assertEquals("Result is not 32", new Integer(32), o);
        Assert.assertEquals("Result is not 42", 42, froboz.getValue());
        Set<List<String>> evars = check.getVariables();
        Assert.assertEquals(1, evars.size());
    }

    @Test
    public void testAssign() throws Exception {
        Froboz froboz = new Froboz(32);
        context.set("froboz", froboz);
        JxltEngine.Expression assign = JXLT.createExpression("${froboz.value = 42}");
        JxltEngine.Expression check = JXLT.createExpression("${froboz.value}");
        Object o = assign.evaluate(context);
        Assert.assertEquals("Result is not 10", new Integer(42), o);
        o = check.evaluate(context);
        Assert.assertEquals("Result is not 10", new Integer(42), o);
    }

    @Test
    public void testComposite() throws Exception {
        String source = "Dear ${p} ${name};";
        JxltEngine.Expression expr = JXLT.createExpression(source);
        context.set("p", "Mr");
        context.set("name", "Doe");
        Assert.assertTrue("expression should be immediate", expr.isImmediate());
        Object o = expr.evaluate(context);
        Assert.assertEquals("Dear Mr Doe;", o);
        context.set("p", "Ms");
        context.set("name", "Jones");
        o = expr.evaluate(context);
        Assert.assertEquals("Dear Ms Jones;", o);
        Assert.assertEquals(source, getSource(expr.toString()));
    }

    boolean contains(Set<List<String>> set, List<String> list) {
        for (List<String> sl : set) {
            if (sl.equals(list)) {
                return true;
            }
        }
        return false;
    }

    @Test
    public void testPrepareEvaluate() throws Exception {
        final String source = "Dear #{p} ${name};";
        JxltEngine.Expression expr = JXLT.createExpression("Dear #{p} ${name};");
        Assert.assertTrue("expression should be deferred", expr.isDeferred());

        Set<List<String>> evars = expr.getVariables();
        Assert.assertEquals(1, evars.size());
        Assert.assertTrue(contains(evars, Arrays.asList("name")));
        context.set("name", "Doe");
        JxltEngine.Expression phase1 = expr.prepare(context);
        String as = phase1.asString();
        Assert.assertEquals("Dear ${p} Doe;", as);
        Set<List<String>> evars1 = phase1.getVariables();
        Assert.assertEquals(1, evars1.size());
        Assert.assertTrue(contains(evars1, Arrays.asList("p")));
        vars.clear();
        context.set("p", "Mr");
        context.set("name", "Should not be used in 2nd phase");
        Object o = phase1.evaluate(context);
        Assert.assertEquals("Dear Mr Doe;", o);

        String p1 = getSource(phase1.toString());
        Assert.assertEquals(source, getSource(phase1.toString()));
        Assert.assertEquals(source, getSource(expr.toString()));
    }

    @Test
    public void testNested() throws Exception {
        final String source = "#{${hi}+'.world'}";
        JxltEngine.Expression expr = JXLT.createExpression(source);

        Set<List<String>> evars = expr.getVariables();
        Assert.assertEquals(1, evars.size());
        Assert.assertTrue(contains(evars, Arrays.asList("hi")));

        context.set("hi", "greeting");
        context.set("greeting.world", "Hello World!");
        Assert.assertTrue("expression should be deferred", expr.isDeferred());
        Object o = expr.evaluate(context);
        Assert.assertEquals("Hello World!", o);

        Assert.assertEquals(source, getSource(expr.toString()));
    }

    @Test
    public void testNestedTemplate() throws Exception {
        final String source = "#{${hi}+'.world'}";
        JxltEngine.Template expr = JXLT.createTemplate(source, "hi");

        context.set("greeting.world", "Hello World!");
        StringWriter strw = new StringWriter();
        expr.evaluate(context, strw, "greeting");
        String o = strw.toString();
        Assert.assertEquals("Hello World!", o);

        Assert.assertEquals(source, getSource(expr.toString()));
    }

    @Test
    public void testImmediate() throws Exception {
        JexlContext none = null;
        final String source = "${'Hello ' + 'World!'}";
        JxltEngine.Expression expr = JXLT.createExpression(source);
        JxltEngine.Expression prepared = expr.prepare(none);
        Assert.assertEquals("prepare should return same expression", "Hello World!", prepared.asString());
        Object o = expr.evaluate(none);
        Assert.assertTrue("expression should be immediate", expr.isImmediate());
        Assert.assertEquals("Hello World!", o);

        Assert.assertEquals(source, getSource(expr.toString()));
    }

    @Test
    public void testConstant() throws Exception {
        JexlContext none = null;
        final String source = "Hello World!";
        JxltEngine.Expression expr = JXLT.createExpression(source);
        Assert.assertTrue("prepare should return same expression", expr.prepare(none) == expr);
        Object o = expr.evaluate(none);
        Assert.assertTrue("expression should be immediate", expr.isImmediate());
        Assert.assertEquals("Hello World!", o);

        Assert.assertEquals(source, getSource(expr.toString()));
    }

    @Test
    public void testConstant2() throws Exception {
        JexlContext none = null;
        final String source = "${size({'map':123,'map2':456})}";
        JxltEngine.Expression expr = JXLT.createExpression(source);
        //Assert.assertTrue("prepare should return same expression", expr.prepare(none) == expr);
        Object o = expr.evaluate(none);
        Assert.assertTrue("expression should be immediate", expr.isImmediate());
        Assert.assertEquals(2, o);

        Assert.assertEquals(source, getSource(expr.toString()));
    }

    @Test
    public void testConstant3() throws Exception {
        JexlContext none = null;
        final String source = "#{size({'map':123,'map2':456})}";
        JxltEngine.Expression expr = JXLT.createExpression(source);
        //Assert.assertTrue("prepare should return same expression", expr.prepare(none) == expr);
        Object o = expr.evaluate(none);
        Assert.assertTrue("expression should be deferred", expr.isDeferred());
        Assert.assertEquals(2, o);

        Assert.assertEquals(source, getSource(expr.toString()));
    }

    @Test
    public void testConstant4() throws Exception {
        JexlContext none = null;
        final String source = "#{ ${size({'1':2,'2': 3})} }";
        JxltEngine.Expression expr = JXLT.createExpression(source);
        //Assert.assertTrue("prepare should return same expression", expr.prepare(none) == expr);
        Object o = expr.evaluate(none);
        Assert.assertTrue("expression should be deferred", expr.isDeferred());
        Assert.assertEquals(2, o);

        Assert.assertEquals(source, getSource(expr.toString()));
    }

    @Test
    public void testDeferred() throws Exception {
        JexlContext none = null;
        final String source = "#{'world'}";
        JxltEngine.Expression expr = JXLT.createExpression(source);
        Assert.assertTrue("expression should be deferred", expr.isDeferred());
        String as = expr.prepare(none).asString();
        Assert.assertEquals("prepare should return immediate version", "${'world'}", as);
        Object o = expr.evaluate(none);
        Assert.assertEquals("world", o);

        Assert.assertEquals(source, getSource(expr.toString()));
    }

    @Test
    public void testEscape() throws Exception {
        JexlContext none = null;
        JxltEngine.Expression expr;
        Object o;
        // $ and # are escapable in TemplateEngine
        expr = JXLT.createExpression("\\#{'world'}");
        o = expr.evaluate(none);
        Assert.assertEquals("#{'world'}", o);
        expr = JXLT.createExpression("\\${'world'}");
        o = expr.evaluate(none);
        Assert.assertEquals("${'world'}", o);
    }

    @Test
    public void testEscapeString() throws Exception {
        JxltEngine.Expression expr = JXLT.createExpression("\\\"${'world\\'s finest'}\\\"");
        JexlContext none = null;
        Object o = expr.evaluate(none);
        Assert.assertEquals("\"world's finest\"", o);
    }

    @Test
    public void testNonEscapeString() throws Exception {
        JxltEngine.Expression expr = JXLT.createExpression("c:\\some\\windows\\path");
        JexlContext none = null;
        Object o = expr.evaluate(none);
        Assert.assertEquals("c:\\some\\windows\\path", o);
    }

    @Test
    public void testMalformed() throws Exception {
        try {
            JxltEngine.Expression expr = JXLT.createExpression("${'world'");
            JexlContext none = null;
            expr.evaluate(none);
            Assert.fail("should be malformed");
        } catch (JxltEngine.Exception xjexl) {
            // expected
            String xmsg = xjexl.getMessage();
            LOGGER.warn(xmsg);
        }
    }

    @Test
    public void testMalformedNested() throws Exception {
        try {
            JxltEngine.Expression expr = JXLT.createExpression("#{${hi} world}");
            JexlContext none = null;
            expr.evaluate(none);
            Assert.fail("should be malformed");
        } catch (JxltEngine.Exception xjexl) {
            // expected
            String xmsg = xjexl.getMessage();
            LOGGER.warn(xmsg);
        }
    }

    @Test
    public void testMalformedNested2() throws Exception {
        try {
            JxltEngine.Expression expr = JXLT.createExpression("#{${hi} world}");
            JexlContext ctxt = new MapContext();
            ctxt.set("hi", "hello");
            expr.evaluate(ctxt);
            Assert.fail("should be malformed");
        } catch (JxltEngine.Exception xjexl) {
            // expected
            String xmsg = xjexl.getMessage();
            LOGGER.warn(xmsg);
        }
    }

    @Test
    public void testBadContextNested() throws Exception {
        try {
            JxltEngine.Expression expr = JXLT.createExpression("#{${hi}+'.world'}");
            JexlContext none = null;
            expr.evaluate(none);
            Assert.fail("should be malformed");
        } catch (JxltEngine.Exception xjexl) {
            // expected
            String xmsg = xjexl.getMessage();
            LOGGER.warn(xmsg);
        }
    }

    @Test
    public void testCharAtBug() throws Exception {
        context.set("foo", "abcdef");
        JexlOptions options = context.getEngineOptions();
        JxltEngine.Expression expr = JXLT.createExpression("${foo.substring(2,4)/*comment*/}");
        Object o = expr.evaluate(context);
        Assert.assertEquals("cd", o);

        context.set("bar", "foo");
        try {
            options.setSilent(true);
            expr = JXLT.createExpression("#{${bar}+'.charAt(-2)'}");
            expr = expr.prepare(context);
            o = expr.evaluate(context);
            Assert.assertEquals(null, o);
        } finally {
            options.setSilent(false);
        }

    }

    @Test
    public void testTemplate0() throws Exception {
        String source = "   $$ if(x) {\nx is ${x}\n   $$ } else {\n${'no x'}\n$$ }\n";
        StringWriter strw;
        String output;

        JxltEngine.Template t = JXLT.createTemplate(source);

        context.set("x", 42);
        strw = new StringWriter();
        t.evaluate(context, strw);
        output = strw.toString();
        Assert.assertEquals("x is 42\n", output);

        strw = new StringWriter();
        context.set("x", "");
        t.evaluate(context, strw);
        output = strw.toString();
        Assert.assertEquals("no x\n", output);

        String dstr = t.toString();
        Assert.assertNotNull(dstr);
    }

    @Test
    public void testTemplate10() throws Exception {
        String source = "$$(x)->{ if(x) {\nx is ${x}\n$$ } else {\n${'no x'}\n$$ } }\n";
        StringWriter strw;
        String output;

        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(source), (String[]) null);
        String dstr = t.asString();
        Assert.assertNotNull(dstr);

        String[] ps = t.getParameters();
        Assert.assertTrue(Arrays.asList(ps).contains("x"));

        strw = new StringWriter();
        t.evaluate(context, strw, 42);
        output = strw.toString();
        Assert.assertEquals("x is 42\n", output);
    }

    @Test
    public void testTemplate1() throws Exception {
        String source = "$$ if(x) {\nx is ${x}\n$$ } else {\n${'no x'}\n$$ }\n";
        StringWriter strw;
        String output;

        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(source), "x");
        String dstr = t.asString();
        Assert.assertNotNull(dstr);

        strw = new StringWriter();
        t.evaluate(context, strw, 42);
        output = strw.toString();
        Assert.assertEquals("x is 42\n", output);

        strw = new StringWriter();
        t.evaluate(context, strw, "");
        output = strw.toString();
        Assert.assertEquals("no x\n", output);
    }

    @Test
    public void testTemplate2() throws Exception {
        String source = "The answer: ${x}";
        StringWriter strw;
        String output;

        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(source), "x");
        String dstr = t.asString();
        Assert.assertNotNull(dstr);

        strw = new StringWriter();
        t.evaluate(context, strw, 42);
        output = strw.toString();
        Assert.assertEquals("The answer: 42", output);
    }

    @Test
    public void testPrepareTemplate() throws Exception {
        String source
                = "$$ for(var x : list) {\n"
                + "${l10n}=#{x}\n"
                + "$$ }\n";
        int[] args = {42};
        JxltEngine.Template tl10n = JXLT.createTemplate(source, "list");
        String dstr = tl10n.asString();
        Assert.assertNotNull(dstr);
        Set<List<String>> vars = tl10n.getVariables();
        Assert.assertFalse(vars.isEmpty());
        context.set("l10n", "valeur");
        JxltEngine.Template tpFR = tl10n.prepare(context);
        context.set("l10n", "value");
        JxltEngine.Template tpEN = tl10n.prepare(context);
        context.set("l10n", null);

        StringWriter strw;
        strw = new StringWriter();
        tpFR.evaluate(context, strw, args);
        String outFR = strw.toString();
        Assert.assertEquals("valeur=42\n", outFR);

        context.set("l10n", null);
        strw = new StringWriter();
        tpEN.evaluate(context, strw, args);
        String outEN = strw.toString();
        Assert.assertEquals("value=42\n", outEN);
    }

    @Test
    public void test42() throws Exception {
        String test42
                = "$$ for(var x : list) {\n"
                + "$$   if (x == 42) {\n"
                + "Life, the universe, and everything\n"
                + "$$   } else if (x > 42) {\n"
                + "The value ${x} is over fourty-two\n"
                + "$$   } else {\n"
                + "The value ${x} is under fourty-two\n"
                + "$$   }\n"
                + "$$ }\n";
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(test42), "list");
        StringWriter strw = new StringWriter();
        int[] list = {1, 3, 5, 42, 169};
        t.evaluate(context, strw, list);
        String output = strw.toString();
        String out42
                = "The value 1 is under fourty-two\n"
                + "The value 3 is under fourty-two\n"
                + "The value 5 is under fourty-two\n"
                + "Life, the universe, and everything\n"
                + "The value 169 is over fourty-two\n";
        Assert.assertEquals(out42, output);

        String dstr = t.asString();
        Assert.assertNotNull(dstr);

        TemplateDebugger td = new TemplateDebugger();
        String refactored = refactor(td, (TemplateScript) t);
        Assert.assertNotNull(refactored);
        Assert.assertEquals(test42, refactored);
    }
    
    @Test
    public void testInheritedDebugger() throws Exception {
        String src = "if ($A) { $B + 1; } else { $C - 2 }";
        JexlEngine jexl = JXLT.getEngine();
        JexlScript script = jexl.createScript(src);
                
        Debugger sd = new Debugger();
        String rscript = sd.debug(script)? sd.toString() : null;
        Assert.assertNotNull(rscript);
        
        TemplateDebugger td = new TemplateDebugger();
        String refactored = td.debug(script)? td.toString() : null;
        Assert.assertNotNull(refactored);
        Assert.assertEquals(refactored, rscript);
    }

    public static class FrobozWriter extends PrintWriter {
        public FrobozWriter(Writer w) {
            super(w);
        }

        public void print(Froboz froboz) {
            super.print("froboz{");
            super.print(froboz.value);
            super.print("}");
        }

        @Override
        public String toString() {
            return out.toString();
        }
    }

    @Test
    public void testWriter() throws Exception {
        Froboz froboz = new Froboz(42);
        Writer writer = new FrobozWriter(new StringWriter());
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader("$$$jexl.print(froboz)"), "froboz");
        t.evaluate(context, writer, froboz);
        Assert.assertEquals("froboz{42}", writer.toString());
    }

    @Test
    public void testReport() throws Exception {
        String rpt
                = "<report>\n"
                + "\n"
                + "\n$$ var a = 1;"
                + "\n$$ var x = 2;"
                + "\n"
                + "\n$$ var y = 9;"
                + "\n"
                + "\n        ${x + y}"
                + "\n</report>\n";
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(rpt));
        StringWriter strw = new StringWriter();
        t.evaluate(context, strw);
        String output = strw.toString();
        String ctl = "<report>\n\n\n\n\n        11\n</report>\n";
        Assert.assertEquals(ctl, output);

        TemplateDebugger td = new TemplateDebugger();
        String refactored = refactor(td, (TemplateScript) t);
        Assert.assertNotNull(refactored);
        Assert.assertEquals(rpt, refactored);
    }

    @Test
    public void testReport1() throws Exception {
        String rpt
                = "<report>\n"
                + "this is ${x}\n"
                + "${x + 1}\n"
                + "${x + 2}\n"
                + "${x + 3}\n"
                + "</report>\n";
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(rpt));
        StringWriter strw = new StringWriter();
        context.set("x", 42);
        t.evaluate(context, strw, 42);
        String output = strw.toString();
        int count = 0;
        for (int i = 0; i < output.length(); ++i) {
            char c = output.charAt(i);
            if ('\n' == c) {
                count += 1;
            }
        }
        Assert.assertEquals(6, count);
        Assert.assertTrue(output.indexOf("42") > 0);
        Assert.assertTrue(output.indexOf("43") > 0);
        Assert.assertTrue(output.indexOf("44") > 0);
        Assert.assertTrue(output.indexOf("45") > 0);
    }

    @Test
    public void testReport2() throws Exception {
        String rpt
                = "<report>\n"
                + "this is ${x}\n"
                + "${x + 1}\n"
                + "${x + 2}\n"
                + "${x + 3}\n"
                + "</report>\n";
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(rpt), "x");
        StringWriter strw = new StringWriter();
        t.evaluate(context, strw, 42);
        String output = strw.toString();
        int count = 0;
        for (int i = 0; i < output.length(); ++i) {
            char c = output.charAt(i);
            if ('\n' == c) {
                count += 1;
            }
        }
        Assert.assertEquals(6, count);
        Assert.assertTrue(output.indexOf("42") > 0);
        Assert.assertTrue(output.indexOf("43") > 0);
        Assert.assertTrue(output.indexOf("44") > 0);
        Assert.assertTrue(output.indexOf("45") > 0);

        TemplateDebugger td = new TemplateDebugger();
        String xxx = refactor(td, (TemplateScript) t);
        Assert.assertNotNull(xxx);
        Assert.assertEquals(rpt, xxx);
    }
    @Test
    public void testOneLiner() throws Exception {
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader("fourty-two"));
        StringWriter strw = new StringWriter();
        t.evaluate(context, strw);
        String output = strw.toString();
        Assert.assertEquals("fourty-two", output);
    }

    @Test
    public void testOneLinerVar() throws Exception {
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader("fourty-${x}"));
        StringWriter strw = new StringWriter();
        context.set("x", "two");
        t.evaluate(context, strw);
        String output = strw.toString();
        Assert.assertEquals("fourty-two", output);
    }

    @Test
    public void testInterpolation() throws Exception {
        String expr =  "`Hello \n${user}`";
        JexlScript script = ENGINE.createScript(expr);
        context.set("user", "Dimitri");
        Object value = script.execute(context);
        Assert.assertEquals(expr, "Hello \nDimitri", value);
        context.set("user", "Rahul");
        value = script.execute(context);
        Assert.assertEquals(expr, "Hello \nRahul", value);
    }

    @Test
    public void testInterpolationGlobal() throws Exception {
        if (isLexicalShade()) {
            context.set("user", null);
        }
        String expr =  "user='Dimitri'; `Hello \n${user}`";
        Object value = ENGINE.createScript(expr).execute(context);
        Assert.assertEquals(expr, "Hello \nDimitri", value);
    }

    @Test
    public void testInterpolationLocal() throws Exception {
        String expr =  "var user='Henrib'; `Hello \n${user}`";
        Object value = ENGINE.createScript(expr).execute(context);
        Assert.assertEquals(expr, "Hello \nHenrib", value);
    }

    @Test
    public void testInterpolationLvsG() throws Exception {
        if (isLexicalShade()) {
            context.set("user", null);
        }
        String expr =  "user='Dimitri'; var user='Henrib'; `H\\\"ello \n${user}`";
        Object value = ENGINE.createScript(expr).execute(context);
        Assert.assertEquals(expr, "H\"ello \nHenrib", value);
    }
        
    @Test
    public void testInterpolationLvsG2() throws Exception {
        if (isLexicalShade()) {
            context.set("user", null);
        }
        String expr =  "user='Dimitri'; var user='Henrib'; `H\\`ello \n${user}`";
        Object value = ENGINE.createScript(expr).execute(context);
        Assert.assertEquals(expr, "H`ello \nHenrib", value);
    }

    @Test
    public void testInterpolationParameter() throws Exception {
        String expr =  "(user)->{`Hello \n${user}`}";
        Object value = ENGINE.createScript(expr).execute(context, "Henrib");
        Assert.assertEquals(expr, "Hello \nHenrib", value);
        value = ENGINE.createScript(expr).execute(context, "Dimitri");
        Assert.assertEquals(expr, "Hello \nDimitri", value);
    }

    @Test
    public void testImmediateTemplate() throws Exception {
        context.set("tables", new String[]{"table1", "table2"});
        context.set("w" ,"x=1");
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(
             "select * from \n"+
             "$$var comma = false; \n"+
             "$$for(var c : tables) { \n"+
             "$$  if (comma) $jexl.write(','); else comma = true;\n"+
             "${c}"+
             "\n$$}\n"+
             "where ${w}\n"
        ));
        StringWriter strw = new StringWriter();
        //vars.clear();
        t.evaluate(context, strw);
        String output = strw.toString();
        Assert.assertTrue(output.contains("table1") && output.contains("table2"));
    }  

    public static class Executor311 {
        private final String name;
        
        public Executor311(String name) {
            this.name = name;
        }
        // Injects name as first arg of any called script
        public Object execute(JexlScript script, Object ...args) {
            Object[] actuals;
            if (args != null && args.length > 0) {
                actuals = new Object[args.length + 1] ;
                System.arraycopy(args, 0, actuals, 1, args.length);
                actuals[0] = name;
            } else {
                actuals = new Object[]{name};
            }
            return script.execute(JexlEngine.getThreadContext(), actuals);
        }
    }
    
    public static class Context311 extends MapContext 
      implements JexlContext.OptionsHandle, JexlContext.ThreadLocal {
        private JexlOptions options = null;
        
        public void setOptions(JexlOptions o) {
            options = o;
        }
        
        public Executor311 exec(String name) {
            return new Executor311(name);
        }

        @Override
        public JexlOptions getEngineOptions() {
            return options;
        }
        
        JexlOptions newOptions() {
            options = new JexlOptions();
            return options;
        }
    }
    
    @Test
    public void test311a() throws Exception {
        JexlContext ctx = null;
        String rpt
                = "$$((a)->{\n"
                + "<p>Universe ${a}</p>\n"
                + "$$})(42)";
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(rpt));
        StringWriter strw = new StringWriter();
        t.evaluate(ctx, strw);
        String output = strw.toString();
        Assert.assertEquals("<p>Universe 42</p>\n", output);
    }

    @Test
    public void test311b() throws Exception {
        JexlContext ctx311 = new Context311();
        String rpt
                = "$$ exec('42').execute(()->{\n"
                + "<p>Universe 42</p>\n"
                + "$$})";
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(rpt));
        StringWriter strw = new StringWriter();
        t.evaluate(ctx311, strw, 42);
        String output = strw.toString();
        Assert.assertEquals("<p>Universe 42</p>\n", output);
    }
    
    @Test
    public void test311c() throws Exception {
        Context311 ctx311 = new Context311();
        ctx311.newOptions().setLexical(true);
        String rpt
                = "$$ exec('42').execute((a)->{"
                + "\n<p>Universe ${a}</p>"
                + "\n$$})";
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(rpt));
        StringWriter strw = new StringWriter();
        t.evaluate(ctx311, strw, 42);
        String output = strw.toString();
        Assert.assertEquals("<p>Universe 42</p>\n", output);
    }
       
    @Test
    public void test311d() throws Exception {
        Context311 ctx311 = new Context311();
        ctx311.newOptions().setLexical(true);
        String rpt
                = "$$ exec('4').execute((a, b)->{"
                + "\n<p>Universe ${a}${b}</p>"
                + "\n$$}, '2')";
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(rpt));
        StringWriter strw = new StringWriter();
        t.evaluate(ctx311, strw, 42);
        String output = strw.toString();
        Assert.assertEquals("<p>Universe 42</p>\n", output);
    }
    
    @Test
    public void test311e() throws Exception {
        Context311 ctx311 = new Context311();
        ctx311.newOptions().setLexical(true);
        String rpt
                = "exec('4').execute((a, b)->{"
                + " '<p>Universe ' + a + b + '</p>'"
                + "}, '2')";
        JexlScript script = JEXL.createScript(rpt);
        String output = script.execute(ctx311, 42).toString();
        Assert.assertEquals("<p>Universe 42</p>", output);
    } 
    
    @Test
    public void test311f() throws Exception {
        Context311 ctx311 = new Context311();
        ctx311.newOptions().setLexical(true);
        String rpt
                = "exec('4').execute((a, b)->{"
                + " `<p>Universe ${a}${b}</p>`"
                + "}, '2')";
        JexlScript script = JEXL.createScript(rpt);
        String output = script.execute(ctx311, 42).toString();
        Assert.assertEquals("<p>Universe 42</p>", output);
    }
           
    @Test
    public void test311g() throws Exception {
        Context311 ctx311 = new Context311();
        ctx311.newOptions().setLexical(true);
        String rpt
                = "(a, b)->{"
                + " `<p>Universe ${a}${b}</p>`"
                + "}";
        JexlScript script = JEXL.createScript(rpt);
        String output = script.execute(ctx311, "4", "2").toString();
        Assert.assertEquals("<p>Universe 42</p>", output);
    }  
               
    @Test
    public void test311h() throws Exception {
        Context311 ctx311 = new Context311();
        ctx311.newOptions().setLexical(true);
        String rpt= " `<p>Universe ${a}${b}</p>`";
        JexlScript script = JEXL.createScript(rpt, "a", "b");
        String output = script.execute(ctx311, "4", "2").toString();
        Assert.assertEquals("<p>Universe 42</p>", output);
    }   
    
    @Test
    public void test311i() throws Exception {
        JexlContext ctx311 = new Context311();
        String rpt
                = "$$var u = 'Universe'; exec('4').execute((a, b)->{"
                + "\n<p>${u} ${a}${b}</p>"
                + "\n$$}, '2')";
        JxltEngine.Template t = JXLT.createTemplate("$$", new StringReader(rpt));
        StringWriter strw = new StringWriter();
        t.evaluate(ctx311, strw, 42);
        String output = strw.toString();
        Assert.assertEquals("<p>Universe 42</p>\n", output);
    }
    
    @Test
    public void test315() throws Exception {
        String s315;
        StringWriter strw;
        JxltEngine.Template t315;
        String output;
        
        s315 = "<report/>$";
        t315 = JXLT.createTemplate("$$", new StringReader(s315));
        strw = new StringWriter();
        t315.evaluate(context, strw);
        output = strw.toString();
        Assert.assertEquals(s315, output);
        
        s315 = "<foo/>#";
        t315 = JXLT.createTemplate("$$", new StringReader(s315));
         strw = new StringWriter();
        t315.evaluate(context, strw);
        output = strw.toString();
        Assert.assertEquals(s315, output);
        
        s315 = "<bar/>\\";
        t315 = JXLT.createTemplate("$$", new StringReader(s315));
        strw = new StringWriter();
        t315.evaluate(context, strw);
        output = strw.toString();
        Assert.assertEquals(s315, output);
    }
    
        // define mode pro50
    static final JexlOptions MODE_PRO50 = new JexlOptions();
    static {
        MODE_PRO50.setFlags( "+strict +cancellable +lexical +lexicalShade -safe".split(" "));
    }

    public static class PragmaticContext extends MapContext implements JexlContext.PragmaProcessor, JexlContext.OptionsHandle {
        private final JexlOptions options;

        public PragmaticContext(JexlOptions o) {
            this.options = o;
        }

        @Override
        public void processPragma(String key, Object value) {
            if ("script.mode".equals(key) && "pro50".equals(value)) {
                options.set(MODE_PRO50);
            }
        }

        @Override
        public Object get(String name) {
            if ("$options".equals(name)) {
                return options;
            }
            return super.get(name);
        }

        @Override
        public JexlOptions getEngineOptions() {
            return options;
        }
    }
    
    @Test
    public void testLexicalTemplate() throws Exception {
        JexlOptions opts = new JexlOptions();
        JexlContext ctxt = new PragmaticContext(opts);
        opts.setCancellable(false);
        opts.setStrict(false);
        opts.setSafe(true);
        opts.setLexical(false);
        opts.setLexicalShade(false);
        String src0 = "${$options.strict?'+':'-'}strict"
                + " ${$options.cancellable?'+':'-'}cancellable"
                + " ${$options.lexical?'+':'-'}lexical"
                + " ${$options.lexicalShade?'+':'-'}lexicalShade"
                + " ${$options.safe?'+':'-'}safe";
        
        JxltEngine.Template tmplt0 = JXLT.createTemplate("$$", new StringReader(src0));
        Writer strw0 = new StringWriter();
        tmplt0.evaluate(ctxt, strw0);
        String output0 = strw0.toString();
        Assert.assertEquals( "-strict -cancellable -lexical -lexicalShade +safe", output0);
                
        String src = "$$ #pragma script.mode pro50\n" + src0;
            
        JxltEngine.Template tmplt = JXLT.createTemplate("$$", new StringReader(src));
        Writer strw = new StringWriter();
        tmplt.evaluate(ctxt, strw);
        String output = strw.toString();
        Assert.assertEquals("+strict +cancellable +lexical +lexicalShade -safe", output);
    }

    @Test
    public void testTemplatePragmaPro50() throws Exception {
        JexlOptions opts = new JexlOptions();
        opts.setCancellable(false);
        opts.setStrict(false);
        opts.setSafe(true);
        opts.setLexical(false);
        opts.setLexicalShade(false);
        opts.setSharedInstance(true);
        JexlContext ctxt = new PragmaticContext(opts);
        String src = "$$ #pragma script.mode pro50\n"
                + "$$ var tab = null;\n"
                + "$$ tab.dummy();";
        JxltEngine.Template tmplt = JXLT.createTemplate("$$", new StringReader(src));
        Writer strw = new StringWriter();
        try {
            tmplt.evaluate(ctxt, strw);
            Assert.fail("tab var is null");
        } catch (JexlException.Variable xvar) {
            Assert.assertTrue("tab".equals(xvar.getVariable()));
            Assert.assertFalse(xvar.isUndefined());
        }
    }
}