All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.rhq.bindings.util.ScriptAssert Maven / Gradle / Ivy

    Go to download

    Abstraction of different facilities and default configurations for script bindings

    The newest version!
    /*
 * RHQ Management Platform
 * Copyright (C) 2005-2008 Red Hat, Inc.
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2, as
 * published by the Free Software Foundation, and/or the GNU Lesser
 * General Public License, version 2.1, also as published by the Free
 * Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License and the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * and the GNU Lesser General Public License along with this program;
 * if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

package org.rhq.bindings.util;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

import javax.script.ScriptEngine;

/**
 * This class provides the assertion functions to the scripts.
 * It is heavily inspired by and in part copied from org.testng.Assert class.
 * 
    
 * We specifically do not use the TestNG class here so that we avoid a runtime
 * dependency on TestNG.
 */
public class ScriptAssert {

    private ScriptEngine scriptEngine;

    //borrowed from TestNG
    private static String format(Object actual, Object expected, String message) {
        String formatted = "";
        if (null != message) {
            formatted = message + " ";
        }

        return formatted + "expected:<" + expected + "> but was:<" + actual + ">";
    }

    private void failNotEquals(Object actual, Object expected, String message) {
        fail(format(actual, expected, message));
    }
    
    private void failAssertNoEqual(Object[] actual, Object[] expected, String message, String defaultMessage) {
        if (message != null) {
            fail(message);
        } else {
            fail(defaultMessage);
        }
    }
    
    public ScriptAssert() {
        
    }
    
    public ScriptAssert(ScriptEngine scriptEngine) {
        this.scriptEngine = scriptEngine;
    }

    @NoTopLevelIndirection
    public void init(ScriptEngine engine) {
        this.scriptEngine = engine;
    }
    
    public void assertTrue(boolean condition, String msg) {
        if (!condition) {
            failNotEquals(Boolean.valueOf(condition), Boolean.TRUE, msg);
        }
    }

    public void assertTrue(boolean condition) {
        assertTrue(condition, null);
    }

    public void assertFalse(boolean condition, String msg) {
        if (condition) {
            failNotEquals(Boolean.valueOf(condition), Boolean.FALSE, msg);
        }
    }

    public void assertFalse(boolean condition) {
        assertFalse(condition, null);
    }

    public void fail(String msg, Throwable throwable) {
        throw new ScriptAssertionException(msg, throwable);
    }

    public void fail(String msg) {
        throw new ScriptAssertionException(msg);
    }

    public void fail() {
        throw new ScriptAssertionException();
    }

    public void assertEquals(Object actual, Object expected, String msg) {
        if ((expected == null) && (actual == null)) {
            return;
        }
        if (expected != null) {
            if (expected.getClass().isArray()) {
                assertArrayEquals(actual, expected, msg);
                return;
            } else if (expected.equals(actual)) {
                return;
            }
        }
        failNotEquals(actual, expected, msg);
    }
    
    /**
     * COPIED FROM TESTNG
     * Asserts that two objects are equal. It they are not, an AssertionError,
     * with given message, is thrown.
     * @param actual the actual value
     * @param expected the expected value (should be an non-null array value)
     * @param message the assertion error message
     */
    private void assertArrayEquals(Object actual, Object expected, String message) {
        //is called only when expected is an array
        if (actual.getClass().isArray()) {
            int expectedLength = Array.getLength(expected);
            if (expectedLength == Array.getLength(actual)) {
                for (int i = 0; i < expectedLength; i++) {
                    Object _actual = Array.get(actual, i);
                    Object _expected = Array.get(expected, i);
                    try {
                        assertEquals(_actual, _expected);
                    } catch (AssertionError ae) {
                        failNotEquals(actual, expected, message == null ? "" : message + " (values as index " + i
                            + " are not the same)");
                    }
                }
                //array values matched
                return;
            } else {
                failNotEquals(Array.getLength(actual), expectedLength, message == null ? "" : message
                    + " (Array lengths are not the same)");
            }
        }
        failNotEquals(actual, expected, message);
    }    

    public void assertEquals(Object actual, Object expected) {
        assertEquals(actual, expected, null);
    }

    public void assertNotNull(Object object) {
        assertNotNull(object, null);
    }

    public void assertNotNull(Object object, String msg) {
        if (object == null) {
            String message = "";
            if (msg != null) {
                message += msg + " ";
            }
            
            message = "expected the object to not be null";
            fail(message);
        }
    }

    public void assertNull(Object object) {
        assertNull(object, null);
    }

    public void assertNull(Object object, String msg) {
        if (object != null) {
            failNotEquals(object, null, msg);
        }
    }

    public void assertSame(Object actual, Object expected, String msg) {
        if (actual != expected) {
            failNotEquals(actual, expected, msg);
        }
    }

