libcore/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FormatterTest.java

/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.harmony.logging.tests.java.util.logging;

import dalvik.annotation.AndroidOnly;
import dalvik.annotation.TestTargetClass;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestLevel;

import java.io.File;
import java.text.MessageFormat;
import java.util.Locale;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.logging.FileHandler;
import java.util.logging.Formatter;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.LogManager;
import java.util.logging.LogRecord;

import junit.framework.TestCase;

import org.apache.harmony.logging.tests.java.util.logging.util.EnvironmentHelper;

@TestTargetClass(Formatter.class) 
public class FormatterTest extends TestCase {
    Formatter f;

    LogRecord r;
    
    FileHandler h;

    static String MSG = "msg, pls. ignore it";

    static LogManager manager = LogManager.getLogManager();

    final static Properties props = new Properties();

    final static String className = FormatterTest.class.getName();

    final static String TEMPPATH = System.getProperty("java.io.tmpdir");

    final static String SEP = File.separator;

    /*
     * @see TestCase#setUp()
     */
    protected void setUp() throws Exception {
        super.setUp();
        manager.reset();
        
        //initProp
        props.clear();
        props.put("java.util.logging.FileHandler.level", "FINE");
        props.put("java.util.logging.FileHandler.filter", className
                + "$MockFilter");
        props.put("java.util.logging.FileHandler.formatter", className
                + "$MockFormatter");
        props.put("java.util.logging.FileHandler.encoding", "iso-8859-1");
        // limit to only two message
        props.put("java.util.logging.FileHandler.limit", "1000");
        // rotation count is 2
        props.put("java.util.logging.FileHandler.count", "2");
        // using append mode
        props.put("java.util.logging.FileHandler.append", "true");
        props.put("java.util.logging.FileHandler.pattern",
                        "%t/log/java%u.test");
        
        File file = new File(TEMPPATH + SEP + "log");
        file.mkdir();
        manager.readConfiguration(EnvironmentHelper
                .PropertiesToInputStream(props));

        f = new MockFormatter();
        r = new LogRecord(Level.FINE, MSG);
        h = new FileHandler();
    }

    /*
     * test for constructor protected Formatter()
     */
    @TestTargets({
        @TestTargetNew(
            level = TestLevel.COMPLETE,
            notes = "",
            method = "Formatter",
            args = {}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL_COMPLETE,
            notes = "",
            method = "getHead",
            args = {java.util.logging.Handler.class}
        ),
        @TestTargetNew(
            level = TestLevel.PARTIAL_COMPLETE,
            notes = "",
            method = "getTail",
            args = {java.util.logging.Handler.class}
        )
    })
    public void testFormatter() {
        assertEquals("head string is not empty", "", f.getHead(null));
        assertEquals("tail string is not empty", "", f.getTail(null));

    }

    /*
     * test for method public String getHead(Handler h)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "getHead",
        args = {Handler.class}
    )
    public void testGetHead() {
        assertEquals("head string is not empty", "", f.getHead(null));
        assertEquals("head string is not empty", "", f.getHead(h));
        h.publish(r);
        assertEquals("head string is not empty", "", f.getHead(h));
    }

    /*
     * test for method public String getTail(Handler h)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "getTail",
        args = {Handler.class}
    )
    public void testGetTail() {
        assertEquals("tail string is not empty", "", f.getTail(null));
        assertEquals("tail string is not empty", "", f.getTail(h));
        h.publish(r);
        assertEquals("tail string is not empty", "", f.getTail(h));
    }

    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "formatMessage",
        args = {LogRecord.class}
    )
    @AndroidOnly("The RI fails in this test because it uses a MessageFormat " +
            "to format the message even though it doesn't contain \"{0\". " +
            "The spec says that this would indicate that a MessageFormat " +
            "should be used and else no formatting should be done.")
    public void testFormatMessage() {
        assertEquals(MSG, f.formatMessage(r));

        String pattern = "test formatter {0, number}";
        r.setMessage(pattern);
        assertEquals(pattern, f.formatMessage(r));

        Object[] oa = new Object[0];
        r.setParameters(oa);
        assertEquals(pattern, f.formatMessage(r));

        oa = new Object[] { new Integer(100), new Float(1.2), new Float(2.2) };
        r.setParameters(oa);
        assertEquals(MessageFormat.format(pattern, oa), f.formatMessage(r));

        r.setMessage(MSG);
        assertEquals(MSG, f.formatMessage(r));

        pattern = "wrong pattern {0, asdfasfd}";
        r.setMessage(pattern);
        assertEquals(pattern, f.formatMessage(r));

        pattern = null;
        r.setMessage(pattern);
        assertNull(f.formatMessage(r));

        // The RI fails in this test because it uses a MessageFormat to format
        // the message even though it doesn't contain "{0". The spec says that
        // this would indicate that a MessageFormat should be used and else no
        // formatting should be done.
        pattern = "pattern without 0 {1, number}";
        r.setMessage(pattern);
        assertEquals(pattern, f.formatMessage(r));
    }

    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "formatMessage",
        args = {LogRecord.class}
    )
    public void testLocalizedFormatMessage() {
        // normal case
        r.setMessage("msg");
        ResourceBundle rb = ResourceBundle
                .getBundle("bundles/java/util/logging/res");
        r.setResourceBundle(rb);
        assertEquals(rb.getString("msg"), f.formatMessage(r));

        // local message is a pattern
        r.setMessage("pattern");
        Object[] oa = new Object[] { new Integer(3) };
        r.setParameters(oa);
        assertEquals(MessageFormat.format(rb.getString("pattern"), oa), f
                .formatMessage(r));

        // key is a pattern, but local message is not
        r.setMessage("pattern{0,number}");
        oa = new Object[] { new Integer(3) };
        r.setParameters(oa);
        assertEquals(rb.getString("pattern{0,number}"), f.formatMessage(r));

        // another bundle
        rb = ResourceBundle.getBundle("bundles/java/util/logging/res",
                Locale.US);
        r.setMessage("msg");
        r.setResourceBundle(rb);
        assertEquals(rb.getString("msg"), f.formatMessage(r));

        // cannot find local message in bundle
        r.setMessage("msg without locale");
        assertEquals("msg without locale", f.formatMessage(r));

        // set bundle name but not bundle
        r.setResourceBundle(null);
        r.setResourceBundleName("bundles/java/util/logging/res");
        r.setMessage("msg");
        assertEquals("msg", f.formatMessage(r));
    }

    public static class MockFormatter extends Formatter {

        public String format(LogRecord arg0) {
            return "format";
        }
    }
}