retest.java

java写的crawler

        for (int i = 0; i < r.getParenCount(); i++)
        {
            // Show paren register
            say("$" + i + " = " + r.getParen(i));
        }
    }

    // Pre-compiled regular expression "a*b"
    char[] re1Instructions =
    {
        0x007c, 0x0000, 0x001a, 0x007c, 0x0000, 0x000d, 0x0041,
        0x0001, 0x0004, 0x0061, 0x007c, 0x0000, 0x0003, 0x0047,
        0x0000, 0xfff6, 0x007c, 0x0000, 0x0003, 0x004e, 0x0000,
        0x0003, 0x0041, 0x0001, 0x0004, 0x0062, 0x0045, 0x0000,
        0x0000,
    };

    REProgram re1 = new REProgram(re1Instructions);

    /*
     * Current expression and number in automated test
    */
    String expr;
    int n = 0;

    /*
     * Count of failures in automated test
     */
    int failures = 0;

    /**
     * Run automated tests in RETest.txt file (from Perl 4.0 test battery)
    * @exception Exception thrown in case of error
    */
    void runAutomatedTests(String testDocument) throws Exception
    {
        long ms = System.currentTimeMillis();

        // Simple test of pre-compiled regular expressions
        RE r = new RE(re1);
        say("a*b");
        say("aaaab = " + r.match("aaab"));
        showParens(r);
        say("b = " + r.match("b"));
        showParens(r);
        say("c = " + r.match("c"));
        showParens(r);
        say("ccccaaaaab = " + r.match("ccccaaaaab"));
        showParens(r);

        r = new RE("a*b");
        String[] s = r.split("xxxxaabxxxxbyyyyaaabzzz");
        r = new RE("x+");
        s = r.grep(s);
        for (int i = 0; i < s.length; i++)
        {
            System.out.println ("s[" + i + "] = " + s[i]);
        }

        r = new RE("a*b");
        String s1 = r.subst("aaaabfooaaabgarplyaaabwackyb", "-");
        System.out.println ("s = " + s1);

        // Test from script file
        File testInput = new File(testDocument);
        if (! testInput.exists())
            throw new Exception ("Could not find: " + testDocument);
        BufferedReader br = new BufferedReader(new FileReader(testInput));
        try
        {
            // While input is available, parse lines
            while (br.ready())
            {
                // Find next re test case
                String number = "";
                String yesno;
                while (br.ready())
                {
                    number = br.readLine();
                    if (number == null)
                    {
                        break;
                    }
                    number = number.trim();
                    if (number.startsWith("#"))
                    {
                        break;
                    }
                    if (!number.equals(""))
                    {
                        System.out.println ("Script error.  Line = " + number);
                        System.exit(0);
                    }
                }

                // Are we done?
                if (!br.ready())
                {
                    break;
                }

                // Get expression
                expr = br.readLine();
                n++;
                say("");
                say(n + ". " + expr);
                say("");

                // Compile it
                try
                {
                    r.setProgram(compiler.compile(expr));
                }

                // Some expressions *should* cause exceptions to be thrown
                catch (Exception e)
                {
                    // Get expected result
                    yesno = br.readLine().trim();

                    // If it was supposed to be an error, report success and continue
                    if (yesno.equals("ERR"))
                    {
                        say("   Match: ERR");
                        success("Produces an error (" + e.toString() + "), as expected.");
                        continue;
                    }

                    // Wasn't supposed to be an error
                    fail("Produces the unexpected error \"" + e.getMessage() + "\"");
                }
                catch (Error e)
                {
                    // Internal error happened
                    fail("Compiler threw fatal error \"" + e.getMessage() + "\"");
                    e.printStackTrace();
                }

                // Get string to match against
                String matchAgainst = br.readLine().trim();
                say("   Match against: '" + matchAgainst + "'");

                // Expression didn't cause an expected error
                if (matchAgainst.equals("ERR"))
                {
                    fail("Was expected to be an error, but wasn't.");
                    continue;
                }

                // Try matching
                try
                {
                    // Match against the string
                    boolean b = r.match(matchAgainst);

                    // Get expected result
                    yesno = br.readLine().trim();

                    // If match succeeded
                    if (b)
                    {
                        // Status
                        say("   Match: YES");

                        // Match wasn't supposed to succeed
                        if (yesno.equals("NO"))
                        {
                            fail("Matched \"" + matchAgainst + "\", when not expected to.");
                        }
                        else
                        if (yesno.equals("YES"))
                        {
                            // Match succeeded as expected
                            success("Matched \"" + matchAgainst + "\", as expected:");

                            // Show subexpression registers
                            if (showSuccesses)
                            {
                                showParens(r);
                            }

                            say("   Paren count: " + r.getParenCount());

                            // Check registers against expected contents
                            for (int p = 0; p < r.getParenCount(); p++)
                            {
                                // Get next register
                                String register = br.readLine().trim();
                                say("   Paren " + p + " : " + r.getParen(p));

                                // Compare expected result with actual
                                if (!register.equals(r.getParen(p)))
                                {
                                    // Register isn't what it was supposed to be
                                    fail("Register " + p + " should be = \"" + register + "\", but is \"" + r.getParen(p) + "\" instead.");
                                }
                            }
                        }
                        else
                        {
                            // Bad test script
                            die("Test script error!");
                        }
                    }
                    else
                    {
                        // Status
                        say("   Match: NO");

                        // Match failed
                        if (yesno.equals("YES"))
                        {
                            // Should have failed
                            fail("Did not match \"" + matchAgainst + "\", when expected to.");
                        }
                        else
                        if (yesno.equals("NO"))
                        {
                            // Should have failed
                            success("Did not match \"" + matchAgainst + "\", as expected.");
                        }
                        else
                        {
                            // Bad test script
                            die("Test script error!");
                        }
                    }
                }

                // Matcher blew it
                catch (Exception e)
                {
                    fail("Matcher threw exception: " + e.toString());
                    e.printStackTrace();
                }

                // Internal error
                catch (Error e)
                {
                    fail("Matcher threw fatal error \"" + e.getMessage() + "\"");
                    e.printStackTrace();
                }
            }
        }
        finally
        {
            br.close();
        }

        // Show match time
        System.out.println ("\n\nMatch time = " + (System.currentTimeMillis() - ms) + " ms.");

        // Print final results
        System.out.println ("\nTests complete.  " + n + " tests, " + failures + " failure(s).");
    }
}