junit/src/org/apache/tapestry/junit/script/TestScript.java - tapestry3 - Git at Google

 //  Copyright 2004 The Apache Software Foundation
 //
 // Licensed 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.tapestry.junit.script;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;

 import org.apache.tapestry.IRequestCycle;
 import org.apache.tapestry.IResourceLocation;
 import org.apache.tapestry.IResourceResolver;
 import org.apache.tapestry.IScript;
 import org.apache.tapestry.junit.MockRequestCycle;
 import org.apache.tapestry.junit.TapestryTestCase;
 import org.apache.tapestry.resource.ClasspathResourceLocation;
 import org.apache.tapestry.script.ScriptParser;
 import org.apache.tapestry.script.ScriptSession;
 import org.apache.tapestry.util.DefaultResourceResolver;
 import org.apache.tapestry.util.xml.DocumentParseException;

 /**
  *  A collection of tests for Tapestry scripting.
  *
  *
  *  @author Howard Lewis Ship
  *  @version $Id$
  *  @since 2.2
  *
  **/

 public class TestScript extends TapestryTestCase
 {
     private MockScriptProcessor _processor = new MockScriptProcessor();

     private IScript read(String file) throws IOException, DocumentParseException
     {
         IResourceResolver resolver = new DefaultResourceResolver();
         ScriptParser parser = new ScriptParser(resolver);

         String classAsPath = "/" + getClass().getName().replace('.', '/');

         IResourceLocation classLocation = new ClasspathResourceLocation(resolver, classAsPath);
         IResourceLocation scriptLocation = classLocation.getRelativeLocation(file);

         return parser.parse(scriptLocation);
     }

     private IScript execute(String file, Map symbols) throws DocumentParseException, IOException
     {
         IScript script = read(file);

         script.execute(new MockRequestCycle(), _processor, symbols);

         return script;
     }

     private void assertSymbol(Map symbols, String key, Object expected)
     {
         Object actual = symbols.get(key);

         assertEquals(key, expected, actual);
     }

     /**
      *  Simple test where the body and initialization are static.
      *
      **/

     public void testSimple() throws Exception
     {
         execute("simple.script", null);

         assertEquals("body", "\nBODY\n", _processor.getBody());
         assertEquals("initialization", "\nINITIALIZATION\n", _processor.getInitialization());
         assertNull(_processor.getExternalScripts());
     }

     /**
      * Test the &lt;unique&gt; element, new in the 1.3 DTD
      * @since 3.0
      */

     public void testUnique() throws Exception
     {
         IScript script = read("unique.script");

         IRequestCycle cycle = new MockRequestCycle();

         script.execute(cycle, _processor, null);
         script.execute(cycle, _processor, null);

         assertEquals("Block1\nBlock2\nNotUnique\n\n\n\nNotUnique", _processor.getBody().trim());
     }

     /**
      *  Test omitting body and initialization, ensure they return null.
      *
      **/

     public void testEmpty() throws Exception
     {
         execute("empty.script", null);

         assertNull("body", _processor.getBody());
         assertNull("initialization", _processor.getInitialization());
     }

     /**
      *  Test the ability of the let element to create an output symbol.  Also,
      *  test the insert element.
      *
      **/

     public void testLet() throws Exception
     {
         String inputSymbol = Long.toHexString(System.currentTimeMillis());
         Map symbols = new HashMap();
         symbols.put("inputSymbol", inputSymbol);

         execute("let.script", symbols);

         // Unlike body, the let element trims whitespace.

         String outputSymbol = "output: " + inputSymbol;

         assertEquals("Output symbol", outputSymbol, symbols.get("outputSymbol"));
     }

     /**
      *  Tests the if element, using strings, numbers, booleans, nulls, arrays
      *  and collections.
      *
      **/

     public void testIf() throws Exception
     {
         Map input = new HashMap();

         input.put("true_string", "anything");
         input.put("false_string", " ");
         input.put("boolean_true", Boolean.TRUE);
         input.put("boolean_false", Boolean.FALSE);
         input.put("collection_non_empty", Collections.singletonList(Boolean.TRUE));
         input.put("collection_empty", new ArrayList());
         input.put("array_nonempty", new String[] { "alpha", "beta" });
         input.put("array_empty", new Integer[0]);
         input.put("number_zero", new Long(0));
         input.put("number_nonzero", new Integer(1));

         Map symbols = new HashMap();
         symbols.put("input", input);

         execute("if.script", symbols);

         assertSymbol(symbols, "output_true_string", "TRUE-STRING");
         assertSymbol(symbols, "output_false_string", "");
         assertSymbol(symbols, "output_null", "");
         assertSymbol(symbols, "output_boolean_true", "BOOLEAN-TRUE");
         assertSymbol(symbols, "output_boolean_false", "");
         assertSymbol(symbols, "output_collection_nonempty", "COLLECTION-NON-EMPTY");
         assertSymbol(symbols, "output_collection_empty", "");
         assertSymbol(symbols, "output_array_nonempty", "ARRAY-NON-EMPTY");
         assertSymbol(symbols, "output_array_empty", "");
         assertSymbol(symbols, "output_number_zero", "");
         assertSymbol(symbols, "output_number_nonzero", "NUMBER-NON-ZERO");
     }

     /**
      * Test the unique attribute on the &lt;let&gt; element.  New in
      * the 1.3 DTD
      * @since 3.0
      */
     public void testUniqueLet() throws Exception
     {
         Map symbols = new HashMap();

         execute("unique-let.script", symbols);

         assertSymbol(symbols, "alpha", "Alpha");
         assertSymbol(symbols, "beta", "Alpha$0");
         assertSymbol(symbols, "gamma", "Alpha$1");
     }

     /**
      *  Tests the if-not element.
      *
      **/

     public void testIfNot() throws Exception
     {
         Map input = new HashMap();

         input.put("trueString", "anything");
         input.put("falseString", " ");
         input.put("booleanTrue", Boolean.TRUE);
         input.put("booleanFalse", Boolean.FALSE);
         input.put("collectionNonEmpty", Collections.singletonList(Boolean.TRUE));
         input.put("collectionEmpty", new ArrayList());
         input.put("arrayNonempty", new String[] { "alpha", "beta" });
         input.put("arrayEmpty", new Integer[0]);
         input.put("numberZero", new Long(0));
         input.put("numberNonzero", new Integer(1));

         Map symbols = new HashMap();
         symbols.put("input", input);

         execute("if-not.script", symbols);

         assertSymbol(symbols, "outputTrueString", "");
         assertSymbol(symbols, "outputFalseString", "FALSE-STRING");
         assertSymbol(symbols, "outputNull", "NULL");
         assertSymbol(symbols, "outputBooleanTrue", "");
         assertSymbol(symbols, "outputBooleanFalse", "BOOLEAN-FALSE");
         assertSymbol(symbols, "outputCollectionNonempty", "");
         assertSymbol(symbols, "outputCollectionEmpty", "COLLECTION-EMPTY");
         assertSymbol(symbols, "outputArrayNonempty", "");
         assertSymbol(symbols, "outputArrayEmpty", "ARRAY-EMPTY");
         assertSymbol(symbols, "outputNumberZero", "NUMBER-ZERO");
         assertSymbol(symbols, "outputNumberNonzero", "");
     }

     /**
      *  Tests a bunch of variations on the foreach element.
      *
      **/

     public void testForeach() throws Exception
     {
         Map input = new HashMap();
         input.put("single", "SINGLE");
         input.put("emptyArray", new String[0]);
         input.put("array", new String[] { "ALPHA", "BETA", "GAMMA" });
         input.put("collection", Arrays.asList(new String[] { "MOE", "LARRY", "CURLY" }));
         input.put("emptyCollection", new ArrayList());

         Map symbols = new HashMap();
         symbols.put("input", input);

         execute("foreach.script", symbols);

         assertSymbol(symbols, "outputMissing", "");
         assertSymbol(symbols, "outputEmptyArray", "");
         assertSymbol(symbols, "outputEmptyCollection", "");
         assertSymbol(symbols, "outputSingle", "SINGLE");
         assertSymbol(symbols, "outputArray", "ALPHA\n\nBETA\n\nGAMMA");
         assertSymbol(symbols, "outputCollection", "MOE\n\nLARRY\n\nCURLY");

         // Tests for the "index" attribute
         assertSymbol(symbols, "outputMissingIndex", "");
         assertSymbol(symbols, "outputEmptyArrayIndex", "");
         assertSymbol(symbols, "outputEmptyCollectionIndex", "");
         assertSymbol(symbols, "outputSingleIndex", "SINGLE 0");
         assertSymbol(symbols, "outputArrayIndex", "ALPHA 0\n\nBETA 1\n\nGAMMA 2");
         assertSymbol(symbols, "outputCollectionIndex", "MOE 0\n\nLARRY 1\n\nCURLY 2");

         // Test implied key
         assertSymbol(symbols, "outputCollectionIndexOnly", "0\n\n1\n\n2");
     }

     public void testIncludeScript() throws Exception
     {
         IScript script = execute("include-script.script", null);

         IResourceLocation scriptLocation = script.getScriptLocation();

         IResourceLocation[] expected =
             new IResourceLocation[] {
                 scriptLocation.getRelativeLocation("first"),
                 scriptLocation.getRelativeLocation("second"),
                 scriptLocation.getRelativeLocation("third")};

         assertEquals(
             "included scripts",
             Arrays.asList(expected),
             Arrays.asList(_processor.getExternalScripts()));
     }

     public void testAntSyntax() throws Exception
     {
         Map form = new HashMap();

         form.put("name", "gallahad");

         Map component = new HashMap();
         component.put("form", form);
         component.put("name", "lancelot");

         Map symbols = new HashMap();
         symbols.put("component", component);

         execute("ant-syntax.script", symbols);

         assertSymbol(symbols, "functionName", "gallahad_lancelot");
         assertSymbol(symbols, "incomplete1", "Incomplete: $");
         assertSymbol(symbols, "incomplete2", "Incomplete: ${");
         assertSymbol(symbols, "nopath", "This ${} ends up as literal.");
         assertSymbol(symbols, "OGNL", "This is a brace: }.");
     }

     public void testSet() throws Exception
     {
         Map symbols = new HashMap();

         execute("set.script", symbols);

         assertSymbol(symbols, "element2", new Character('p'));
     }

     public void testInvalidKeyLet() throws Exception
     {
         try
         {
             execute("invalid-key-let.script", new HashMap());

             unreachable();
         }
         catch (DocumentParseException ex)
         {
             checkException(ex, "key");
         }
     }

     public void testInvalidKeySet() throws Exception
     {
         try
         {
             execute("invalid-key-Set.script", new HashMap());

             unreachable();
         }
         catch (DocumentParseException ex)
         {
             checkException(ex, "key");
         }
     }

     public void testInputSymbolClass() throws Exception
     {
         try
         {
             Map symbols = new HashMap();
             symbols.put("input", new Integer(20));

             execute("input-symbol-class.script", symbols);

             unreachable();
         }
         catch (Exception ex)
         {
             checkException(ex, "Integer");
             checkException(ex, "Long");
         }
     }

     public void testInputSymbol() throws Exception
     {
         Map symbols = new HashMap();
         symbols.put("input", new Long(20));

         execute("input-symbol.script", symbols);

         assertSymbol(symbols, "success", "Success");
     }

     public void testInputSymbolRequired() throws Exception
     {
         try
         {
             execute("input-symbol-required.script", new HashMap());

             unreachable();
         }
         catch (Exception ex)
         {
             checkException(ex, "required");
         }
     }

     public void testInputSymbolInvalidKey() throws Exception
     {
         try
         {
             execute("input-symbol-invalid-key.script", new HashMap());

             unreachable();
         }
         catch (DocumentParseException ex)
         {
             checkException(ex, "key");
         }

     }

     /** @since 3.0 */

     public void testNameAppend() throws Exception
     {
         Map symbols = new HashMap();

         symbols.put("name", "fred");
         execute("name-append.script", symbols);

         assertSymbol(symbols, "output", "fred$suffix");
     }

     /**
      * A bunch of quickies to push up the code coverage numbers.
      */
     public void testCheats() throws Exception
     {
         IScript script = execute("simple.script", null);

         ScriptSession session = new ScriptSession(script.getScriptLocation(), null, null, null);
         assertEquals("ScriptSession[" + script.getScriptLocation() + "]", session.toString());
     }
 }
	// Copyright 2004 The Apache Software Foundation
	//
	// Licensed 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.tapestry.junit.script;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.HashMap;
	import java.util.Map;

	import org.apache.tapestry.IRequestCycle;
	import org.apache.tapestry.IResourceLocation;
	import org.apache.tapestry.IResourceResolver;
	import org.apache.tapestry.IScript;
	import org.apache.tapestry.junit.MockRequestCycle;
	import org.apache.tapestry.junit.TapestryTestCase;
	import org.apache.tapestry.resource.ClasspathResourceLocation;
	import org.apache.tapestry.script.ScriptParser;
	import org.apache.tapestry.script.ScriptSession;
	import org.apache.tapestry.util.DefaultResourceResolver;
	import org.apache.tapestry.util.xml.DocumentParseException;

	/**
	* A collection of tests for Tapestry scripting.
	*
	*
	* @author Howard Lewis Ship
	* @version $Id$
	* @since 2.2
	*
	**/

	public class TestScript extends TapestryTestCase
	{
	private MockScriptProcessor _processor = new MockScriptProcessor();

	private IScript read(String file) throws IOException, DocumentParseException
	{
	IResourceResolver resolver = new DefaultResourceResolver();
	ScriptParser parser = new ScriptParser(resolver);

	String classAsPath = "/" + getClass().getName().replace('.', '/');

	IResourceLocation classLocation = new ClasspathResourceLocation(resolver, classAsPath);
	IResourceLocation scriptLocation = classLocation.getRelativeLocation(file);

	return parser.parse(scriptLocation);
	}

	private IScript execute(String file, Map symbols) throws DocumentParseException, IOException
	{
	IScript script = read(file);

	script.execute(new MockRequestCycle(), _processor, symbols);

	return script;
	}

	private void assertSymbol(Map symbols, String key, Object expected)
	{
	Object actual = symbols.get(key);

	assertEquals(key, expected, actual);
	}

	/**
	* Simple test where the body and initialization are static.
	*
	**/

	public void testSimple() throws Exception
	{
	execute("simple.script", null);

	assertEquals("body", "\nBODY\n", _processor.getBody());
	assertEquals("initialization", "\nINITIALIZATION\n", _processor.getInitialization());
	assertNull(_processor.getExternalScripts());
	}

	/**
	* Test the <unique> element, new in the 1.3 DTD
	* @since 3.0
	*/

	public void testUnique() throws Exception
	{
	IScript script = read("unique.script");

	IRequestCycle cycle = new MockRequestCycle();

	script.execute(cycle, _processor, null);
	script.execute(cycle, _processor, null);

	assertEquals("Block1\nBlock2\nNotUnique\n\n\n\nNotUnique", _processor.getBody().trim());
	}

	/**
	* Test omitting body and initialization, ensure they return null.
	*
	**/

	public void testEmpty() throws Exception
	{
	execute("empty.script", null);

	assertNull("body", _processor.getBody());
	assertNull("initialization", _processor.getInitialization());
	}

	/**
	* Test the ability of the let element to create an output symbol. Also,
	* test the insert element.
	*
	**/

	public void testLet() throws Exception
	{
	String inputSymbol = Long.toHexString(System.currentTimeMillis());
	Map symbols = new HashMap();
	symbols.put("inputSymbol", inputSymbol);

	execute("let.script", symbols);

	// Unlike body, the let element trims whitespace.

	String outputSymbol = "output: " + inputSymbol;

	assertEquals("Output symbol", outputSymbol, symbols.get("outputSymbol"));
	}

	/**
	* Tests the if element, using strings, numbers, booleans, nulls, arrays
	* and collections.
	*
	**/

	public void testIf() throws Exception
	{
	Map input = new HashMap();

	input.put("true_string", "anything");
	input.put("false_string", " ");
	input.put("boolean_true", Boolean.TRUE);
	input.put("boolean_false", Boolean.FALSE);
	input.put("collection_non_empty", Collections.singletonList(Boolean.TRUE));
	input.put("collection_empty", new ArrayList());
	input.put("array_nonempty", new String[] { "alpha", "beta" });
	input.put("array_empty", new Integer[0]);
	input.put("number_zero", new Long(0));
	input.put("number_nonzero", new Integer(1));

	Map symbols = new HashMap();
	symbols.put("input", input);

	execute("if.script", symbols);

	assertSymbol(symbols, "output_true_string", "TRUE-STRING");
	assertSymbol(symbols, "output_false_string", "");
	assertSymbol(symbols, "output_null", "");
	assertSymbol(symbols, "output_boolean_true", "BOOLEAN-TRUE");
	assertSymbol(symbols, "output_boolean_false", "");
	assertSymbol(symbols, "output_collection_nonempty", "COLLECTION-NON-EMPTY");
	assertSymbol(symbols, "output_collection_empty", "");
	assertSymbol(symbols, "output_array_nonempty", "ARRAY-NON-EMPTY");
	assertSymbol(symbols, "output_array_empty", "");
	assertSymbol(symbols, "output_number_zero", "");
	assertSymbol(symbols, "output_number_nonzero", "NUMBER-NON-ZERO");
	}

	/**
	* Test the unique attribute on the <let> element. New in
	* the 1.3 DTD
	* @since 3.0
	*/
	public void testUniqueLet() throws Exception
	{
	Map symbols = new HashMap();

	execute("unique-let.script", symbols);

	assertSymbol(symbols, "alpha", "Alpha");
	assertSymbol(symbols, "beta", "Alpha$0");
	assertSymbol(symbols, "gamma", "Alpha$1");
	}

	/**
	* Tests the if-not element.
	*
	**/

	public void testIfNot() throws Exception
	{
	Map input = new HashMap();

	input.put("trueString", "anything");
	input.put("falseString", " ");
	input.put("booleanTrue", Boolean.TRUE);
	input.put("booleanFalse", Boolean.FALSE);
	input.put("collectionNonEmpty", Collections.singletonList(Boolean.TRUE));
	input.put("collectionEmpty", new ArrayList());
	input.put("arrayNonempty", new String[] { "alpha", "beta" });
	input.put("arrayEmpty", new Integer[0]);
	input.put("numberZero", new Long(0));
	input.put("numberNonzero", new Integer(1));

	Map symbols = new HashMap();
	symbols.put("input", input);

	execute("if-not.script", symbols);

	assertSymbol(symbols, "outputTrueString", "");
	assertSymbol(symbols, "outputFalseString", "FALSE-STRING");
	assertSymbol(symbols, "outputNull", "NULL");
	assertSymbol(symbols, "outputBooleanTrue", "");
	assertSymbol(symbols, "outputBooleanFalse", "BOOLEAN-FALSE");
	assertSymbol(symbols, "outputCollectionNonempty", "");
	assertSymbol(symbols, "outputCollectionEmpty", "COLLECTION-EMPTY");
	assertSymbol(symbols, "outputArrayNonempty", "");
	assertSymbol(symbols, "outputArrayEmpty", "ARRAY-EMPTY");
	assertSymbol(symbols, "outputNumberZero", "NUMBER-ZERO");
	assertSymbol(symbols, "outputNumberNonzero", "");
	}

	/**
	* Tests a bunch of variations on the foreach element.
	*
	**/

	public void testForeach() throws Exception
	{
	Map input = new HashMap();
	input.put("single", "SINGLE");
	input.put("emptyArray", new String[0]);
	input.put("array", new String[] { "ALPHA", "BETA", "GAMMA" });
	input.put("collection", Arrays.asList(new String[] { "MOE", "LARRY", "CURLY" }));
	input.put("emptyCollection", new ArrayList());

	Map symbols = new HashMap();
	symbols.put("input", input);

	execute("foreach.script", symbols);

	assertSymbol(symbols, "outputMissing", "");
	assertSymbol(symbols, "outputEmptyArray", "");
	assertSymbol(symbols, "outputEmptyCollection", "");
	assertSymbol(symbols, "outputSingle", "SINGLE");
	assertSymbol(symbols, "outputArray", "ALPHA\n\nBETA\n\nGAMMA");
	assertSymbol(symbols, "outputCollection", "MOE\n\nLARRY\n\nCURLY");

	// Tests for the "index" attribute
	assertSymbol(symbols, "outputMissingIndex", "");
	assertSymbol(symbols, "outputEmptyArrayIndex", "");
	assertSymbol(symbols, "outputEmptyCollectionIndex", "");
	assertSymbol(symbols, "outputSingleIndex", "SINGLE 0");
	assertSymbol(symbols, "outputArrayIndex", "ALPHA 0\n\nBETA 1\n\nGAMMA 2");
	assertSymbol(symbols, "outputCollectionIndex", "MOE 0\n\nLARRY 1\n\nCURLY 2");

	// Test implied key
	assertSymbol(symbols, "outputCollectionIndexOnly", "0\n\n1\n\n2");
	}

	public void testIncludeScript() throws Exception
	{
	IScript script = execute("include-script.script", null);

	IResourceLocation scriptLocation = script.getScriptLocation();

	IResourceLocation[] expected =
	new IResourceLocation[] {
	scriptLocation.getRelativeLocation("first"),
	scriptLocation.getRelativeLocation("second"),
	scriptLocation.getRelativeLocation("third")};

	assertEquals(
	"included scripts",
	Arrays.asList(expected),
	Arrays.asList(_processor.getExternalScripts()));
	}

	public void testAntSyntax() throws Exception
	{
	Map form = new HashMap();

	form.put("name", "gallahad");

	Map component = new HashMap();
	component.put("form", form);
	component.put("name", "lancelot");

	Map symbols = new HashMap();
	symbols.put("component", component);

	execute("ant-syntax.script", symbols);

	assertSymbol(symbols, "functionName", "gallahad_lancelot");
	assertSymbol(symbols, "incomplete1", "Incomplete: $");
	assertSymbol(symbols, "incomplete2", "Incomplete: ${");
	assertSymbol(symbols, "nopath", "This ${} ends up as literal.");
	assertSymbol(symbols, "OGNL", "This is a brace: }.");
	}

	public void testSet() throws Exception
	{
	Map symbols = new HashMap();

	execute("set.script", symbols);

	assertSymbol(symbols, "element2", new Character('p'));
	}

	public void testInvalidKeyLet() throws Exception
	{
	try
	{
	execute("invalid-key-let.script", new HashMap());

	unreachable();
	}
	catch (DocumentParseException ex)
	{
	checkException(ex, "key");
	}
	}

	public void testInvalidKeySet() throws Exception
	{
	try
	{
	execute("invalid-key-Set.script", new HashMap());

	unreachable();
	}
	catch (DocumentParseException ex)
	{
	checkException(ex, "key");
	}
	}

	public void testInputSymbolClass() throws Exception
	{
	try
	{
	Map symbols = new HashMap();
	symbols.put("input", new Integer(20));

	execute("input-symbol-class.script", symbols);

	unreachable();
	}
	catch (Exception ex)
	{
	checkException(ex, "Integer");
	checkException(ex, "Long");
	}
	}

	public void testInputSymbol() throws Exception
	{
	Map symbols = new HashMap();
	symbols.put("input", new Long(20));

	execute("input-symbol.script", symbols);

	assertSymbol(symbols, "success", "Success");
	}

	public void testInputSymbolRequired() throws Exception
	{
	try
	{
	execute("input-symbol-required.script", new HashMap());

	unreachable();
	}
	catch (Exception ex)
	{
	checkException(ex, "required");
	}
	}

	public void testInputSymbolInvalidKey() throws Exception
	{
	try
	{
	execute("input-symbol-invalid-key.script", new HashMap());

	unreachable();
	}
	catch (DocumentParseException ex)
	{
	checkException(ex, "key");
	}

	}

	/** @since 3.0 */

	public void testNameAppend() throws Exception
	{
	Map symbols = new HashMap();

	symbols.put("name", "fred");
	execute("name-append.script", symbols);

	assertSymbol(symbols, "output", "fred$suffix");
	}

	/**
	* A bunch of quickies to push up the code coverage numbers.
	*/
	public void testCheats() throws Exception
	{
	IScript script = execute("simple.script", null);

	ScriptSession session = new ScriptSession(script.getScriptLocation(), null, null, null);
	assertEquals("ScriptSession[" + script.getScriptLocation() + "]", session.toString());
	}
	}