    public void assertSame(Object actual, Object expected) {
        assertSame(actual, expected, null);
    }

    public void assertNotSame(Object actual, Object expected, String msg) {
        if (actual == expected) {
            String formatted = "";
            if (msg != null) {
                formatted = msg + " ";
            }
            fail(formatted + "expected not same with:<" + expected + "> but was same:<" + actual + ">");
        }
    }

    public void assertNotSame(Object actual, Object expected) {
        assertNotSame(actual, expected, null);
    }

    public void assertEquals(Collection actual, Collection expected) {
        assertEquals(actual, expected, null);
    }

    public void assertEquals(Collection actual, Collection expected, String msg) {
        if(actual == expected) {
            return;
          }

          if (actual == null || expected == null) {
            if (msg != null) {
              fail(msg);
            } else {
              fail("Collections not equal: expected: " + expected + " and actual: " + actual);
            }
          }

          assertEquals(actual.size(), expected.size(), msg + ": lists don't have the same size");

          Iterator actIt = actual.iterator();
          Iterator expIt = expected.iterator();
          int i = -1;
          while(actIt.hasNext() && expIt.hasNext()) {
            i++;
            Object e = expIt.next();
            Object a = actIt.next();
            String explanation = "Lists differ at element [" + i + "]: " + e + " != " + a;
            String errorMessage = msg == null ? explanation : msg + ": " + explanation;

            assertEquals(a, e, errorMessage);
          }
    }

    /* These are no longer needed in Rhino 1.7R3, because native javascript arrays implement
     * the collection interfaces.
     */
    /*    
        public void assertEquals(Object[] actual, Object[] expected, String msg) {
            if (actual == expected) {
                return;
            }

            if ((actual == null && expected != null) || (actual != null && expected == null)) {
                if (msg != null) {
                    fail(msg);
                } else {
                    fail("Arrays not equal: " + Arrays.toString(expected) + " and " + Arrays.toString(actual));
                }
            }
            assertEquals(Arrays.asList(actual), Arrays.asList(expected), msg);
        }

        public void assertEquals(Object[] actual, Object[] expected) {
            assertEquals(actual, expected, null);
        }

    */

    public void assertEqualsNoOrder(Object[] actual, Object[] expected, String msg) {
        if (actual == expected) {
            return;
        }

        if ((actual == null && expected != null) || (actual != null && expected == null)) {
            failAssertNoEqual(actual, expected,
                "Arrays not equal: " + Arrays.toString(expected) + " and " + Arrays.toString(actual), msg);
        }

        if (actual.length != expected.length) {
            failAssertNoEqual(actual, expected, "Arrays do not have the same size:" + actual.length + " != "
                + expected.length, msg);
        }

        List actualCollection = new ArrayList();
        for (Object a : actual) {
            actualCollection.add(a);
        }
        for (Object o : expected) {
            actualCollection.remove(o);
        }
        if (actualCollection.size() != 0) {
            failAssertNoEqual(actual, expected,
                "Arrays not equal: " + Arrays.toString(expected) + " and " + Arrays.toString(actual), msg);
        }
    }

    public void assertEqualsNoOrder(Object[] actual, Object[] expected) {
        assertEqualsNoOrder(actual, expected, null);
    }

    public void assertExists(String identifier) {
        Object value = scriptEngine.get(identifier);
        assertNotNull(value, identifier + " is not defined");
    }

    /**
     * JavaScript has only a single numeric type such that x = 1 and y = 1.0 are considered to
     * be of the same type. From within a (JavaScript) script if you were to call assertEquals(x, y), you
     * would get an exception that looks something like,
     *
     * 
         * Caused by: javax.script.ScriptException: sun.org.mozilla.javascript.internal.EvaluatorException: The choice of
     * Java constructor assertEquals matching JavaScript argument types (number,number,string) is ambiguous;
     * candidate constructors are:
     * void assertEquals(java.lang.String,java.lang.String,java.lang.String)
     * void assertEquals(double,double,double)
     * void assertEquals(float,float,float)
     * void assertEquals(long,long,java.lang.String)
     * void assertEquals(byte,byte,java.lang.String)
     * void assertEquals(char,char,java.lang.String)
     * void assertEquals(short,short,java.lang.String)
     * void assertEquals(int,int,java.lang.String) (#1) in  at line number 1
     
    
     *
     * To avoid the ambiguity when comparing numbers in JavaScript scripts, it is recommended to use this method.
     *
     * @param actual The actual value
     * @param expected The expected value
     * @param msg A useful, meaningful error message
     * 
     * @deprecated - it is now possible to use assertEquals() with numbers from within javascript because we
     * now only provide {@link #assertEquals(Object, Object)} to which the numbers convert to correctly.
     */
    @Deprecated
    public void assertNumberEqualsJS(double actual, double expected, String msg) {
        assertEquals(actual, expected, msg);
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy