bsf3/bsf-api/src/test/java/org/apache/bsf/ScriptEngineManagerTest.java

/*
 * 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.bsf;

import java.util.List;

import javax.script.Compilable;
import javax.script.CompiledScript;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.script.SimpleBindings;

import junit.framework.TestCase;

import org.apache.bsf.utils.TestScriptEngine;
import org.apache.bsf.utils.TestScriptEngineFactory;

public class ScriptEngineManagerTest extends TestCase {
	private ScriptEngineManager mgr = null;
	
	public ScriptEngineManagerTest() {
		super("ScriptEngineManagerTest");
	}
	
	protected void setUp() throws Exception {
		super.setUp();
		mgr = new ScriptEngineManager();
	}

	public void testScriptEngineManager() {
		assertNotNull(mgr);
		List facs = mgr.getEngineFactories();
		assertNotNull(facs);
		assertTrue(facs.size() > 0); // need at least one
	}

	public void testGetPut() {
		mgr.put("x", new Integer(1));
		Object retValue = mgr.get("x");
		assertEquals(new Integer(1), retValue);
		try {
            mgr.get(null);
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
        }
		try {
            mgr.get("");
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        }
        assertNull(mgr.get("missing_Key"));
        assertNull(mgr.get("null_Key"));
        mgr.put("null_Key", null);
        assertNull(mgr.get("null_Key"));
	}

	public void testGetEngineByExtension() {
		ScriptEngine engine;
		
		engine =  mgr.getEngineByExtension("tEst");
        assertNotNull(engine);
		assertTrue(engine instanceof TestScriptEngine);
		
		engine = mgr.getEngineByExtension("teSt");
        assertNotNull(engine);
		assertTrue(engine instanceof TestScriptEngine);
	}

	public void testGetEngineByMimeType() {
        ScriptEngine engine;
        engine =  mgr.getEngineByMimeType("application/junit");
        assertNotNull(engine);
        assertTrue(engine instanceof TestScriptEngine);
	}

	public void testGetEngineByName() {
		ScriptEngine engine;
		
		engine =  mgr.getEngineByName("JUnit");
		assertNotNull(engine);
		assertTrue(engine instanceof TestScriptEngine);
	}

	public void testGetEngineFactories() {
		boolean found = false;
		List factories = mgr.getEngineFactories();
		
		for(int i = 0; i < factories.size(); i++) {
			if (factories.get(i) instanceof TestScriptEngineFactory) {
				found = true;
				break;
			}
		}
		
		if (!found) {
			fail("ScriptEngineManager.getEngineFactories(): " +
					"TestScriptEngineFactory is not present ..");
		}
	}

	public void testRegisterEngineExtension() {
        try {
            mgr.registerEngineExtension(null, null);
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
        }
        try {
            mgr.registerEngineExtension(null, new TestScriptEngineFactory());
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
        }
        try {
            mgr.registerEngineExtension("", null);
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
        }
        assertNull(mgr.getEngineByExtension("")); // not yet defined
        // Empty extensions are allowed
        mgr.registerEngineExtension("", new TestScriptEngineFactory());
        assertNotNull(mgr.getEngineByExtension("")); //now defined
        assertNull(mgr.getEngineByExtension("junit2")); // not yet defined
        mgr.registerEngineExtension("junit2", new TestScriptEngineFactory());
        assertNotNull(mgr.getEngineByExtension("junit2")); //now defined
	}

	public void testRegisterEngineName() {
        try {
            mgr.registerEngineName(null, null);
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
        }
        try {
            mgr.registerEngineName(null, new TestScriptEngineFactory());
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
        }
        try {
            mgr.registerEngineName("", null);
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
        }
        assertNull(mgr.getEngineByName("")); // not yet defined
        // Empty extensions are allowed
        mgr.registerEngineName("", new TestScriptEngineFactory());
        assertNotNull(mgr.getEngineByName("")); //now defined
        assertNull(mgr.getEngineByName("junit2")); // not yet defined
        mgr.registerEngineName("junit2", new TestScriptEngineFactory());
        assertNotNull(mgr.getEngineByName("junit2")); //now defined
	}

	public void testRegisterEngineMimeType() {
        try {
            mgr.registerEngineMimeType(null, null);
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
        }
        try {
            mgr.registerEngineMimeType(null, new TestScriptEngineFactory());
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
        }
        try {
            mgr.registerEngineMimeType("", null);
            fail("Expected NullPointerException");
        } catch (NullPointerException e) {
        }
        assertNull(mgr.getEngineByMimeType("")); // not yet defined
        // Empty extensions are allowed
        mgr.registerEngineMimeType("", new TestScriptEngineFactory());
        assertNotNull(mgr.getEngineByMimeType("")); //now defined
        assertNull(mgr.getEngineByMimeType("junit2")); // not yet defined
        mgr.registerEngineMimeType("junit2", new TestScriptEngineFactory());
        assertNotNull(mgr.getEngineByMimeType("junit2")); //now defined
	}

	public void testSetBindings() {
	    assertNotNull(mgr.getBindings());
		try {
            mgr.setBindings(null);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
        }
        final SimpleBindings bindings = new SimpleBindings();
        assertNotSame(bindings, mgr.getBindings());
        mgr.setBindings(bindings);
        assertSame(bindings, mgr.getBindings());
	}

	public void testEvalAndCompile() throws ScriptException{
	    ScriptEngine se = mgr.getEngineByName("JUnit");
	    assertNotNull(se);
	    se.put("key", "value");
	    assertEquals("value",se.eval("key"));
	    if (se instanceof Compilable){
	        Compilable co = (Compilable) se;
	        CompiledScript cs = co.compile("key");
	        assertNotNull(cs);
	        assertEquals("value",cs.eval());
            assertEquals("value",cs.eval());	        
	    } else {
	        fail("Expected engine to implement Compilable");
	    }
	}
	
}