retest.java

来自「JAVA的一些源码 JAVA2 STANDARD EDITION DEVELO」· Java 代码 · 共 515 行 · 第 1/2 页

package com.sun.org.apache.regexp.internal;

/*
 * ====================================================================
 * 
 * The Apache Software License, Version 1.1
 *
 * Copyright (c) 1999 The Apache Software Foundation.  All rights 
 * reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer. 
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The end-user documentation included with the redistribution, if
 *    any, must include the following acknowlegement:  
 *       "This product includes software developed by the 
 *        Apache Software Foundation (http://www.apache.org/)."
 *    Alternately, this acknowlegement may appear in the software itself,
 *    if and wherever such third-party acknowlegements normally appear.
 *
 * 4. The names "The Jakarta Project", "Jakarta-Regexp", and "Apache Software
 *    Foundation" must not be used to endorse or promote products derived
 *    from this software without prior written permission. For written 
 *    permission, please contact [e-mail].
 *
 * 5. Products derived from this software may not be called "Apache"
 *    nor may "Apache" appear in their names without prior written
 *    permission of the Apache Group.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 * ====================================================================
 *
 * This software consists of voluntary contributions made by many
 * individuals on behalf of the Apache Software Foundation.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 *
 */ 

import java.io.*;

/**
 * Data driven (and optionally interactive) testing harness to exercise regular
 * expression compiler and matching engine.
 *
 * @author <a href="mailto:[e-mail]">Jonathan Locke</a>
 * @author <a href="mailto:[e-mail]">Jon S. Stevens</a>
 * @version $Id: RETest.java,v 1.2 2000/04/30 20:42:35 jon Exp $
 */
public class RETest
{
    // Construct a matcher and a debug compiler
    RE r = new RE();
    REDebugCompiler compiler = new REDebugCompiler();

    // True if we want to see output from success cases
    static final boolean showSuccesses = false;

    /**
     * Main program entrypoint.  If an argument is given, it will be compiled
     * and interactive matching will ensue.  If no argument is given, the
     * file RETest.txt will be used as automated testing input.
     * @param arg Command line arguments (optional regular expression)
    */
    public static void _main(String[] arg)
    {
        try
        {
            //new RETest(arg);
            test();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    /**
     * Testing entrypoint.
     * @param arg Command line arguments
     * @exception Exception thrown in case of error
    */
    public static boolean test() throws Exception
    {
        RETest test = new RETest();
        test.runAutomatedTests("docs/RETest.txt");
        return test.failures == 0;
    }

    /**
     * Constructor
    */
    public RETest()
    {
    }

    /**
     * Constructor for test
     * @param arg Command line arguments
    */
    public RETest(String[] arg)
    {
        try
        {
            // Run interactive tests against a single regexp
            if (arg.length == 2)
            {
                runInteractiveTests(arg[1]);
            }
            else if (arg.length == 1)
            {
                // Run automated tests 
                runAutomatedTests(arg[0]);
            }
            else
            {
                System.out.println ( "Usage: RETest ([-i] [regex]) ([/path/to/testfile.txt])" );
            }
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }       
    }

    /**
     * Compile and test matching against a single expression
     * @param expr Expression to compile and test
    */
    void runInteractiveTests(String expr)
    {
        try
        {
            // Compile expression
            r.setProgram(compiler.compile(expr));

            // Show expression
            say("\n" + expr + "\n");

            // Show program for compiled expression
            compiler.dumpProgram(new PrintWriter(System.out));
            
            // Test matching against compiled expression
            while (true)
            {
                // Read from keyboard
                BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                System.out.print("> ");
                System.out.flush();
                String match = br.readLine();

                // Try a match against the keyboard input
                if (r.match(match))
                {
                    say("Match successful.");
                }
                else
                {
                    say("Match failed.");
                }

                // Show subparen registers
                showParens(r);
            }
        }
        catch (Exception e)
        {
            say("Error: " + e.toString());
            e.printStackTrace();
        }
    }

    /**
     * Exit with a fatal error.
     * @param s Last famous words before exiting
    */
    void die(String s)
    {
        say("FATAL ERROR: " + s);
        System.exit(0);
    }

    /**
     * Fail with an error
     * @param s Failure description
    */
    void fail(String s)
    {
        failures++;
        say("\n");
        say("*******************************************************");
        say("*********************  FAILURE!  **********************");
        say("*******************************************************");
        say("\n");
        say(s);
        say("");        
        compiler.dumpProgram(new PrintWriter(System.out));
        say("\n");
    }

    /**
     * Show a success
     * @param s Success story
    */
    void success(String s)
    {
        if (showSuccesses)
        {
            show();
            say("Success: " + s);
        }
    }

    /**
     * Say something to standard out
     * @param s What to say
    */
    void say(String s)
    {
        System.out.println (s);
    }

    /**
     * Show an expression
    */
    void show()
    {
        say("\n-----------------------\n");
        say("Expression #" + (n) + " \"" + expr + "\" ");
    }

    /**
     * Dump parenthesized subexpressions found by a regular expression matcher object
     * @param r Matcher object with results to show
    */
    void showParens(RE r)
    {
        // Loop through each paren