parsertestcase.java

本程序用于对页面信息进行提取并分析

        String displayMessage, Node expectedNode,Node actualNode) {

        String expected = expectedNode.toPlainTextString().trim();
        String actual = actualNode.toPlainTextString().trim();
        expected = expected.replace('\n', ' ');
        actual = actual.replace('\n',' ');
        displayMessage = "String value mismatch\nEXPECTED:"+expected+"\nACTUAL:"+actual+displayMessage;
        assertStringEquals(displayMessage,expected,actual);

    }

    private void assertActualXmlHasNoMoreNodes(
        String displayMessage,
        NodeIterator actualIterator)
        throws ParserException {
        if (actualIterator.hasMoreNodes()) {
            String extraTags = "\nExtra Tags\n**********\n";
            do {
                extraTags += actualIterator.nextNode().toHtml();
            }
            while (actualIterator.hasMoreNodes());

            displayMessage = "Actual had more data than expected\n"+extraTags+displayMessage;
            fail(displayMessage);
        }
    }

    private String createGenericFailureMessage(
        String displayMessage,
        String expected,
        String actual) {
        return "\n\n"+displayMessage+"\n\nComplete Xml\n************\nEXPECTED:\n"+expected+"\nACTUAL:\n"+actual;
    }

    /**
     * Return a following tag if node is an empty XML tag.
     */
    private Tag fixIfXmlEndTag (Page page, Node node)
    {
        Tag ret;

        ret = null;
        if (node instanceof Tag)
        {
            Tag tag = (Tag)node;
            if (tag.isEmptyXmlTag())
            {
                tag.setEmptyXmlTag (false);
                ret = new TagNode (page, tag.getStartPosition (), tag.getEndPosition (), tag.getAttributesEx ());
            }
        }
        
        return (ret);
    }

    private void assertAttributesMatch(String displayMessage, Tag expectedTag, Tag actualTag)
    {
        assertAllExpectedTagAttributesFoundInActualTag(
            displayMessage,
            expectedTag,
            actualTag);
        if (expectedTag.getAttributesEx().size() != actualTag.getAttributesEx().size())
            assertActualTagHasNoExtraAttributes(displayMessage, expectedTag, actualTag);
    }

    private void assertActualTagHasNoExtraAttributes(String displayMessage, Tag expectedTag, Tag actualTag)
    {
        assertStringEquals (displayMessage+"\ntag name", expectedTag.getTagName (), actualTag.getTagName ());
        Vector v = actualTag.getAttributesEx ();
        for (int i = 1; i < v.size (); i++)
        {
            Attribute a = (Attribute)v.elementAt (i);
            if (a.isWhitespace ())
                continue;
            String expectedValue = expectedTag.getAttribute (a.getName ());
            if (null == expectedValue)
                fail("\nActual tag had extra attribute: " + a.getName () + displayMessage);
        }
    }

    private void assertAllExpectedTagAttributesFoundInActualTag(
        String displayMessage,
        Tag expectedTag,
        Tag actualTag)
    {
        assertStringEquals (displayMessage+"\ntag name", expectedTag.getTagName (), actualTag.getTagName ());
        Vector v = actualTag.getAttributesEx ();
        for (int i = 1; i < v.size (); i++)
        {
            Attribute a = (Attribute)v.elementAt (i);
            if (a.isWhitespace ())
                continue;
            String actualValue = actualTag.getAttribute (a.getName ());
            String expectedValue = expectedTag.getAttribute (a.getName ());

            assertStringEquals(
                "\nvalue for attribute " + a.getName () + " in tag "+expectedTag.getTagName()+" expected="+expectedValue+" but was "+actualValue+
                "\n\nComplete Tag expected:\n"+expectedTag.toHtml()+
                "\n\nComplete Tag actual:\n"+actualTag.toHtml()+
                displayMessage,
                expectedValue,
                actualValue
            );
        }
    }

    public static String removeEscapeCharacters(String inputString) {
        inputString = ParserUtils.removeChars(inputString,'\r');
        inputString = inputString.replace ('\n',' ');
        inputString = ParserUtils.removeChars(inputString,'\t');
        return inputString;
    }

    public void assertSuperType(
        String message,
        Class expectedType,
        Object object)
    {   
        String expectedTypeName = expectedType.getName();
        String actualTypeName   = object.getClass().getName();
        if (!expectedType.isAssignableFrom (object.getClass ()))
            fail(
                message+" should have been of type\n"+
                expectedTypeName+
                " but was of type \n"+
                actualTypeName+"\n and is :"+((Node)object).toHtml()
            );
    }

    public void assertType(
        String message,
        Class expectedType,
        Object object)
    {
        if (!expectedType.isAssignableFrom (object.getClass ()))
        {
            String expectedTypeName = expectedType.getName ();
            String actualTypeName   = object.getClass ().getName ();
            if (!actualTypeName.equals (expectedTypeName))
                fail(
                    message + " should have been of type "+
                    expectedTypeName
                    + " but was of type "
                    + actualTypeName
                    + " and is:"
                    + ((Node)object).toHtml()
                );
        }
    }

    protected void assertHiddenIDTagPresent(FormTag formTag, String name, String inputTagValue) {
        InputTag inputTag = formTag.getInputTag(name);
        assertNotNull("Hidden Tag "+name+" should have been there", inputTag);
        assertStringEquals("Hidden Tag Contents", inputTagValue, inputTag.getAttribute("VALUE"));
        assertStringEquals("Hidden Tag Type", "hidden", inputTag.getAttribute("TYPE"));
    }

    protected void assertNodeCount(String message, int expectedLength, Node[] nodes) {
        if (expectedLength!=nodes.length) {
            StringBuffer failMsg = new StringBuffer(message);
            failMsg.append("\n");
            failMsg.append("Number of nodes expected ").append(expectedLength).append(" \n");
            failMsg.append("but was : ");
            failMsg.append(nodes.length).append("\n");
            failMsg.append("Nodes found are:\n");
            for (int i=0;i<nodes.length;i++) {
                failMsg.append("Node ").append(i).append(" : ");
                failMsg.append(nodes[i].getClass().getName()).append("\n");
                failMsg.append(nodes[i].toString()).append("\n\n");
            }
            fail(failMsg.toString());
        }
    }

    /**
     * Mainline for individual test cases.
     * @param args Command line arguments. The following options
     * are understood:
     * <pre>
     * -text  -- use junit.textui.TestRunner
     * -awt   -- use junit.awtui.TestRunner
     * -swing -- use junit.swingui.TestRunner (default)
     * </pre>
     * All other options are passed on to the junit framework.
     * Decides the test class by examiing the system properties looking
     * for a property that starts with "org.htmlparser.tests.", this is
     * used as the name of the class (the value is ignored).
     * Each class that subclasses ParserTestCase can inherit this mainline
     * by adding a static block in their class similar to:
     * <pre>
     * static
     * {
     *     System.setProperty ("org.htmlparser.tests.ParserTest", "ParserTest");
     * }
     * </pre>
     */
    public static void main(String[] args)
    {
        String runner;
        int i;
        String arguments[];
        Properties properties;
        Enumeration enumeration;
        String name;
        Class cls;

        runner = null;
        for (i = 0; (i < args.length) && (null == runner); i++)
        {
            if (args[i].equalsIgnoreCase ("-text"))
                runner = "junit.textui.TestRunner";
            else if (args[i].equalsIgnoreCase ("-awt"))
                runner = "junit.awtui.TestRunner";
            else if (args[i].equalsIgnoreCase ("-swing"))
                runner = "junit.swingui.TestRunner";
        }
        if (null != runner)
        {
            // remove it from the arguments
            arguments = new String[args.length - 1];
            System.arraycopy (args, 0, arguments, 0, i - 1);
            System.arraycopy (args, i, arguments, i - 1, args.length - i);
            args = arguments;
        }
        else
            runner = "junit.swingui.TestRunner";

        // find the test class that has registered in the system properties
        arguments = args; // default of no class name, works in GUI mode
        properties = System.getProperties ();
        enumeration = properties.propertyNames ();
        while (enumeration.hasMoreElements ())
        {
            name = (String)enumeration.nextElement ();
            if (name.startsWith ("org.htmlparser.tests."))
            {
                // from http://www.mail-archive.com/commons-user%40jakarta.apache.org/msg02958.html
                //
                // The problem is within the UI test runners of JUnit. They bring
                // with them a custom classloader, which causes the
                // LogConfigurationException. Unfortunately Log4j doesn't work
                // either.
                //
                // Solution: Disable "Reload classes every run" or start JUnit with
                // command line option -noloading before the name of the Testsuite.
                if (true)
                {
                    // append the test class
                    arguments = new String[args.length + 2];
                    System.arraycopy (args, 0, arguments, 0, args.length);
                    arguments[arguments.length - 2] = "-noloading";
                    arguments[arguments.length - 1] = name;
                }
                else
                {
                    // append the test class
                    arguments = new String[args.length + 1];
                    System.arraycopy (args, 0, arguments, 0, args.length);
                    arguments[args.length] = name;
                }
                break; // JUnit only handles one class on the command line
            }
        }

        // invoke main() of the test runner
        try
        {
            cls = Class.forName (runner);
            java.lang.reflect.Method method = cls.getDeclaredMethod (
                "main", new Class[] { String[].class });
            method.invoke (
                null,
                new Object[] { arguments });
        }
        catch (Throwable t)
        {
            System.err.println (
                "cannot run unit test ("
                + t.getMessage ()
                + ")");
        }
    }
}