Mailing-List: contact harmony-commits-help@incubator.apache.org; run by ezmlm
Precedence: bulk
Reply-To: harmony-dev@incubator.apache.org
Received-SPF: pass (asf.osuosl.org: local policy)
Content-Type: text/plain; charset="utf-8"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Subject: svn commit: r438419 [2/9] -
 /incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/
Date: Wed, 30 Aug 2006 08:22:17 -0000
To: harmony-commits@incubator.apache.org
From: smishura@apache.org
Message-Id: <20060830082221.864F01A981D@eris.apache.org>

Modified: incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FileHandlerTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FileHandlerTest.java?rev=438419&r1=438418&r2=438419&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FileHandlerTest.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FileHandlerTest.java Wed Aug 30 01:22:13 2006
@@ -1,683 +1,683 @@
-/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
- * 
- * Licensed 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 java.io.BufferedReader;
-import java.io.ByteArrayOutputStream;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
-import java.io.FilePermission;
-import java.io.FileReader;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.io.Reader;
-import java.io.StringWriter;
-import java.security.Permission;
-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 java.util.logging.LoggingPermission;
-import java.util.logging.XMLFormatter;
-
-import junit.framework.TestCase;
-import org.apache.harmony.logging.tests.java.util.logging.util.DefaultPropertyHelper;
-import org.apache.harmony.logging.tests.java.util.logging.util.EnvironmentHelper;
-
-/**
- */
-public class FileHandlerTest extends TestCase {
-
-	static LogManager manager;
-
-	final static Properties props = new Properties();
-
-	final static String className = FileHandlerTest.class.getName();
-
-	final static StringWriter writer = new StringWriter();
-
-	final static SecurityManager securityManager = new MockLogSecurityManager();
-
-	final static String HOMEPATH = System.getProperty("user.home");
-
-	final static String TEMPPATH = System.getProperty("java.io.tmpdir");
-
-	final static String SEP = File.separator;
-
-	private static File bakPropFile = null;
-
-	static {
-		try {
-			bakPropFile = DefaultPropertyHelper.init();
-		} catch (Exception e) {
-		}
-		Runtime.getRuntime().addShutdownHook(new Thread() {
-			public void run() {
-				DefaultPropertyHelper.reset(bakPropFile);
-			}
-		});
-	}
-
-	FileHandler handler;
-
-	LogRecord r;
-
-	/*
-	 * @see TestCase#setUp()
-	 */
-	protected void setUp() throws Exception {
-		super.setUp();
-		manager = LogManager.getLogManager();
-		manager.reset();
-		initProps();
-		File file = new File(TEMPPATH + SEP + "log");
-		file.mkdir();
-		manager.readConfiguration(EnvironmentHelper
-				.PropertiesToInputStream(props));
-		handler = new FileHandler();
-		r = new LogRecord(Level.CONFIG, "msg");
-
-	}
-
-	/**
-	 * 
-	 */
-	private void initProps() {
-		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");
-	}
-
-	/*
-	 * @see TestCase#tearDown()
-	 */
-	protected void tearDown() throws Exception {
-		if (null != handler) {
-			handler.close();
-		}
-		reset(TEMPPATH + SEP + "log", "");
-		super.tearDown();
-	}
-
-	public void testLock() throws Exception {
-		FileOutputStream output = new FileOutputStream(TEMPPATH + SEP + "log"
-				+ SEP + "java1.test.0");
-		FileHandler h = new FileHandler();
-		h.publish(r);
-		h.close();
-		assertFileContent(TEMPPATH + SEP + "log", "java1.test.0", h
-				.getFormatter());
-		output.close();
-	}
-
-	/*
-	 * Class under test for void FileHandler()
-	 */
-	public void testFileHandler() throws Exception {
-		assertEquals(handler.getEncoding(), "iso-8859-1");
-		assertTrue(handler.getFilter() instanceof MockFilter);
-		assertTrue(handler.getFormatter() instanceof MockFormatter);
-		assertEquals(handler.getLevel(), Level.FINE);
-		assertNotNull(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 testDefaultValue() throws Exception {
-		handler.publish(r);
-		handler.close();
-		props.clear();
-		manager.readConfiguration(EnvironmentHelper
-				.PropertiesToInputStream(props));
-		handler = new FileHandler();
-		assertNull(handler.getEncoding());
-		assertNull(handler.getFilter());
-		assertTrue(handler.getFormatter() instanceof XMLFormatter);
-		assertEquals(handler.getLevel(), Level.ALL);
-		assertNotNull(handler.getErrorManager());
-		handler.publish(r);
-		handler.close();
-		// output 3 times, and only one record left
-		// default append mode is false
-		for (int i = 0; i < 3; i++) {
-			handler = new FileHandler();
-			handler.publish(r);
-			handler.close();
-		}
-		assertFileContent(HOMEPATH, "java0.log", new XMLFormatter());
-	}
-
-	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);
-			// System.out.println(new String(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
-     *
-	 * @param homepath
-	 * @param filename
-	 */
-	private void reset(String homepath, String filename) {
-		File file = null;
-		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();
-		}
-	}
-
-	public void testLimitAndCount() throws Exception {
-		handler.close();
-		// very small limit value, count=2
-		// output, rename current output file to the second generation file
-		// close it and open a new file as rotation output
-		handler = new FileHandler("%t/testLimitCount%g", 1, 2, false);
-		handler.publish(r);
-		handler.close();
-		assertFileContent(TEMPPATH, "testLimitCount1", handler.getFormatter());
-
-		// very small limit value, count=1
-		// output once, rotate(equals to nothing output)
-		handler = new FileHandler("%t/testLimitCount%g", 1, 1, false);
-		handler.publish(r);
-		handler.close();
-		assertFileContent(TEMPPATH, "testLimitCount0", new LogRecord[0],
-				handler.getFormatter());
-
-		// normal case, limit is 60(>2*msg length <3*msg length), append is
-		// false
-		handler = new FileHandler("%t/testLimitCount%u", 60, 3, false);
-		LogRecord[] rs = new LogRecord[10];
-		// batch output twice to test the append mode
-		for (int i = 0; i < 5; i++) {
-			rs[i] = new LogRecord(Level.SEVERE, "msg" + i);
-			handler.publish(rs[i]);
-		}
-		handler.close();
-		handler = new FileHandler("%t/testLimitCount%u", 60, 3, false);
-		for (int i = 5; i < 10; i++) {
-			rs[i] = new LogRecord(Level.SEVERE, "msg" + i);
-			handler.publish(rs[i]);
-		}
-
-		assertFileContent(TEMPPATH, "testLimitCount0.1", new LogRecord[] {
-				rs[5], rs[6], rs[7] }, handler.getFormatter());
-		assertFileContent(TEMPPATH, "testLimitCount0.0", new LogRecord[] {
-				rs[8], rs[9] }, handler.getFormatter());
-
-		// normal case, limit is 60(>2*msg length <3*msg length), append is true
-		handler = new FileHandler("%t/testLimitCount%u", 60, 3, false);
-		// batch output twice to test the append mode
-		for (int i = 0; i < 5; i++) {
-			rs[i] = new LogRecord(Level.SEVERE, "msg" + i);
-			handler.publish(rs[i]);
-		}
-		handler.close();
-		handler = new FileHandler("%t/testLimitCount%u", 60, 3, true);
-		for (int i = 5; i < 10; i++) {
-			rs[i] = new LogRecord(Level.SEVERE, "msg" + i);
-			handler.publish(rs[i]);
-		}
-		handler.close();
-		assertFileContent(TEMPPATH, "testLimitCount0.2", new LogRecord[] {
-				rs[3], rs[4], null, rs[5] }, handler.getFormatter());
-		assertFileContent(TEMPPATH, "testLimitCount0.1", new LogRecord[] {
-				rs[6], rs[7], rs[8] }, handler.getFormatter());
-		assertFileContent(TEMPPATH, "testLimitCount0.0",
-				new LogRecord[] { rs[9] }, handler.getFormatter());
-		
-        FileHandler h1 = null;
-        FileHandler h2 = null;
-        try {
-            File logDir = new File("log");
-            reset("log",""); 
-            logDir.mkdir();
-            h1 = new FileHandler("log/a", 0, 1);
-            assertNotNull(h1);
-            h2 = new FileHandler("log/a", 0, 1, false);
-            assertNotNull(h2);
-        } finally {
-            try{
-                h1.close();
-            }catch(Exception e){
-            }
-            try{
-                h2.close();
-            }catch(Exception e){
-            }
-            reset("log", "");
-        }	
-	}
-
-	public void testSecurity() throws IOException {
-		SecurityManager currentManager = System.getSecurityManager();
-
-		try {
-			System.setSecurityManager(new MockLogSecurityManager());
-			try {
-				handler.close();
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-
-			handler.publish(new LogRecord(Level.SEVERE, "msg"));
-			try {
-				handler = new FileHandler();
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-
-			try {
-				handler = new FileHandler("pattern1");
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-			try {
-				handler = new FileHandler("pattern2", true);
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-			try {
-				handler = new FileHandler("pattern3", 1000, 1);
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-			try {
-				handler = new FileHandler("pattern4", 1000, 1, true);
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-		} finally {
-			System.setSecurityManager(currentManager);
-		}
-
-	}
-
-	public void testFileSecurity() throws IOException {
-		SecurityManager currentManager = System.getSecurityManager();
-
-		try {
-			System.setSecurityManager(new MockFileSecurityManager());
-			handler.publish(new LogRecord(Level.SEVERE, "msg"));
-			handler.close();
-			try {
-				handler = new FileHandler();
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-
-			try {
-				handler = new FileHandler("pattern1");
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-			try {
-				handler = new FileHandler("pattern2", true);
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-			try {
-				handler = new FileHandler("pattern3", 1000, 1);
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-			try {
-				handler = new FileHandler("pattern4", 1000, 1, true);
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-		} finally {
-			System.setSecurityManager(currentManager);
-		}
-	}
-
-	public void testInvalidProperty() throws Exception {
-		props.put("java.util.logging.FileHandler.level", "null");
-		props.put("java.util.logging.FileHandler.filter", className
-				+ "$MockFilte");
-		props.put("java.util.logging.FileHandler.formatter", className
-				+ "$MockFormatte");
-		props.put("java.util.logging.FileHandler.encoding", "ut");
-		// limit to only two message
-		props.put("java.util.logging.FileHandler.limit", "-1");
-		// rotation count is 2
-		props.put("java.util.logging.FileHandler.count", "-1");
-		// using append mode
-		props.put("java.util.logging.FileHandler.append", "bad");
-
-		handler.close();
-
-		manager.readConfiguration(EnvironmentHelper
-				.PropertiesToInputStream(props));
-		handler = new FileHandler();
-		assertEquals(Level.ALL, handler.getLevel());
-		assertEquals(null, handler.getFilter());
-		assertTrue(handler.getFormatter() instanceof XMLFormatter);
-		assertNull(handler.getEncoding());
-		handler.close();
-
-		props.put("java.util.logging.FileHandler.pattern", "");
-		manager.readConfiguration(EnvironmentHelper
-				.PropertiesToInputStream(props));
-		try {
-			handler = new FileHandler();
-			fail("shouldn't open file with empty name");
-		} catch (NullPointerException e) {
-		}
-	}
-
-	public void testInvalidParams() throws IOException {
-
-		// %t and %p parsing can add file separator automatically
-		FileHandler h1 = new FileHandler("%taaa");
-		h1.close();
-		File file = new File(TEMPPATH + SEP + "aaa");
-		assertTrue(file.exists());
-		reset(TEMPPATH, "aaa");
-
-		// always parse special pattern
-		try {
-			h1 = new FileHandler("%t/%h");
-			fail("should throw null exception");
-		} catch (FileNotFoundException e) {
-		}
-		h1 = new FileHandler("%t%g");
-		h1.close();
-		file = new File(TEMPPATH + SEP + "0");
-		assertTrue(file.exists());
-		reset(TEMPPATH, "0");
-		h1 = new FileHandler("%t%u%g");
-		h1.close();
-		file = new File(TEMPPATH + SEP + "00");
-		assertTrue(file.exists());
-		reset(TEMPPATH, "00");
-
-		// this is normal case
-		h1 = new FileHandler("%t/%u%g%%g");
-		h1.close();
-		file = new File(TEMPPATH + SEP + "00%g");
-		assertTrue(file.exists());
-		reset(TEMPPATH, "00%g");
-
-		// multi separator has no effect
-		h1 = new FileHandler("//%t//multi%g");
-		h1.close();
-		file = new File(TEMPPATH + SEP + "multi0");
-		assertTrue(file.exists());
-		reset(TEMPPATH, "multi0");
-
-		// bad directory, IOException
-		try {
-			h1 = new FileHandler("%t/baddir/multi%g");
-			fail("should throw IO exception");
-		} catch (IOException e) {
-		}
-		file = new File(TEMPPATH + SEP + "baddir" + SEP + "multi0");
-		assertFalse(file.exists());
-
-		try {
-			new FileHandler(null);
-			fail("should throw null exception");
-		} catch (NullPointerException e) {
-		}
-		try {
-			handler.publish(null);
-		} catch (NullPointerException e) {
-			fail("should not throw NPE");
-		}
-		try {
-			new FileHandler(null, false);
-			fail("should throw null exception");
-		} catch (NullPointerException e) {
-		}
-		try {
-            // regression test for Harmony-1299
-            new FileHandler("");
-            fail("should throw IllegalArgumentException");
-        } catch (IllegalArgumentException e) {
-            // expected 
-        }
-		try {
-			new FileHandler("%t/java%u", 0, 0);
-			fail("should throw IllegalArgumentException");
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			new FileHandler("%t/java%u", -1, 1);
-			fail("should throw IllegalArgumentException");
-		} catch (IllegalArgumentException e) {
-		}
-	}
-
-	// set output stream still works, just like super StreamHandler
-	public void testSetOutputStream() throws Exception {
-		MockFileHandler handler = new MockFileHandler("%h/setoutput.log");
-		handler.setFormatter(new MockFormatter());
-		handler.publish(r);
-
-		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		handler.publicSetOutputStream(out);
-		handler.publish(r);
-		handler.close();
-		String msg = new String(out.toByteArray());
-		Formatter f = handler.getFormatter();
-		assertEquals(msg, f.getHead(handler) + f.format(r) + f.getTail(handler));
-		assertFileContent(HOMEPATH, "setoutput.log", handler.getFormatter());
-	}
-
-	/*
-	 * Class under test for void FileHandler(String)
-	 */
-	public void testFileHandlerString() throws Exception {
-		// 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(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(file.list().length <= 2);
-	}
-
-	/*
-	 * 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";
-		}
-	}
-
-	public static class MockLogSecurityManager extends SecurityManager {
-		public void checkPermission(Permission perm) {
-			if (perm instanceof LoggingPermission) {
-				throw new SecurityException();
-			}
-			return;
-		}
-	}
-
-	public static class MockFileSecurityManager extends SecurityManager {
-		public void checkPermission(Permission perm) {
-			if (perm instanceof FilePermission) {
-				throw new SecurityException();
-			}
-		}
-	}
-
-	public static class MockFileHandler extends FileHandler {
-		public MockFileHandler() throws IOException {
-			super();
-		}
-
-		public MockFileHandler(String pattern) throws IOException {
-			super(pattern);
-		}
-
-		public void publicSetOutputStream(OutputStream stream) {
-			super.setOutputStream(stream);
-		}
-	}
-
-}
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed 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 java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FilePermission;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.StringWriter;
+import java.security.Permission;
+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 java.util.logging.LoggingPermission;
+import java.util.logging.XMLFormatter;
+
+import junit.framework.TestCase;
+import org.apache.harmony.logging.tests.java.util.logging.util.DefaultPropertyHelper;
+import org.apache.harmony.logging.tests.java.util.logging.util.EnvironmentHelper;
+
+/**
+ */
+public class FileHandlerTest extends TestCase {
+
+	static LogManager manager;
+
+	final static Properties props = new Properties();
+
+	final static String className = FileHandlerTest.class.getName();
+
+	final static StringWriter writer = new StringWriter();
+
+	final static SecurityManager securityManager = new MockLogSecurityManager();
+
+	final static String HOMEPATH = System.getProperty("user.home");
+
+	final static String TEMPPATH = System.getProperty("java.io.tmpdir");
+
+	final static String SEP = File.separator;
+
+	private static File bakPropFile = null;
+
+	static {
+		try {
+			bakPropFile = DefaultPropertyHelper.init();
+		} catch (Exception e) {
+		}
+		Runtime.getRuntime().addShutdownHook(new Thread() {
+			public void run() {
+				DefaultPropertyHelper.reset(bakPropFile);
+			}
+		});
+	}
+
+	FileHandler handler;
+
+	LogRecord r;
+
+	/*
+	 * @see TestCase#setUp()
+	 */
+	protected void setUp() throws Exception {
+		super.setUp();
+		manager = LogManager.getLogManager();
+		manager.reset();
+		initProps();
+		File file = new File(TEMPPATH + SEP + "log");
+		file.mkdir();
+		manager.readConfiguration(EnvironmentHelper
+				.PropertiesToInputStream(props));
+		handler = new FileHandler();
+		r = new LogRecord(Level.CONFIG, "msg");
+
+	}
+
+	/**
+	 * 
+	 */
+	private void initProps() {
+		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");
+	}
+
+	/*
+	 * @see TestCase#tearDown()
+	 */
+	protected void tearDown() throws Exception {
+		if (null != handler) {
+			handler.close();
+		}
+		reset(TEMPPATH + SEP + "log", "");
+		super.tearDown();
+	}
+
+	public void testLock() throws Exception {
+		FileOutputStream output = new FileOutputStream(TEMPPATH + SEP + "log"
+				+ SEP + "java1.test.0");
+		FileHandler h = new FileHandler();
+		h.publish(r);
+		h.close();
+		assertFileContent(TEMPPATH + SEP + "log", "java1.test.0", h
+				.getFormatter());
+		output.close();
+	}
+
+	/*
+	 * Class under test for void FileHandler()
+	 */
+	public void testFileHandler() throws Exception {
+		assertEquals(handler.getEncoding(), "iso-8859-1");
+		assertTrue(handler.getFilter() instanceof MockFilter);
+		assertTrue(handler.getFormatter() instanceof MockFormatter);
+		assertEquals(handler.getLevel(), Level.FINE);
+		assertNotNull(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 testDefaultValue() throws Exception {
+		handler.publish(r);
+		handler.close();
+		props.clear();
+		manager.readConfiguration(EnvironmentHelper
+				.PropertiesToInputStream(props));
+		handler = new FileHandler();
+		assertNull(handler.getEncoding());
+		assertNull(handler.getFilter());
+		assertTrue(handler.getFormatter() instanceof XMLFormatter);
+		assertEquals(handler.getLevel(), Level.ALL);
+		assertNotNull(handler.getErrorManager());
+		handler.publish(r);
+		handler.close();
+		// output 3 times, and only one record left
+		// default append mode is false
+		for (int i = 0; i < 3; i++) {
+			handler = new FileHandler();
+			handler.publish(r);
+			handler.close();
+		}
+		assertFileContent(HOMEPATH, "java0.log", new XMLFormatter());
+	}
+
+	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);
+			// System.out.println(new String(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
+     *
+	 * @param homepath
+	 * @param filename
+	 */
+	private void reset(String homepath, String filename) {
+		File file = null;
+		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();
+		}
+	}
+
+	public void testLimitAndCount() throws Exception {
+		handler.close();
+		// very small limit value, count=2
+		// output, rename current output file to the second generation file
+		// close it and open a new file as rotation output
+		handler = new FileHandler("%t/testLimitCount%g", 1, 2, false);
+		handler.publish(r);
+		handler.close();
+		assertFileContent(TEMPPATH, "testLimitCount1", handler.getFormatter());
+
+		// very small limit value, count=1
+		// output once, rotate(equals to nothing output)
+		handler = new FileHandler("%t/testLimitCount%g", 1, 1, false);
+		handler.publish(r);
+		handler.close();
+		assertFileContent(TEMPPATH, "testLimitCount0", new LogRecord[0],
+				handler.getFormatter());
+
+		// normal case, limit is 60(>2*msg length <3*msg length), append is
+		// false
+		handler = new FileHandler("%t/testLimitCount%u", 60, 3, false);
+		LogRecord[] rs = new LogRecord[10];
+		// batch output twice to test the append mode
+		for (int i = 0; i < 5; i++) {
+			rs[i] = new LogRecord(Level.SEVERE, "msg" + i);
+			handler.publish(rs[i]);
+		}
+		handler.close();
+		handler = new FileHandler("%t/testLimitCount%u", 60, 3, false);
+		for (int i = 5; i < 10; i++) {
+			rs[i] = new LogRecord(Level.SEVERE, "msg" + i);
+			handler.publish(rs[i]);
+		}
+
+		assertFileContent(TEMPPATH, "testLimitCount0.1", new LogRecord[] {
+				rs[5], rs[6], rs[7] }, handler.getFormatter());
+		assertFileContent(TEMPPATH, "testLimitCount0.0", new LogRecord[] {
+				rs[8], rs[9] }, handler.getFormatter());
+
+		// normal case, limit is 60(>2*msg length <3*msg length), append is true
+		handler = new FileHandler("%t/testLimitCount%u", 60, 3, false);
+		// batch output twice to test the append mode
+		for (int i = 0; i < 5; i++) {
+			rs[i] = new LogRecord(Level.SEVERE, "msg" + i);
+			handler.publish(rs[i]);
+		}
+		handler.close();
+		handler = new FileHandler("%t/testLimitCount%u", 60, 3, true);
+		for (int i = 5; i < 10; i++) {
+			rs[i] = new LogRecord(Level.SEVERE, "msg" + i);
+			handler.publish(rs[i]);
+		}
+		handler.close();
+		assertFileContent(TEMPPATH, "testLimitCount0.2", new LogRecord[] {
+				rs[3], rs[4], null, rs[5] }, handler.getFormatter());
+		assertFileContent(TEMPPATH, "testLimitCount0.1", new LogRecord[] {
+				rs[6], rs[7], rs[8] }, handler.getFormatter());
+		assertFileContent(TEMPPATH, "testLimitCount0.0",
+				new LogRecord[] { rs[9] }, handler.getFormatter());
+		
+        FileHandler h1 = null;
+        FileHandler h2 = null;
+        try {
+            File logDir = new File("log");
+            reset("log",""); 
+            logDir.mkdir();
+            h1 = new FileHandler("log/a", 0, 1);
+            assertNotNull(h1);
+            h2 = new FileHandler("log/a", 0, 1, false);
+            assertNotNull(h2);
+        } finally {
+            try{
+                h1.close();
+            }catch(Exception e){
+            }
+            try{
+                h2.close();
+            }catch(Exception e){
+            }
+            reset("log", "");
+        }	
+	}
+
+	public void testSecurity() throws IOException {
+		SecurityManager currentManager = System.getSecurityManager();
+
+		try {
+			System.setSecurityManager(new MockLogSecurityManager());
+			try {
+				handler.close();
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+
+			handler.publish(new LogRecord(Level.SEVERE, "msg"));
+			try {
+				handler = new FileHandler();
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+
+			try {
+				handler = new FileHandler("pattern1");
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+			try {
+				handler = new FileHandler("pattern2", true);
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+			try {
+				handler = new FileHandler("pattern3", 1000, 1);
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+			try {
+				handler = new FileHandler("pattern4", 1000, 1, true);
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+		} finally {
+			System.setSecurityManager(currentManager);
+		}
+
+	}
+
+	public void testFileSecurity() throws IOException {
+		SecurityManager currentManager = System.getSecurityManager();
+
+		try {
+			System.setSecurityManager(new MockFileSecurityManager());
+			handler.publish(new LogRecord(Level.SEVERE, "msg"));
+			handler.close();
+			try {
+				handler = new FileHandler();
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+
+			try {
+				handler = new FileHandler("pattern1");
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+			try {
+				handler = new FileHandler("pattern2", true);
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+			try {
+				handler = new FileHandler("pattern3", 1000, 1);
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+			try {
+				handler = new FileHandler("pattern4", 1000, 1, true);
+				fail("should throw security exception");
+			} catch (SecurityException e) {
+			}
+		} finally {
+			System.setSecurityManager(currentManager);
+		}
+	}
+
+	public void testInvalidProperty() throws Exception {
+		props.put("java.util.logging.FileHandler.level", "null");
+		props.put("java.util.logging.FileHandler.filter", className
+				+ "$MockFilte");
+		props.put("java.util.logging.FileHandler.formatter", className
+				+ "$MockFormatte");
+		props.put("java.util.logging.FileHandler.encoding", "ut");
+		// limit to only two message
+		props.put("java.util.logging.FileHandler.limit", "-1");
+		// rotation count is 2
+		props.put("java.util.logging.FileHandler.count", "-1");
+		// using append mode
+		props.put("java.util.logging.FileHandler.append", "bad");
+
+		handler.close();
+
+		manager.readConfiguration(EnvironmentHelper
+				.PropertiesToInputStream(props));
+		handler = new FileHandler();
+		assertEquals(Level.ALL, handler.getLevel());
+		assertEquals(null, handler.getFilter());
+		assertTrue(handler.getFormatter() instanceof XMLFormatter);
+		assertNull(handler.getEncoding());
+		handler.close();
+
+		props.put("java.util.logging.FileHandler.pattern", "");
+		manager.readConfiguration(EnvironmentHelper
+				.PropertiesToInputStream(props));
+		try {
+			handler = new FileHandler();
+			fail("shouldn't open file with empty name");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	public void testInvalidParams() throws IOException {
+
+		// %t and %p parsing can add file separator automatically
+		FileHandler h1 = new FileHandler("%taaa");
+		h1.close();
+		File file = new File(TEMPPATH + SEP + "aaa");
+		assertTrue(file.exists());
+		reset(TEMPPATH, "aaa");
+
+		// always parse special pattern
+		try {
+			h1 = new FileHandler("%t/%h");
+			fail("should throw null exception");
+		} catch (FileNotFoundException e) {
+		}
+		h1 = new FileHandler("%t%g");
+		h1.close();
+		file = new File(TEMPPATH + SEP + "0");
+		assertTrue(file.exists());
+		reset(TEMPPATH, "0");
+		h1 = new FileHandler("%t%u%g");
+		h1.close();
+		file = new File(TEMPPATH + SEP + "00");
+		assertTrue(file.exists());
+		reset(TEMPPATH, "00");
+
+		// this is normal case
+		h1 = new FileHandler("%t/%u%g%%g");
+		h1.close();
+		file = new File(TEMPPATH + SEP + "00%g");
+		assertTrue(file.exists());
+		reset(TEMPPATH, "00%g");
+
+		// multi separator has no effect
+		h1 = new FileHandler("//%t//multi%g");
+		h1.close();
+		file = new File(TEMPPATH + SEP + "multi0");
+		assertTrue(file.exists());
+		reset(TEMPPATH, "multi0");
+
+		// bad directory, IOException
+		try {
+			h1 = new FileHandler("%t/baddir/multi%g");
+			fail("should throw IO exception");
+		} catch (IOException e) {
+		}
+		file = new File(TEMPPATH + SEP + "baddir" + SEP + "multi0");
+		assertFalse(file.exists());
+
+		try {
+			new FileHandler(null);
+			fail("should throw null exception");
+		} catch (NullPointerException e) {
+		}
+		try {
+			handler.publish(null);
+		} catch (NullPointerException e) {
+			fail("should not throw NPE");
+		}
+		try {
+			new FileHandler(null, false);
+			fail("should throw null exception");
+		} catch (NullPointerException e) {
+		}
+		try {
+            // regression test for Harmony-1299
+            new FileHandler("");
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            // expected 
+        }
+		try {
+			new FileHandler("%t/java%u", 0, 0);
+			fail("should throw IllegalArgumentException");
+		} catch (IllegalArgumentException e) {
+		}
+		try {
+			new FileHandler("%t/java%u", -1, 1);
+			fail("should throw IllegalArgumentException");
+		} catch (IllegalArgumentException e) {
+		}
+	}
+
+	// set output stream still works, just like super StreamHandler
+	public void testSetOutputStream() throws Exception {
+		MockFileHandler handler = new MockFileHandler("%h/setoutput.log");
+		handler.setFormatter(new MockFormatter());
+		handler.publish(r);
+
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		handler.publicSetOutputStream(out);
+		handler.publish(r);
+		handler.close();
+		String msg = new String(out.toByteArray());
+		Formatter f = handler.getFormatter();
+		assertEquals(msg, f.getHead(handler) + f.format(r) + f.getTail(handler));
+		assertFileContent(HOMEPATH, "setoutput.log", handler.getFormatter());
+	}
+
+	/*
+	 * Class under test for void FileHandler(String)
+	 */
+	public void testFileHandlerString() throws Exception {
+		// 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(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(file.list().length <= 2);
+	}
+
+	/*
+	 * 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";
+		}
+	}
+
+	public static class MockLogSecurityManager extends SecurityManager {
+		public void checkPermission(Permission perm) {
+			if (perm instanceof LoggingPermission) {
+				throw new SecurityException();
+			}
+			return;
+		}
+	}
+
+	public static class MockFileSecurityManager extends SecurityManager {
+		public void checkPermission(Permission perm) {
+			if (perm instanceof FilePermission) {
+				throw new SecurityException();
+			}
+		}
+	}
+
+	public static class MockFileHandler extends FileHandler {
+		public MockFileHandler() throws IOException {
+			super();
+		}
+
+		public MockFileHandler(String pattern) throws IOException {
+			super(pattern);
+		}
+
+		public void publicSetOutputStream(OutputStream stream) {
+			super.setOutputStream(stream);
+		}
+	}
+
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FileHandlerTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FilterTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FilterTest.java?rev=438419&r1=438418&r2=438419&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FilterTest.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FilterTest.java Wed Aug 30 01:22:13 2006
@@ -1,42 +1,42 @@
-/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
- * 
- * Licensed 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 java.util.logging.Filter;
-import java.util.logging.LogRecord;
-
-import junit.framework.TestCase;
-
-/**
- * This testcase verifies the signature of the interface Filter.
- * 
- */
-public class FilterTest extends TestCase {
-	public void testFilter() {
-		MockFilter f = new MockFilter();
-		f.isLoggable(null);
-	}
-
-	/*
-	 * This inner class implements the interface Filter to verify the signature.
-	 */
-	private class MockFilter implements Filter {
-
-		public boolean isLoggable(LogRecord record) {
-			return false;
-		}
-	}
-}
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed 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 java.util.logging.Filter;
+import java.util.logging.LogRecord;
+
+import junit.framework.TestCase;
+
+/**
+ * This testcase verifies the signature of the interface Filter.
+ * 
+ */
+public class FilterTest extends TestCase {
+	public void testFilter() {
+		MockFilter f = new MockFilter();
+		f.isLoggable(null);
+	}
+
+	/*
+	 * This inner class implements the interface Filter to verify the signature.
+	 */
+	private class MockFilter implements Filter {
+
+		public boolean isLoggable(LogRecord record) {
+			return false;
+		}
+	}
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FilterTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FormatterTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FormatterTest.java?rev=438419&r1=438418&r2=438419&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FormatterTest.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FormatterTest.java Wed Aug 30 01:22:13 2006
@@ -1,133 +1,133 @@
-/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
- * 
- * Licensed 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 java.text.MessageFormat;
-import java.util.Locale;
-import java.util.ResourceBundle;
-import java.util.logging.Formatter;
-import java.util.logging.Level;
-import java.util.logging.LogRecord;
-
-import junit.framework.TestCase;
-
-public class FormatterTest extends TestCase {
-	Formatter f;
-
-	LogRecord r;
-
-	static String MSG = "msg, pls. ignore it";
-
-	/*
-	 * @see TestCase#setUp()
-	 */
-	protected void setUp() throws Exception {
-		super.setUp();
-		f = new MockFormatter();
-		r = new LogRecord(Level.FINE, MSG);
-	}
-
-	public void testFormat() {
-		assertEquals("format", f.format(r));
-	}
-
-	public void testGetHead() {
-		assertEquals("", f.getHead(null));
-	}
-
-	public void testGetTail() {
-		assertEquals("", f.getTail(null));
-	}
-
-	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.1) };
-		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 = "pattern without 0 {1, number}";
-		r.setMessage(pattern);
-		assertEquals(pattern, f.formatMessage(r));
-
-		pattern = null;
-		r.setMessage(pattern);
-		assertNull(f.formatMessage(r));
-	}
-
-	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";
-		}
-
-	}
-
-}
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed 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 java.text.MessageFormat;
+import java.util.Locale;
+import java.util.ResourceBundle;
+import java.util.logging.Formatter;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+
+import junit.framework.TestCase;
+
+public class FormatterTest extends TestCase {
+	Formatter f;
+
+	LogRecord r;
+
+	static String MSG = "msg, pls. ignore it";
+
+	/*
+	 * @see TestCase#setUp()
+	 */
+	protected void setUp() throws Exception {
+		super.setUp();
+		f = new MockFormatter();
+		r = new LogRecord(Level.FINE, MSG);
+	}
+
+	public void testFormat() {
+		assertEquals("format", f.format(r));
+	}
+
+	public void testGetHead() {
+		assertEquals("", f.getHead(null));
+	}
+
+	public void testGetTail() {
+		assertEquals("", f.getTail(null));
+	}
+
+	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.1) };
+		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 = "pattern without 0 {1, number}";
+		r.setMessage(pattern);
+		assertEquals(pattern, f.formatMessage(r));
+
+		pattern = null;
+		r.setMessage(pattern);
+		assertNull(f.formatMessage(r));
+	}
+
+	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";
+		}
+
+	}
+
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/FormatterTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Modified: incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/HandlerTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/HandlerTest.java?rev=438419&r1=438418&r2=438419&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/HandlerTest.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/HandlerTest.java Wed Aug 30 01:22:13 2006
@@ -1,586 +1,586 @@
-/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
- * 
- * Licensed 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 java.io.UnsupportedEncodingException;
-import java.security.Permission;
-import java.util.Properties;
-import java.util.logging.ErrorManager;
-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 java.util.logging.LoggingPermission;
-import java.util.logging.SimpleFormatter;
-
-import junit.framework.TestCase;
-import org.apache.harmony.logging.tests.java.util.logging.util.EnvironmentHelper;
-import tests.util.CallVerificationStack;
-
-/**
- * Test suite for the class java.util.logging.Handler.
- * 
- */
-public class HandlerTest extends TestCase {
-	private static String className = HandlerTest.class.getName();
-
-	/*
-	 * @see TestCase#setUp()
-	 */
-	protected void setUp() throws Exception {
-		super.setUp();
-	}
-
-	/*
-	 * @see TestCase#tearDown()
-	 */
-	protected void tearDown() throws Exception {
-		super.tearDown();
-        CallVerificationStack.getInstance().clear();
-	}
-
-	/**
-	 * Constructor for HandlerTest.
-	 * 
-	 * @param arg0
-	 */
-	public HandlerTest(String arg0) {
-		super(arg0);
-	}
-
-	/*
-	 * Test the constructor.
-	 */
-	public void testConstructor() {
-		MockHandler h = new MockHandler();
-		assertSame(h.getLevel(), Level.ALL);
-		assertNull(h.getFormatter());
-		assertNull(h.getFilter());
-		assertNull(h.getEncoding());
-		assertTrue(h.getErrorManager() instanceof ErrorManager);
-	}
-
-	/*
-	 * Test the constructor, with properties set
-	 */
-	public void testConstructor_Properties() throws Exception {
-		Properties p = new Properties();
-		p.put("java.util.logging.MockHandler.level", "FINE");
-		p
-				.put("java.util.logging.MockHandler.filter", className
-						+ "$MockFilter");
-		p.put("java.util.logging.Handler.formatter", className
-				+ "$MockFormatter");
-		p.put("java.util.logging.MockHandler.encoding", "utf-8");
-		LogManager.getLogManager().readConfiguration(
-				EnvironmentHelper.PropertiesToInputStream(p));
-
-		assertEquals(LogManager.getLogManager().getProperty(
-				"java.util.logging.MockHandler.level"), "FINE");
-		assertEquals(LogManager.getLogManager().getProperty(
-				"java.util.logging.MockHandler.encoding"), "utf-8");
-		MockHandler h = new MockHandler();
-		assertSame(h.getLevel(), Level.ALL);
-		assertNull(h.getFormatter());
-		assertNull(h.getFilter());
-		assertNull(h.getEncoding());
-		assertTrue(h.getErrorManager() instanceof ErrorManager);
-		LogManager.getLogManager().reset();
-	}
-
-	/*
-	 * Abstract method, no test needed.
-	 */
-	public void testClose() {
-		MockHandler h = new MockHandler();
-		h.close();
-	}
-
-	/*
-	 * Abstract method, no test needed.
-	 */
-	public void testFlush() {
-		MockHandler h = new MockHandler();
-		h.flush();
-	}
-
-	/*
-	 * Abstract method, no test needed.
-	 */
-	public void testPublish() {
-		MockHandler h = new MockHandler();
-		h.publish(null);
-	}
-
-	/*
-	 * Test getEncoding & setEncoding methods with supported encoding.
-	 */
-	public void testGetSetEncoding_Normal() throws Exception {
-		MockHandler h = new MockHandler();
-		h.setEncoding("iso-8859-1");
-		assertEquals("iso-8859-1", h.getEncoding());
-	}
-
-	/*
-	 * Test getEncoding & setEncoding methods with null.
-	 */
-	public void testGetSetEncoding_Null() throws Exception {
-		MockHandler h = new MockHandler();
-		h.setEncoding(null);
-		assertNull(h.getEncoding());
-	}
-
-	/*
-	 * Test getEncoding & setEncoding methods with unsupported encoding.
-	 */
-	public void testGetSetEncoding_Unsupported() {
-		MockHandler h = new MockHandler();
-		try {
-			h.setEncoding("impossible");
-			fail("Should throw UnsupportedEncodingException!");
-		} catch (UnsupportedEncodingException e) {
-		}
-		assertNull(h.getEncoding());
-	}
-
-	/*
-	 * Test setEncoding with insufficient privilege.
-	 */
-	public void testSetEncoding_InsufficientPrivilege() throws Exception {
-		MockHandler h = new MockHandler();
-		SecurityManager oldMan = System.getSecurityManager();
-		System.setSecurityManager(new MockSecurityManager());
-		// set a normal value
-		try {
-			h.setEncoding("iso-8859-1");
-			fail("Should throw SecurityException!");
-		} catch (SecurityException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-		assertNull(h.getEncoding());
-		System.setSecurityManager(new MockSecurityManager());
-		// set an invalid value
-		try {
-
-			h.setEncoding("impossible");
-			fail("Should throw SecurityException!");
-		} catch (SecurityException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-		assertNull(h.getEncoding());
-	}
-
-	/*
-	 * Test getErrorManager & setErrorManager methods with non-null value.
-	 */
-	public void testGetSetErrorManager_Normal() throws Exception {
-		MockHandler h = new MockHandler();
-		ErrorManager man = new ErrorManager();
-		h.setErrorManager(man);
-		assertSame(man, h.getErrorManager());
-	}
-
-	/*
-	 * Test getErrorManager & setErrorManager methods with null.
-	 */
-	public void testGetSetErrorManager_Null() throws Exception {
-		MockHandler h = new MockHandler();
-		// test set null
-		try {
-			h.setErrorManager(null);
-			fail("Should throw NullPointerException!");
-		} catch (NullPointerException e) {
-		}
-
-		// test reset null
-		try {
-			h.setErrorManager(new ErrorManager());
-			h.setErrorManager(null);
-			fail("Should throw NullPointerException!");
-		} catch (NullPointerException e) {
-		}
-	}
-
-	/*
-	 * Test getErrorManager with insufficient privilege.
-	 */
-	public void testGetErrorManager_InsufficientPrivilege() throws Exception {
-		MockHandler h = new MockHandler();
-		SecurityManager oldMan = System.getSecurityManager();
-		System.setSecurityManager(new MockSecurityManager());
-
-		try {
-			h.getErrorManager();
-			fail("Should throw SecurityException!");
-		} catch (SecurityException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-	}
-
-	/*
-	 * Test setErrorManager with insufficient privilege.
-	 */
-	public void testSetErrorManager_InsufficientPrivilege() throws Exception {
-		MockHandler h = new MockHandler();
-		SecurityManager oldMan = System.getSecurityManager();
-		System.setSecurityManager(new MockSecurityManager());
-
-		// set null
-		try {
-
-			h.setErrorManager(null);
-			fail("Should throw SecurityException!");
-		} catch (SecurityException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-		// set a normal value
-		System.setSecurityManager(new MockSecurityManager());
-		try {
-
-			h.setErrorManager(new ErrorManager());
-			fail("Should throw SecurityException!");
-		} catch (SecurityException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-	}
-
-	/*
-	 * Test getFilter & setFilter methods with non-null value.
-	 */
-	public void testGetSetFilter_Normal() throws Exception {
-		MockHandler h = new MockHandler();
-		Filter f = new MockFilter();
-		h.setFilter(f);
-		assertSame(f, h.getFilter());
-	}
-
-	/*
-	 * Test getFilter & setFilter methods with null.
-	 */
-	public void testGetSetFilter_Null() throws Exception {
-		MockHandler h = new MockHandler();
-		// test set null
-		h.setFilter(null);
-
-		// test reset null
-		h.setFilter(new MockFilter());
-		h.setFilter(null);
-	}
-
-	/*
-	 * Test setFilter with insufficient privilege.
-	 */
-	public void testSetFilter_InsufficientPrivilege() throws Exception {
-		MockHandler h = new MockHandler();
-		SecurityManager oldMan = System.getSecurityManager();
-		System.setSecurityManager(new MockSecurityManager());
-
-		// set null
-		try {
-
-			h.setFilter(null);
-			fail("Should throw SecurityException!");
-		} catch (SecurityException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-		// set a normal value
-		System.setSecurityManager(new MockSecurityManager());
-		try {
-
-			h.setFilter(new MockFilter());
-			fail("Should throw SecurityException!");
-		} catch (SecurityException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-	}
-
-	/*
-	 * Test getFormatter & setFormatter methods with non-null value.
-	 */
-	public void testGetSetFormatter_Normal() throws Exception {
-		MockHandler h = new MockHandler();
-		Formatter f = new SimpleFormatter();
-		h.setFormatter(f);
-		assertSame(f, h.getFormatter());
-	}
-
-	/*
-	 * Test getFormatter & setFormatter methods with null.
-	 */
-	public void testGetSetFormatter_Null() throws Exception {
-		MockHandler h = new MockHandler();
-		// test set null
-		try {
-			h.setFormatter(null);
-			fail("Should throw NullPointerException!");
-		} catch (NullPointerException e) {
-		}
-
-		// test reset null
-		try {
-			h.setFormatter(new SimpleFormatter());
-			h.setFormatter(null);
-			fail("Should throw NullPointerException!");
-		} catch (NullPointerException e) {
-		}
-	}
-
-	/*
-	 * Test setFormatter with insufficient privilege.
-	 */
-	public void testSetFormatter_InsufficientPrivilege() throws Exception {
-		MockHandler h = new MockHandler();
-		SecurityManager oldMan = System.getSecurityManager();
-		System.setSecurityManager(new MockSecurityManager());
-
-		// set null
-		try {
-
-			h.setFormatter(null);
-			fail("Should throw SecurityException!");
-		} catch (SecurityException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-		// set a normal value
-		System.setSecurityManager(new MockSecurityManager());
-		try {
-
-			h.setFormatter(new SimpleFormatter());
-			fail("Should throw SecurityException!");
-		} catch (SecurityException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-	}
-
-	/*
-	 * Test getLevel & setLevel methods with non-null value.
-	 */
-	public void testGetSetLevel_Normal() throws Exception {
-		MockHandler h = new MockHandler();
-		Level f = Level.CONFIG;
-		h.setLevel(f);
-		assertSame(f, h.getLevel());
-	}
-
-	/*
-	 * Test getLevel & setLevel methods with null.
-	 */
-	public void testGetSetLevel_Null() throws Exception {
-		MockHandler h = new MockHandler();
-		// test set null
-		try {
-			h.setLevel(null);
-			fail("Should throw NullPointerException!");
-		} catch (NullPointerException e) {
-		}
-
-		// test reset null
-		try {
-			h.setLevel(Level.CONFIG);
-			h.setLevel(null);
-			fail("Should throw NullPointerException!");
-		} catch (NullPointerException e) {
-		}
-	}
-
-	/*
-	 * Test setLevel with insufficient privilege.
-	 */
-	public void testSetLevel_InsufficientPrivilege() throws Exception {
-		MockHandler h = new MockHandler();
-		SecurityManager oldMan = System.getSecurityManager();
-		System.setSecurityManager(new MockSecurityManager());
-
-		// set null
-		try {
-
-			h.setLevel(null);
-			fail("Should throw NullPointerException!");
-		} catch (NullPointerException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-		// set a normal value
-		System.setSecurityManager(new MockSecurityManager());
-		try {
-
-			h.setLevel(Level.CONFIG);
-			fail("Should throw SecurityException!");
-		} catch (SecurityException e) {
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-	}
-
-	/*
-	 * Use no filter
-	 */
-	public void testIsLoggable_NoFilter() {
-		MockHandler h = new MockHandler();
-		LogRecord r = new LogRecord(Level.CONFIG, null);
-		assertTrue(h.isLoggable(r));
-
-		h.setLevel(Level.CONFIG);
-		assertTrue(h.isLoggable(r));
-
-		h.setLevel(Level.SEVERE);
-		assertFalse(h.isLoggable(r));
-
-		r.setLevel(Level.OFF);
-		h.setLevel(Level.OFF);
-		assertFalse(h.isLoggable(r));
-	}
-
-	/*
-	 * Use a filter
-	 */
-	public void testIsLoggable_WithFilter() {
-		MockHandler h = new MockHandler();
-		LogRecord r = new LogRecord(Level.CONFIG, null);
-		h.setFilter(new MockFilter());
-		assertFalse(h.isLoggable(r));
-
-		h.setLevel(Level.CONFIG);
-		assertFalse(h.isLoggable(r));
-		assertSame(r, CallVerificationStack.getInstance().pop());
-
-		h.setLevel(Level.SEVERE);
-		assertFalse(h.isLoggable(r));
-		assertSame(r, CallVerificationStack.getInstance().pop());
-	}
-
-	/**
-	 * @tests java.util.logging.Handler#isLoggable(LogRecord)
-	 */
-	public void testIsLoggable_Null() {
-		MockHandler h = new MockHandler();
-		try {
-			h.isLoggable(null);
-			fail("should throw NullPointerException");
-		} catch (NullPointerException e) {
-			// expected
-		}
-	}
-
-	/*
-	 * Test whether the error manager is actually called with expected
-	 * parameters.
-	 */
-	public void testReportError() {
-		MockHandler h = new MockHandler();
-		h.setErrorManager(new MockErrorManager());
-		SecurityManager oldMan = System.getSecurityManager();
-		System.setSecurityManager(new MockSecurityManager());
-
-		try {
-			Exception ex = new Exception("test exception");
-			// with non-null parameters
-			h.reportError("test msg", ex, -1);
-			assertEquals(-1, CallVerificationStack.getInstance().popInt());
-			assertSame(ex, CallVerificationStack.getInstance().pop());
-			assertEquals("test msg", CallVerificationStack.getInstance().pop());
-			// with null parameters
-			h.reportError(null, null, 0);
-			assertEquals(0, CallVerificationStack.getInstance().popInt());
-			assertSame(null, CallVerificationStack.getInstance().pop());
-			assertEquals(null, CallVerificationStack.getInstance().pop());
-		} catch (SecurityException e) {
-			fail("Should not throw SecurityException!");
-		} finally {
-			System.setSecurityManager(oldMan);
-		}
-	}
-
-	/*
-	 * Used to enable the testing of Handler because Handler is an abstract
-	 * class.
-	 */
-	public static class MockHandler extends Handler {
-
-		public void close() {
-		}
-
-		public void flush() {
-		}
-
-		public void publish(LogRecord record) {
-		}
-
-		public void reportError(String msg, Exception ex, int code) {
-			super.reportError(msg, ex, code);
-		}
-	}
-
-	/*
-	 * Used to grant all permissions except logging control.
-	 */
-	public static class MockSecurityManager extends SecurityManager {
-
-		public MockSecurityManager() {
-		}
-
-		public void checkPermission(Permission perm) {
-			// grant all permissions except logging control
-			if (perm instanceof LoggingPermission) {
-				throw new SecurityException();
-			}
-		}
-
-		public void checkPermission(Permission perm, Object context) {
-			// grant all permissions except logging control
-			if (perm instanceof LoggingPermission) {
-				throw new SecurityException();
-			}
-		}
-	}
-
-	/*
-	 * A mock filter, always return false.
-	 */
-	public static class MockFilter implements Filter {
-
-		public boolean isLoggable(LogRecord record) {
-			CallVerificationStack.getInstance().push(record);
-			return false;
-		}
-	}
-
-	/*
-	 * A mock error manager, used to validate the expected method is called with
-	 * the expected parameters.
-	 */
-	public static class MockErrorManager extends ErrorManager {
-
-		public void error(String msg, Exception ex, int errorCode) {
-			CallVerificationStack.getInstance().push(msg);
-			CallVerificationStack.getInstance().push(ex);
-			CallVerificationStack.getInstance().push(errorCode);
-		}
-
-	}
-
-}
+/* Copyright 2004 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * Licensed 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 java.io.UnsupportedEncodingException;
+import java.security.Permission;
+import java.util.Properties;
+import java.util.logging.ErrorManager;
+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 java.util.logging.LoggingPermission;
+import java.util.logging.SimpleFormatter;
+
+import junit.framework.TestCase;
+import org.apache.harmony.logging.tests.java.util.logging.util.EnvironmentHelper;
+import tests.util.CallVerificationStack;
+
+/**
+ * Test suite for the class java.util.logging.Handler.
+ * 
+ */
+public class HandlerTest extends TestCase {
+	private static String className = HandlerTest.class.getName();
+
+	/*
+	 * @see TestCase#setUp()
+	 */
+	protected void setUp() throws Exception {
+		super.setUp();
+	}
+
+	/*
+	 * @see TestCase#tearDown()
+	 */
+	protected void tearDown() throws Exception {
+		super.tearDown();
+        CallVerificationStack.getInstance().clear();
+	}
+
+	/**
+	 * Constructor for HandlerTest.
+	 * 
+	 * @param arg0
+	 */
+	public HandlerTest(String arg0) {
+		super(arg0);
+	}
+
+	/*
+	 * Test the constructor.
+	 */
+	public void testConstructor() {
+		MockHandler h = new MockHandler();
+		assertSame(h.getLevel(), Level.ALL);
+		assertNull(h.getFormatter());
+		assertNull(h.getFilter());
+		assertNull(h.getEncoding());
+		assertTrue(h.getErrorManager() instanceof ErrorManager);
+	}
+
+	/*
+	 * Test the constructor, with properties set
+	 */
+	public void testConstructor_Properties() throws Exception {
+		Properties p = new Properties();
+		p.put("java.util.logging.MockHandler.level", "FINE");
+		p
+				.put("java.util.logging.MockHandler.filter", className
+						+ "$MockFilter");
+		p.put("java.util.logging.Handler.formatter", className
+				+ "$MockFormatter");
+		p.put("java.util.logging.MockHandler.encoding", "utf-8");
+		LogManager.getLogManager().readConfiguration(
+				EnvironmentHelper.PropertiesToInputStream(p));
+
+		assertEquals(LogManager.getLogManager().getProperty(
+				"java.util.logging.MockHandler.level"), "FINE");
+		assertEquals(LogManager.getLogManager().getProperty(
+				"java.util.logging.MockHandler.encoding"), "utf-8");
+		MockHandler h = new MockHandler();
+		assertSame(h.getLevel(), Level.ALL);
+		assertNull(h.getFormatter());
+		assertNull(h.getFilter());
+		assertNull(h.getEncoding());
+		assertTrue(h.getErrorManager() instanceof ErrorManager);
+		LogManager.getLogManager().reset();
+	}
+
+	/*
+	 * Abstract method, no test needed.
+	 */
+	public void testClose() {
+		MockHandler h = new MockHandler();
+		h.close();
+	}
+
+	/*
+	 * Abstract method, no test needed.
+	 */
+	public void testFlush() {
+		MockHandler h = new MockHandler();
+		h.flush();
+	}
+
+	/*
+	 * Abstract method, no test needed.
+	 */
+	public void testPublish() {
+		MockHandler h = new MockHandler();
+		h.publish(null);
+	}
+
+	/*
+	 * Test getEncoding & setEncoding methods with supported encoding.
+	 */
+	public void testGetSetEncoding_Normal() throws Exception {
+		MockHandler h = new MockHandler();
+		h.setEncoding("iso-8859-1");
+		assertEquals("iso-8859-1", h.getEncoding());
+	}
+
+	/*
+	 * Test getEncoding & setEncoding methods with null.
+	 */
+	public void testGetSetEncoding_Null() throws Exception {
+		MockHandler h = new MockHandler();
+		h.setEncoding(null);
+		assertNull(h.getEncoding());
+	}
+
+	/*
+	 * Test getEncoding & setEncoding methods with unsupported encoding.
+	 */
+	public void testGetSetEncoding_Unsupported() {
+		MockHandler h = new MockHandler();
+		try {
+			h.setEncoding("impossible");
+			fail("Should throw UnsupportedEncodingException!");
+		} catch (UnsupportedEncodingException e) {
+		}
+		assertNull(h.getEncoding());
+	}
+
+	/*
+	 * Test setEncoding with insufficient privilege.
+	 */
+	public void testSetEncoding_InsufficientPrivilege() throws Exception {
+		MockHandler h = new MockHandler();
+		SecurityManager oldMan = System.getSecurityManager();
+		System.setSecurityManager(new MockSecurityManager());
+		// set a normal value
+		try {
+			h.setEncoding("iso-8859-1");
+			fail("Should throw SecurityException!");
+		} catch (SecurityException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+		assertNull(h.getEncoding());
+		System.setSecurityManager(new MockSecurityManager());
+		// set an invalid value
+		try {
+
+			h.setEncoding("impossible");
+			fail("Should throw SecurityException!");
+		} catch (SecurityException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+		assertNull(h.getEncoding());
+	}
+
+	/*
+	 * Test getErrorManager & setErrorManager methods with non-null value.
+	 */
+	public void testGetSetErrorManager_Normal() throws Exception {
+		MockHandler h = new MockHandler();
+		ErrorManager man = new ErrorManager();
+		h.setErrorManager(man);
+		assertSame(man, h.getErrorManager());
+	}
+
+	/*
+	 * Test getErrorManager & setErrorManager methods with null.
+	 */
+	public void testGetSetErrorManager_Null() throws Exception {
+		MockHandler h = new MockHandler();
+		// test set null
+		try {
+			h.setErrorManager(null);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException e) {
+		}
+
+		// test reset null
+		try {
+			h.setErrorManager(new ErrorManager());
+			h.setErrorManager(null);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * Test getErrorManager with insufficient privilege.
+	 */
+	public void testGetErrorManager_InsufficientPrivilege() throws Exception {
+		MockHandler h = new MockHandler();
+		SecurityManager oldMan = System.getSecurityManager();
+		System.setSecurityManager(new MockSecurityManager());
+
+		try {
+			h.getErrorManager();
+			fail("Should throw SecurityException!");
+		} catch (SecurityException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+	}
+
+	/*
+	 * Test setErrorManager with insufficient privilege.
+	 */
+	public void testSetErrorManager_InsufficientPrivilege() throws Exception {
+		MockHandler h = new MockHandler();
+		SecurityManager oldMan = System.getSecurityManager();
+		System.setSecurityManager(new MockSecurityManager());
+
+		// set null
+		try {
+
+			h.setErrorManager(null);
+			fail("Should throw SecurityException!");
+		} catch (SecurityException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+		// set a normal value
+		System.setSecurityManager(new MockSecurityManager());
+		try {
+
+			h.setErrorManager(new ErrorManager());
+			fail("Should throw SecurityException!");
+		} catch (SecurityException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+	}
+
+	/*
+	 * Test getFilter & setFilter methods with non-null value.
+	 */
+	public void testGetSetFilter_Normal() throws Exception {
+		MockHandler h = new MockHandler();
+		Filter f = new MockFilter();
+		h.setFilter(f);
+		assertSame(f, h.getFilter());
+	}
+
+	/*
+	 * Test getFilter & setFilter methods with null.
+	 */
+	public void testGetSetFilter_Null() throws Exception {
+		MockHandler h = new MockHandler();
+		// test set null
+		h.setFilter(null);
+
+		// test reset null
+		h.setFilter(new MockFilter());
+		h.setFilter(null);
+	}
+
+	/*
+	 * Test setFilter with insufficient privilege.
+	 */
+	public void testSetFilter_InsufficientPrivilege() throws Exception {
+		MockHandler h = new MockHandler();
+		SecurityManager oldMan = System.getSecurityManager();
+		System.setSecurityManager(new MockSecurityManager());
+
+		// set null
+		try {
+
+			h.setFilter(null);
+			fail("Should throw SecurityException!");
+		} catch (SecurityException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+		// set a normal value
+		System.setSecurityManager(new MockSecurityManager());
+		try {
+
+			h.setFilter(new MockFilter());
+			fail("Should throw SecurityException!");
+		} catch (SecurityException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+	}
+
+	/*
+	 * Test getFormatter & setFormatter methods with non-null value.
+	 */
+	public void testGetSetFormatter_Normal() throws Exception {
+		MockHandler h = new MockHandler();
+		Formatter f = new SimpleFormatter();
+		h.setFormatter(f);
+		assertSame(f, h.getFormatter());
+	}
+
+	/*
+	 * Test getFormatter & setFormatter methods with null.
+	 */
+	public void testGetSetFormatter_Null() throws Exception {
+		MockHandler h = new MockHandler();
+		// test set null
+		try {
+			h.setFormatter(null);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException e) {
+		}
+
+		// test reset null
+		try {
+			h.setFormatter(new SimpleFormatter());
+			h.setFormatter(null);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * Test setFormatter with insufficient privilege.
+	 */
+	public void testSetFormatter_InsufficientPrivilege() throws Exception {
+		MockHandler h = new MockHandler();
+		SecurityManager oldMan = System.getSecurityManager();
+		System.setSecurityManager(new MockSecurityManager());
+
+		// set null
+		try {
+
+			h.setFormatter(null);
+			fail("Should throw SecurityException!");
+		} catch (SecurityException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+		// set a normal value
+		System.setSecurityManager(new MockSecurityManager());
+		try {
+
+			h.setFormatter(new SimpleFormatter());
+			fail("Should throw SecurityException!");
+		} catch (SecurityException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+	}
+
+	/*
+	 * Test getLevel & setLevel methods with non-null value.
+	 */
+	public void testGetSetLevel_Normal() throws Exception {
+		MockHandler h = new MockHandler();
+		Level f = Level.CONFIG;
+		h.setLevel(f);
+		assertSame(f, h.getLevel());
+	}
+
+	/*
+	 * Test getLevel & setLevel methods with null.
+	 */
+	public void testGetSetLevel_Null() throws Exception {
+		MockHandler h = new MockHandler();
+		// test set null
+		try {
+			h.setLevel(null);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException e) {
+		}
+
+		// test reset null
+		try {
+			h.setLevel(Level.CONFIG);
+			h.setLevel(null);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException e) {
+		}
+	}
+
+	/*
+	 * Test setLevel with insufficient privilege.
+	 */
+	public void testSetLevel_InsufficientPrivilege() throws Exception {
+		MockHandler h = new MockHandler();
+		SecurityManager oldMan = System.getSecurityManager();
+		System.setSecurityManager(new MockSecurityManager());
+
+		// set null
+		try {
+
+			h.setLevel(null);
+			fail("Should throw NullPointerException!");
+		} catch (NullPointerException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+		// set a normal value
+		System.setSecurityManager(new MockSecurityManager());
+		try {
+
+			h.setLevel(Level.CONFIG);
+			fail("Should throw SecurityException!");
+		} catch (SecurityException e) {
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+	}
+
+	/*
+	 * Use no filter
+	 */
+	public void testIsLoggable_NoFilter() {
+		MockHandler h = new MockHandler();
+		LogRecord r = new LogRecord(Level.CONFIG, null);
+		assertTrue(h.isLoggable(r));
+
+		h.setLevel(Level.CONFIG);
+		assertTrue(h.isLoggable(r));
+
+		h.setLevel(Level.SEVERE);
+		assertFalse(h.isLoggable(r));
+
+		r.setLevel(Level.OFF);
+		h.setLevel(Level.OFF);
+		assertFalse(h.isLoggable(r));
+	}
+
+	/*
+	 * Use a filter
+	 */
+	public void testIsLoggable_WithFilter() {
+		MockHandler h = new MockHandler();
+		LogRecord r = new LogRecord(Level.CONFIG, null);
+		h.setFilter(new MockFilter());
+		assertFalse(h.isLoggable(r));
+
+		h.setLevel(Level.CONFIG);
+		assertFalse(h.isLoggable(r));
+		assertSame(r, CallVerificationStack.getInstance().pop());
+
+		h.setLevel(Level.SEVERE);
+		assertFalse(h.isLoggable(r));
+		assertSame(r, CallVerificationStack.getInstance().pop());
+	}
+
+	/**
+	 * @tests java.util.logging.Handler#isLoggable(LogRecord)
+	 */
+	public void testIsLoggable_Null() {
+		MockHandler h = new MockHandler();
+		try {
+			h.isLoggable(null);
+			fail("should throw NullPointerException");
+		} catch (NullPointerException e) {
+			// expected
+		}
+	}
+
+	/*
+	 * Test whether the error manager is actually called with expected
+	 * parameters.
+	 */
+	public void testReportError() {
+		MockHandler h = new MockHandler();
+		h.setErrorManager(new MockErrorManager());
+		SecurityManager oldMan = System.getSecurityManager();
+		System.setSecurityManager(new MockSecurityManager());
+
+		try {
+			Exception ex = new Exception("test exception");
+			// with non-null parameters
+			h.reportError("test msg", ex, -1);
+			assertEquals(-1, CallVerificationStack.getInstance().popInt());
+			assertSame(ex, CallVerificationStack.getInstance().pop());
+			assertEquals("test msg", CallVerificationStack.getInstance().pop());
+			// with null parameters
+			h.reportError(null, null, 0);
+			assertEquals(0, CallVerificationStack.getInstance().popInt());
+			assertSame(null, CallVerificationStack.getInstance().pop());
+			assertEquals(null, CallVerificationStack.getInstance().pop());
+		} catch (SecurityException e) {
+			fail("Should not throw SecurityException!");
+		} finally {
+			System.setSecurityManager(oldMan);
+		}
+	}
+
+	/*
+	 * Used to enable the testing of Handler because Handler is an abstract
+	 * class.
+	 */
+	public static class MockHandler extends Handler {
+
+		public void close() {
+		}
+
+		public void flush() {
+		}
+
+		public void publish(LogRecord record) {
+		}
+
+		public void reportError(String msg, Exception ex, int code) {
+			super.reportError(msg, ex, code);
+		}
+	}
+
+	/*
+	 * Used to grant all permissions except logging control.
+	 */
+	public static class MockSecurityManager extends SecurityManager {
+
+		public MockSecurityManager() {
+		}
+
+		public void checkPermission(Permission perm) {
+			// grant all permissions except logging control
+			if (perm instanceof LoggingPermission) {
+				throw new SecurityException();
+			}
+		}
+
+		public void checkPermission(Permission perm, Object context) {
+			// grant all permissions except logging control
+			if (perm instanceof LoggingPermission) {
+				throw new SecurityException();
+			}
+		}
+	}
+
+	/*
+	 * A mock filter, always return false.
+	 */
+	public static class MockFilter implements Filter {
+
+		public boolean isLoggable(LogRecord record) {
+			CallVerificationStack.getInstance().push(record);
+			return false;
+		}
+	}
+
+	/*
+	 * A mock error manager, used to validate the expected method is called with
+	 * the expected parameters.
+	 */
+	public static class MockErrorManager extends ErrorManager {
+
+		public void error(String msg, Exception ex, int errorCode) {
+			CallVerificationStack.getInstance().push(msg);
+			CallVerificationStack.getInstance().push(ex);
+			CallVerificationStack.getInstance().push(errorCode);
+		}
+
+	}
+
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/logging/src/test/java/org/apache/harmony/logging/tests/java/util/logging/HandlerTest.java
------------------------------------------------------------------------------
    svn:eol-style = native