AternativeApproach.java

/**
 * Copyright (c) 2004-2011 QOS.ch
 * All rights reserved.
 *
 * Permission is hereby granted, free  of charge, to any person obtaining
 * a  copy  of this  software  and  associated  documentation files  (the
 * "Software"), to  deal in  the Software without  restriction, including
 * without limitation  the rights to  use, copy, modify,  merge, publish,
 * distribute,  sublicense, and/or sell  copies of  the Software,  and to
 * permit persons to whom the Software  is furnished to do so, subject to
 * the following conditions:
 *
 * The  above  copyright  notice  and  this permission  notice  shall  be
 * included in all copies or substantial portions of the Software.
 *
 * THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
 * EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
 * MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 * OF CONTRACT, TORT OR OTHERWISE,  ARISING FROM, OUT OF OR IN CONNECTION
 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
package org.slf4j.migrator;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.slf4j.migrator.line.MultiGroupConversionRule;

import junit.framework.TestCase;

public class AternativeApproach extends TestCase {

    /**
     * In this test we see that we cans use more simple Pattern to do the
     * conversion
     * 
     */
    public void test() {
        MultiGroupConversionRule cr2 = new MultiGroupConversionRule(Pattern.compile("(.*)(Log)"));
        cr2.addReplacement(2, "LOGGER");

        String s = "abcd Log";
        Pattern pat = cr2.getPattern();
        Matcher m = pat.matcher(s);

        assertTrue(m.matches());
        String r = cr2.replace(m);
        assertEquals("abcd LOGGER", r);

        System.out.println(r);
    }

    /**
     * In this test we replace, using the simple Pattern (Log), the full Log
     * declaration and instantiation. This is not convenient because we will also
     * replace all String containing "Log".
     */
    public void test2() {
        Pattern pat = Pattern.compile("(Log)");
        String s = "abcd Log =";
        Matcher m = pat.matcher(s);
        assertTrue(m.find());
        String r = m.replaceAll("Logger");
        assertEquals("abcd Logger =", r);

        String s1 = "Log l = LogFactory.getLog(MyClass.class);";
        m = pat.matcher(s1);
        assertTrue(m.find());
        r = m.replaceAll("Logger");
        assertEquals("Logger l = LoggerFactory.getLogger(MyClass.class);", r);

        String s2 = "Logabc ";
        m = pat.matcher(s2);
        assertTrue(m.find());

        String s3 = "abcLog";
        m = pat.matcher(s3);
        assertTrue(m.find());
    }

    /**
     * In this test we use a simple Pattern to replace the log instantiation
     * without influence on Log declaration.
     * 
     */
    public void test3() {
        Pattern pat = Pattern.compile("LogFactory.getFactory\\(\\).getInstance\\(");
        String s = "Log log =  LogFactory.getFactory().getInstance(\"x\");";
        Matcher m = pat.matcher(s);
        assertTrue(m.find());
        String r = m.replaceAll("LoggerFactory.getLogger(");
        assertEquals("Log log =  LoggerFactory.getLogger(\"x\");", r);

        String nonMatching = "Log log = xxx;";
        pat.matcher(nonMatching);
        assertFalse(m.find());
    }

    /**
     * In this test we try to replace keyword Log without influence on String
     * containing Log We see that we have to use two different Patterns
     */
    public void test4() {
        Pattern pat = Pattern.compile("(\\sLog\\b)");
        String s = "abcd Log =";
        Matcher m = pat.matcher(s);
        assertTrue(m.find());
        String r = m.replaceAll(" Logger");
        assertEquals("abcd Logger =", r);

        String s2 = "Logabcd ";
        m = pat.matcher(s2);
        assertFalse(m.find());

        String s3 = "abcdLogabcd ";
        m = pat.matcher(s3);
        assertFalse(m.find());

        String s4 = "abcdLog";
        m = pat.matcher(s4);
        assertFalse(m.find());

        String s5 = "Log myLog";
        m = pat.matcher(s5);
        assertFalse(m.find());

        Pattern pat2 = Pattern.compile("^Log\\b");
        Matcher m2 = pat2.matcher(s5);
        assertTrue(m2.find());
        r = m2.replaceAll("Logger");
        assertEquals("Logger myLog", r);
    }

    /**
     * In this test we combine two Pattern to achieve the intended conversion
     */
    public void test5() {
        Pattern pat = Pattern.compile("(\\sLog\\b)");
        String s = "public Log myLog =LogFactory.getFactory().getInstance(myClass.class);";
        Matcher m = pat.matcher(s);
        assertTrue(m.find());
        String r = m.replaceAll(" Logger");
        assertEquals("public Logger myLog =LogFactory.getFactory().getInstance(myClass.class);", r);

        Pattern pat2 = Pattern.compile("LogFactory.getFactory\\(\\).getInstance\\(");
        m = pat2.matcher(r);
        assertTrue(m.find());
        r = m.replaceAll("LoggerFactory.getLogger(");
        assertEquals("public Logger myLog =LoggerFactory.getLogger(myClass.class);", r);
    }
}