android-platform-libcore/luni/src/test/java/libcore/java/util/logging/OldFileHandlerTest.java - nest-cam/4320010/android-platform-libcore - Git at Google

 /*
  * 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 libcore.java.util.logging;

 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.Reader;
 import java.util.Properties;
 import java.util.logging.FileHandler;
 import java.util.logging.Filter;
 import java.util.logging.Formatter;
 import java.util.logging.Handler;
 import java.util.logging.Level;
 import java.util.logging.LogManager;
 import java.util.logging.LogRecord;
 import junit.framework.TestCase;

 public class OldFileHandlerTest extends TestCase {

     static LogManager manager = LogManager.getLogManager();
     final static Properties props = new Properties();
     final static String className = OldFileHandlerTest.class.getName();
     final static String SEP = File.separator;
     String HOMEPATH;
     String TEMPPATH;
     FileHandler handler;
     LogRecord r;

     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");

         HOMEPATH = System.getProperty("user.home");
         TEMPPATH = System.getProperty("java.io.tmpdir");

         File file = new File(TEMPPATH + SEP + "log");
         file.mkdir();
         manager.readConfiguration(propertiesToInputStream(props));
         handler = new FileHandler();
         r = new LogRecord(Level.CONFIG, "msg");
     }

     protected void tearDown() throws Exception {
         if (null != handler) {
             handler.close();
         }
         reset(TEMPPATH + SEP + "log", "");
         super.tearDown();
     }

     public static InputStream propertiesToInputStream(Properties p) throws IOException {
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         p.store(bos, "");
         return new ByteArrayInputStream(bos.toByteArray());
     }

     public void testFileHandler() throws Exception {
         assertEquals("character encoding is non equal to actual value",
                 "iso-8859-1", handler.getEncoding());
         assertNotNull("Filter is null", handler.getFilter());
         assertNotNull("Formatter is null", handler.getFormatter());
         assertEquals("is non equal to actual value", Level.FINE, handler
                 .getLevel());
         assertNotNull("ErrorManager is null", handler.getErrorManager());
         handler.publish(r);
         handler.close();
         // output 3 times, and all records left
         // append mode is true
         for (int i = 0; i < 3; i++) {
             handler = new FileHandler();
             handler.publish(r);
             handler.close();
         }
         assertFileContent(TEMPPATH + SEP + "log", "java0.test.0",
                 new LogRecord[] { r, null, r, null, r, null, r },
                 new MockFormatter());
     }

     public void testFileHandler_1params() throws Exception {

         handler = new FileHandler("%t/log/string");
         assertEquals("character encoding is non equal to actual value",
                 "iso-8859-1", handler.getEncoding());
         assertNotNull("Filter is null", handler.getFilter());
         assertNotNull("Formatter is null", handler.getFormatter());
         assertEquals("is non equal to actual value", Level.FINE, handler
                 .getLevel());
         assertNotNull("ErrorManager is null", handler.getErrorManager());
         handler.publish(r);
         handler.close();

         // output 3 times, and all records left
         // append mode is true
         for (int i = 0; i < 3; i++) {
             handler = new FileHandler("%t/log/string");
             handler.publish(r);
             handler.close();
         }
         assertFileContent(TEMPPATH + SEP + "log", "/string", new LogRecord[] {
                 r, null, r, null, r, null, r }, new MockFormatter());

         // test if unique ids not specified, it will append at the end
         // no generation number is used
         FileHandler h = new FileHandler("%t/log/string");
         FileHandler h2 = new FileHandler("%t/log/string");
         FileHandler h3 = new FileHandler("%t/log/string");
         FileHandler h4 = new FileHandler("%t/log/string");
         h.publish(r);
         h2.publish(r);
         h3.publish(r);
         h4.publish(r);
         h.close();
         h2.close();
         h3.close();
         h4.close();
         assertFileContent(TEMPPATH + SEP + "log", "string", h.getFormatter());
         assertFileContent(TEMPPATH + SEP + "log", "string.1", h.getFormatter());
         assertFileContent(TEMPPATH + SEP + "log", "string.2", h.getFormatter());
         assertFileContent(TEMPPATH + SEP + "log", "string.3", h.getFormatter());

         // default is append mode
         FileHandler h6 = new FileHandler("%t/log/string%u.log");
         h6.publish(r);
         h6.close();
         FileHandler h7 = new FileHandler("%t/log/string%u.log");
         h7.publish(r);
         h7.close();
         try {
             assertFileContent(TEMPPATH + SEP + "log", "string0.log", h
                     .getFormatter());
             fail("should assertion failed");
         } catch (Error e) {
         }
         File file = new File(TEMPPATH + SEP + "log");
         assertTrue("length list of file is incorrect", file.list().length <= 2);

         // test unique ids
         FileHandler h8 = new FileHandler("%t/log/%ustring%u.log");
         h8.publish(r);
         FileHandler h9 = new FileHandler("%t/log/%ustring%u.log");
         h9.publish(r);
         h9.close();
         h8.close();
         assertFileContent(TEMPPATH + SEP + "log", "0string0.log", h
                 .getFormatter());
         assertFileContent(TEMPPATH + SEP + "log", "1string1.log", h
                 .getFormatter());
         file = new File(TEMPPATH + SEP + "log");
         assertTrue("length list of file is incorrect", file.list().length <= 2);

         try {
             new FileHandler("");
             fail("IllegalArgumentException expected");
         } catch (IllegalArgumentException e) {
             //expected
         }
     }

     public void testFileHandler_2params() throws Exception {
         boolean append = false;
         do {
             append = !append;
             handler = new FileHandler("%t/log/string", append);
             assertEquals("character encoding is non equal to actual value",
                     "iso-8859-1", handler.getEncoding());
             assertNotNull("Filter is null", handler.getFilter());
             assertNotNull("Formatter is null", handler.getFormatter());
             assertEquals("is non equal to actual value", Level.FINE, handler
                     .getLevel());
             assertNotNull("ErrorManager is null", handler.getErrorManager());
             handler.publish(r);
             handler.close();
             // output 3 times, and all records left
             // append mode is true
             for (int i = 0; i < 3; i++) {
                 handler = new FileHandler("%t/log/string", append);
                 handler.publish(r);
                 handler.close();
             }
             if (append) {
                 assertFileContent(TEMPPATH + SEP + "log", "/string",
                         new LogRecord[] { r, null, r, null, r, null, r },
                         new MockFormatter());
             } else {
                 assertFileContent(TEMPPATH + SEP + "log", "/string",
                         new LogRecord[] { r }, new MockFormatter());
             }
         } while (append);

         try {
             new FileHandler("", true);
             fail("IllegalArgumentException expected");
         } catch (IllegalArgumentException e) {
             //expected
         }
     }

     public void testFileHandler_3params() throws Exception {
         int limit = 120;
         int count = 1;
         handler = new FileHandler("%t/log/string", limit, count);
         assertEquals("character encoding is non equal to actual value",
                 "iso-8859-1", handler.getEncoding());
         assertNotNull("Filter is null", handler.getFilter());
         assertNotNull("Formatter is null", handler.getFormatter());
         assertEquals("is non equal to actual value", Level.FINE, handler
                 .getLevel());
         assertNotNull("ErrorManager is null", handler.getErrorManager());
         handler.publish(r);
         handler.close();
         // output 3 times, and all records left
         // append mode is true
         for (int i = 0; i < 3; i++) {
             handler = new FileHandler("%t/log/string", limit, count);
             handler.publish(r);
             handler.close();
         }
         assertFileContent(TEMPPATH + SEP + "log", "/string", new LogRecord[] {
                 r, null, r, null, r, null, r }, new MockFormatter());

         try {
             new FileHandler("", limit, count);
             fail("IllegalArgumentException expected");
         } catch (IllegalArgumentException e) {
             //expected
         }

         try {
             new FileHandler("%t/log/string", -1, count);
             fail("IllegalArgumentException expected");
         } catch (IllegalArgumentException e) {
             //expected
         }

         try {
             new FileHandler("%t/log/string", limit, 0);
             fail("IllegalArgumentException expected");
         } catch (IllegalArgumentException e) {
             //expected
         }
     }

     public void testFileHandler_4params() throws Exception {
         int limit = 120;
         int count = 1;
         boolean append = false;
         do {
             append = !append;
             handler = new FileHandler("%t/log/string", limit, count, append);
             assertEquals("character encoding is non equal to actual value",
                     "iso-8859-1", handler.getEncoding());
             assertNotNull("Filter is null", handler.getFilter());
             assertNotNull("Formatter is null", handler.getFormatter());
             assertEquals("is non equal to actual value", Level.FINE, handler
                     .getLevel());
             assertNotNull("ErrorManager is null", handler.getErrorManager());
             handler.publish(r);
             handler.close();
             // output 3 times, and all records left
             // append mode is true
             for (int i = 0; i < 3; i++) {
                 handler = new FileHandler("%t/log/string", limit, count, append);
                 handler.publish(r);
                 handler.close();
             }
             if (append) {
                 assertFileContent(TEMPPATH + SEP + "log", "/string",
                         new LogRecord[] { r, null, r, null, r, null, r },
                         new MockFormatter());
             } else {
                 assertFileContent(TEMPPATH + SEP + "log", "/string",
                         new LogRecord[] { r }, new MockFormatter());
             }
         } while (append);

         try {
             new FileHandler("", limit, count, true);
             fail("IllegalArgumentException expected");
         } catch (IllegalArgumentException e) {
             //expected
         }

         try {
             new FileHandler("%t/log/string", -1, count, false);
             fail("IllegalArgumentException expected");
         } catch (IllegalArgumentException e) {
             //expected
         }

         try {
             new FileHandler("%t/log/string", limit, 0, true);
             fail("IllegalArgumentException expected");
         } catch (IllegalArgumentException e) {
             //expected
         }
     }

     private void assertFileContent(String homepath, String filename,
             Formatter formatter) throws Exception {
         assertFileContent(homepath, filename, new LogRecord[] { r }, formatter);
     }

     private void assertFileContent(String homepath, String filename,
             LogRecord[] lr, Formatter formatter) throws Exception {
         handler.close();
         String msg = "";
         // if formatter is null, the file content should be empty
         // else the message should be formatted given records
         if (null != formatter) {
             StringBuffer sb = new StringBuffer();
             sb.append(formatter.getHead(handler));
             for (int i = 0; i < lr.length; i++) {
                 if (null == lr[i] && i < lr.length - 1) {
                     // if one record is null and is not the last record, means
                     // here is
                     // output completion point, should output tail, then output
                     // head
                     // (ready for next output)
                     sb.append(formatter.getTail(handler));
                     sb.append(formatter.getHead(handler));
                 } else {
                     sb.append(formatter.format(lr[i]));
                 }
             }
             sb.append(formatter.getTail(handler));
             msg = sb.toString();
         }
         char[] chars = new char[msg.length()];
         Reader reader = null;
         try {
             reader = new BufferedReader(new FileReader(homepath + SEP
                     + filename));
             reader.read(chars);
             assertEquals(msg, new String(chars));
             // assert has reached the end of the file
             assertEquals(-1, reader.read());
         } finally {
             try {
                 if (reader != null) {
                     reader.close();
                 }
             } catch (Exception e) {
                 // don't care
             }
             reset(homepath, filename);
         }
     }

     /**
      * Does a cleanup of given file
      */
     private void reset(String homepath, String filename) {
         File file;
         try {
             file = new File(homepath + SEP + filename);
             if (file.isFile()) {
                 file.delete();
             } else if (file.isDirectory()) {
                 File[] files = file.listFiles();
                 for (int i = 0; i < files.length; i++) {
                     files[i].delete();
                 }
                 file.delete();
             }
         } catch (Exception e) {
             e.printStackTrace();
         }
         try {
             file = new File(homepath + SEP + filename + ".lck");
             file.delete();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }

     // This test fails on RI. Doesn't parse special pattern \"%t/%h."
     public void testInvalidParams() throws IOException {

         // %t and %p parsing can add file separator automatically

         // bad directory, IOException, append
         try {
             new FileHandler("%t/baddir/multi%g", true);
             fail("should throw IO exception");
         } catch (IOException e) {
         }
         File file = new File(TEMPPATH + SEP + "baddir" + SEP + "multi0");
         assertFalse(file.exists());
         try {
             new FileHandler("%t/baddir/multi%g", false);
             fail("should throw IO exception");
         } catch (IOException e) {
         }
         file = new File(TEMPPATH + SEP + "baddir" + SEP + "multi0");
         assertFalse(file.exists());

         try {
             new FileHandler("%t/baddir/multi%g", 12, 4);
             fail("should throw IO exception");
         } catch (IOException e) {
         }
         file = new File(TEMPPATH + SEP + "baddir" + SEP + "multi0");
         assertFalse(file.exists());

         try {
             new FileHandler("%t/java%u", -1, -1);
             fail("should throw IllegalArgumentException");
         } catch (IllegalArgumentException e) {
         }
     }

     public void testPublish() throws Exception {
         LogRecord[] r = new LogRecord[] { new LogRecord(Level.CONFIG, "msg__"),
                 new LogRecord(Level.WARNING, "message"),
                 new LogRecord(Level.INFO, "message for"),
                 new LogRecord(Level.FINE, "message for test") };
         for (int i = 0; i < r.length; i++) {
             handler = new FileHandler("%t/log/stringPublish");
             handler.publish(r[i]);
             handler.close();
             assertFileContent(TEMPPATH + SEP + "log", "stringPublish",
                     new LogRecord[] { r[i] }, handler.getFormatter());
         }
     }

     public void testClose() throws Exception {
         FileHandler h = new FileHandler("%t/log/stringPublish");
         h.publish(r);
         h.close();
         assertFileContent(TEMPPATH + SEP + "log", "stringPublish", h
                 .getFormatter());
     }

     /*
      * mock classes
      */
     public static class MockFilter implements Filter {
         public boolean isLoggable(LogRecord record) {
             return !record.getMessage().equals("false");
         }
     }

     public static class MockFormatter extends Formatter {
         public String format(LogRecord r) {
             if (null == r) {
                 return "";
             }
             return r.getMessage() + " by MockFormatter\n";
         }

         public String getTail(Handler h) {
             return "tail\n";
         }

         public String getHead(Handler h) {
             return "head\n";
         }
     }
 }
	/*
	* 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 libcore.java.util.logging;

	import java.io.BufferedReader;
	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.FileReader;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.Reader;
	import java.util.Properties;
	import java.util.logging.FileHandler;
	import java.util.logging.Filter;
	import java.util.logging.Formatter;
	import java.util.logging.Handler;
	import java.util.logging.Level;
	import java.util.logging.LogManager;
	import java.util.logging.LogRecord;
	import junit.framework.TestCase;

	public class OldFileHandlerTest extends TestCase {

	static LogManager manager = LogManager.getLogManager();
	final static Properties props = new Properties();
	final static String className = OldFileHandlerTest.class.getName();
	final static String SEP = File.separator;
	String HOMEPATH;
	String TEMPPATH;
	FileHandler handler;
	LogRecord r;

	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");

	HOMEPATH = System.getProperty("user.home");
	TEMPPATH = System.getProperty("java.io.tmpdir");

	File file = new File(TEMPPATH + SEP + "log");
	file.mkdir();
	manager.readConfiguration(propertiesToInputStream(props));
	handler = new FileHandler();
	r = new LogRecord(Level.CONFIG, "msg");
	}

	protected void tearDown() throws Exception {
	if (null != handler) {
	handler.close();
	}
	reset(TEMPPATH + SEP + "log", "");
	super.tearDown();
	}

	public static InputStream propertiesToInputStream(Properties p) throws IOException {
	ByteArrayOutputStream bos = new ByteArrayOutputStream();
	p.store(bos, "");
	return new ByteArrayInputStream(bos.toByteArray());
	}

	public void testFileHandler() throws Exception {
	assertEquals("character encoding is non equal to actual value",
	"iso-8859-1", handler.getEncoding());
	assertNotNull("Filter is null", handler.getFilter());
	assertNotNull("Formatter is null", handler.getFormatter());
	assertEquals("is non equal to actual value", Level.FINE, handler
	.getLevel());
	assertNotNull("ErrorManager is null", handler.getErrorManager());
	handler.publish(r);
	handler.close();
	// output 3 times, and all records left
	// append mode is true
	for (int i = 0; i < 3; i++) {
	handler = new FileHandler();
	handler.publish(r);
	handler.close();
	}
	assertFileContent(TEMPPATH + SEP + "log", "java0.test.0",
	new LogRecord[] { r, null, r, null, r, null, r },
	new MockFormatter());
	}

	public void testFileHandler_1params() throws Exception {

	handler = new FileHandler("%t/log/string");
	assertEquals("character encoding is non equal to actual value",
	"iso-8859-1", handler.getEncoding());
	assertNotNull("Filter is null", handler.getFilter());
	assertNotNull("Formatter is null", handler.getFormatter());
	assertEquals("is non equal to actual value", Level.FINE, handler
	.getLevel());
	assertNotNull("ErrorManager is null", handler.getErrorManager());
	handler.publish(r);
	handler.close();

	// output 3 times, and all records left
	// append mode is true
	for (int i = 0; i < 3; i++) {
	handler = new FileHandler("%t/log/string");
	handler.publish(r);
	handler.close();
	}
	assertFileContent(TEMPPATH + SEP + "log", "/string", new LogRecord[] {
	r, null, r, null, r, null, r }, new MockFormatter());

	// test if unique ids not specified, it will append at the end
	// no generation number is used
	FileHandler h = new FileHandler("%t/log/string");
	FileHandler h2 = new FileHandler("%t/log/string");
	FileHandler h3 = new FileHandler("%t/log/string");
	FileHandler h4 = new FileHandler("%t/log/string");
	h.publish(r);
	h2.publish(r);
	h3.publish(r);
	h4.publish(r);
	h.close();
	h2.close();
	h3.close();
	h4.close();
	assertFileContent(TEMPPATH + SEP + "log", "string", h.getFormatter());
	assertFileContent(TEMPPATH + SEP + "log", "string.1", h.getFormatter());
	assertFileContent(TEMPPATH + SEP + "log", "string.2", h.getFormatter());
	assertFileContent(TEMPPATH + SEP + "log", "string.3", h.getFormatter());

	// default is append mode
	FileHandler h6 = new FileHandler("%t/log/string%u.log");
	h6.publish(r);
	h6.close();
	FileHandler h7 = new FileHandler("%t/log/string%u.log");
	h7.publish(r);
	h7.close();
	try {
	assertFileContent(TEMPPATH + SEP + "log", "string0.log", h
	.getFormatter());
	fail("should assertion failed");
	} catch (Error e) {
	}
	File file = new File(TEMPPATH + SEP + "log");
	assertTrue("length list of file is incorrect", file.list().length <= 2);

	// test unique ids
	FileHandler h8 = new FileHandler("%t/log/%ustring%u.log");
	h8.publish(r);
	FileHandler h9 = new FileHandler("%t/log/%ustring%u.log");
	h9.publish(r);
	h9.close();
	h8.close();
	assertFileContent(TEMPPATH + SEP + "log", "0string0.log", h
	.getFormatter());
	assertFileContent(TEMPPATH + SEP + "log", "1string1.log", h
	.getFormatter());
	file = new File(TEMPPATH + SEP + "log");
	assertTrue("length list of file is incorrect", file.list().length <= 2);

	try {
	new FileHandler("");
	fail("IllegalArgumentException expected");
	} catch (IllegalArgumentException e) {
	//expected
	}
	}

	public void testFileHandler_2params() throws Exception {
	boolean append = false;
	do {
	append = !append;
	handler = new FileHandler("%t/log/string", append);
	assertEquals("character encoding is non equal to actual value",
	"iso-8859-1", handler.getEncoding());
	assertNotNull("Filter is null", handler.getFilter());
	assertNotNull("Formatter is null", handler.getFormatter());
	assertEquals("is non equal to actual value", Level.FINE, handler
	.getLevel());
	assertNotNull("ErrorManager is null", handler.getErrorManager());
	handler.publish(r);
	handler.close();
	// output 3 times, and all records left
	// append mode is true
	for (int i = 0; i < 3; i++) {
	handler = new FileHandler("%t/log/string", append);
	handler.publish(r);
	handler.close();
	}
	if (append) {
	assertFileContent(TEMPPATH + SEP + "log", "/string",
	new LogRecord[] { r, null, r, null, r, null, r },
	new MockFormatter());
	} else {
	assertFileContent(TEMPPATH + SEP + "log", "/string",
	new LogRecord[] { r }, new MockFormatter());
	}
	} while (append);

	try {
	new FileHandler("", true);
	fail("IllegalArgumentException expected");
	} catch (IllegalArgumentException e) {
	//expected
	}
	}

	public void testFileHandler_3params() throws Exception {
	int limit = 120;
	int count = 1;
	handler = new FileHandler("%t/log/string", limit, count);
	assertEquals("character encoding is non equal to actual value",
	"iso-8859-1", handler.getEncoding());
	assertNotNull("Filter is null", handler.getFilter());
	assertNotNull("Formatter is null", handler.getFormatter());
	assertEquals("is non equal to actual value", Level.FINE, handler
	.getLevel());
	assertNotNull("ErrorManager is null", handler.getErrorManager());
	handler.publish(r);
	handler.close();
	// output 3 times, and all records left
	// append mode is true
	for (int i = 0; i < 3; i++) {
	handler = new FileHandler("%t/log/string", limit, count);
	handler.publish(r);
	handler.close();
	}
	assertFileContent(TEMPPATH + SEP + "log", "/string", new LogRecord[] {
	r, null, r, null, r, null, r }, new MockFormatter());

	try {
	new FileHandler("", limit, count);
	fail("IllegalArgumentException expected");
	} catch (IllegalArgumentException e) {
	//expected
	}

	try {
	new FileHandler("%t/log/string", -1, count);
	fail("IllegalArgumentException expected");
	} catch (IllegalArgumentException e) {
	//expected
	}

	try {
	new FileHandler("%t/log/string", limit, 0);
	fail("IllegalArgumentException expected");
	} catch (IllegalArgumentException e) {
	//expected
	}
	}

	public void testFileHandler_4params() throws Exception {
	int limit = 120;
	int count = 1;
	boolean append = false;
	do {
	append = !append;
	handler = new FileHandler("%t/log/string", limit, count, append);
	assertEquals("character encoding is non equal to actual value",
	"iso-8859-1", handler.getEncoding());
	assertNotNull("Filter is null", handler.getFilter());
	assertNotNull("Formatter is null", handler.getFormatter());
	assertEquals("is non equal to actual value", Level.FINE, handler
	.getLevel());
	assertNotNull("ErrorManager is null", handler.getErrorManager());
	handler.publish(r);
	handler.close();
	// output 3 times, and all records left
	// append mode is true
	for (int i = 0; i < 3; i++) {
	handler = new FileHandler("%t/log/string", limit, count, append);
	handler.publish(r);
	handler.close();
	}
	if (append) {
	assertFileContent(TEMPPATH + SEP + "log", "/string",
	new LogRecord[] { r, null, r, null, r, null, r },
	new MockFormatter());
	} else {
	assertFileContent(TEMPPATH + SEP + "log", "/string",
	new LogRecord[] { r }, new MockFormatter());
	}
	} while (append);

	try {
	new FileHandler("", limit, count, true);
	fail("IllegalArgumentException expected");
	} catch (IllegalArgumentException e) {
	//expected
	}

	try {
	new FileHandler("%t/log/string", -1, count, false);
	fail("IllegalArgumentException expected");
	} catch (IllegalArgumentException e) {
	//expected
	}

	try {
	new FileHandler("%t/log/string", limit, 0, true);
	fail("IllegalArgumentException expected");
	} catch (IllegalArgumentException e) {
	//expected
	}
	}

	private void assertFileContent(String homepath, String filename,
	Formatter formatter) throws Exception {
	assertFileContent(homepath, filename, new LogRecord[] { r }, formatter);
	}

	private void assertFileContent(String homepath, String filename,
	LogRecord[] lr, Formatter formatter) throws Exception {
	handler.close();
	String msg = "";
	// if formatter is null, the file content should be empty
	// else the message should be formatted given records
	if (null != formatter) {
	StringBuffer sb = new StringBuffer();
	sb.append(formatter.getHead(handler));
	for (int i = 0; i < lr.length; i++) {
	if (null == lr[i] && i < lr.length - 1) {
	// if one record is null and is not the last record, means
	// here is
	// output completion point, should output tail, then output
	// head
	// (ready for next output)
	sb.append(formatter.getTail(handler));
	sb.append(formatter.getHead(handler));
	} else {
	sb.append(formatter.format(lr[i]));
	}
	}
	sb.append(formatter.getTail(handler));
	msg = sb.toString();
	}
	char[] chars = new char[msg.length()];
	Reader reader = null;
	try {
	reader = new BufferedReader(new FileReader(homepath + SEP
	+ filename));
	reader.read(chars);
	assertEquals(msg, new String(chars));
	// assert has reached the end of the file
	assertEquals(-1, reader.read());
	} finally {
	try {
	if (reader != null) {
	reader.close();
	}
	} catch (Exception e) {
	// don't care
	}
	reset(homepath, filename);
	}
	}

	/**
	* Does a cleanup of given file
	*/
	private void reset(String homepath, String filename) {
	File file;
	try {
	file = new File(homepath + SEP + filename);
	if (file.isFile()) {
	file.delete();
	} else if (file.isDirectory()) {
	File[] files = file.listFiles();
	for (int i = 0; i < files.length; i++) {
	files[i].delete();
	}
	file.delete();
	}
	} catch (Exception e) {
	e.printStackTrace();
	}
	try {
	file = new File(homepath + SEP + filename + ".lck");
	file.delete();
	} catch (Exception e) {
	e.printStackTrace();
	}
	}

	// This test fails on RI. Doesn't parse special pattern \"%t/%h."
	public void testInvalidParams() throws IOException {

	// %t and %p parsing can add file separator automatically

	// bad directory, IOException, append
	try {
	new FileHandler("%t/baddir/multi%g", true);
	fail("should throw IO exception");
	} catch (IOException e) {
	}
	File file = new File(TEMPPATH + SEP + "baddir" + SEP + "multi0");
	assertFalse(file.exists());
	try {
	new FileHandler("%t/baddir/multi%g", false);
	fail("should throw IO exception");
	} catch (IOException e) {
	}
	file = new File(TEMPPATH + SEP + "baddir" + SEP + "multi0");
	assertFalse(file.exists());

	try {
	new FileHandler("%t/baddir/multi%g", 12, 4);
	fail("should throw IO exception");
	} catch (IOException e) {
	}
	file = new File(TEMPPATH + SEP + "baddir" + SEP + "multi0");
	assertFalse(file.exists());

	try {
	new FileHandler("%t/java%u", -1, -1);
	fail("should throw IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	}
	}

	public void testPublish() throws Exception {
	LogRecord[] r = new LogRecord[] { new LogRecord(Level.CONFIG, "msg__"),
	new LogRecord(Level.WARNING, "message"),
	new LogRecord(Level.INFO, "message for"),
	new LogRecord(Level.FINE, "message for test") };
	for (int i = 0; i < r.length; i++) {
	handler = new FileHandler("%t/log/stringPublish");
	handler.publish(r[i]);
	handler.close();
	assertFileContent(TEMPPATH + SEP + "log", "stringPublish",
	new LogRecord[] { r[i] }, handler.getFormatter());
	}
	}

	public void testClose() throws Exception {
	FileHandler h = new FileHandler("%t/log/stringPublish");
	h.publish(r);
	h.close();
	assertFileContent(TEMPPATH + SEP + "log", "stringPublish", h
	.getFormatter());
	}

	/*
	* mock classes
	*/
	public static class MockFilter implements Filter {
	public boolean isLoggable(LogRecord record) {
	return !record.getMessage().equals("false");
	}
	}

	public static class MockFormatter extends Formatter {
	public String format(LogRecord r) {
	if (null == r) {
	return "";
	}
	return r.getMessage() + " by MockFormatter\n";
	}

	public String getTail(Handler h) {
	return "tail\n";
	}

	public String getHead(Handler h) {
	return "head\n";
	}
	}
	}