| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.harmony.logging.tests.java.util.logging; |
| |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestLevel; |
| |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.io.UnsupportedEncodingException; |
| import java.security.Permission; |
| import java.util.EmptyStackException; |
| 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. |
| * |
| */ |
| @TestTargetClass(Handler.class) |
| public class HandlerTest extends TestCase { |
| private static String className = HandlerTest.class.getName(); |
| |
| /* |
| * @see TestCase#tearDown() |
| */ |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| CallVerificationStack.getInstance().clear(); |
| } |
| |
| /* |
| * Test the constructor. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Handler", |
| args = {} |
| ) |
| 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 |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "Handler", |
| args = {} |
| ) |
| 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(); |
| } |
| |
| /* |
| * Test getEncoding & setEncoding methods with supported encoding. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify exceptions.", |
| method = "getEncoding", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify exceptions.", |
| method = "setEncoding", |
| args = {java.lang.String.class} |
| ) |
| }) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies null as a parameter.", |
| method = "getEncoding", |
| args = {} |
| ) |
| public void testGetSetEncoding_Null() throws Exception { |
| MockHandler h = new MockHandler(); |
| h.setEncoding(null); |
| assertNull(h.getEncoding()); |
| } |
| |
| /* |
| * Test getEncoding & setEncoding methods with unsupported encoding. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies UnsupportedEncodingException.", |
| method = "setEncoding", |
| args = {java.lang.String.class} |
| ) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify UnsupportedEncodingException.", |
| method = "setEncoding", |
| args = {java.lang.String.class} |
| ) |
| 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. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "setErrorManager", |
| args = {java.util.logging.ErrorManager.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "getErrorManager", |
| args = {} |
| ) |
| }) |
| 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. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies null as a parameter.", |
| method = "getErrorManager", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies null as a parameter.", |
| method = "setErrorManager", |
| args = {java.util.logging.ErrorManager.class} |
| ) |
| }) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies SecurityException.", |
| method = "getErrorManager", |
| args = {} |
| ) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies setErrorManager with insufficient privilege.", |
| method = "setErrorManager", |
| args = {java.util.logging.ErrorManager.class} |
| ) |
| 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. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify SecurityException.", |
| method = "setFilter", |
| args = {java.util.logging.Filter.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify SecurityException.", |
| method = "getFilter", |
| args = {} |
| ) |
| }) |
| 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. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies null as a parameter.", |
| method = "getFilter", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies null as a parameter.", |
| method = "setFilter", |
| args = {java.util.logging.Filter.class} |
| ) |
| }) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies SecurityException.", |
| method = "setFilter", |
| args = {java.util.logging.Filter.class} |
| ) |
| 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. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify SecurityException.", |
| method = "getFormatter", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify SecurityException.", |
| method = "setFormatter", |
| args = {java.util.logging.Formatter.class} |
| ) |
| }) |
| 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. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies null as a parameter.", |
| method = "getFormatter", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies null as a parameter.", |
| method = "setFormatter", |
| args = {java.util.logging.Formatter.class} |
| ) |
| }) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies SecurityException.", |
| method = "getFormatter", |
| args = {} |
| ) |
| 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. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify SecurityException.", |
| method = "getLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Doesn't verify SecurityException.", |
| method = "setLevel", |
| args = {java.util.logging.Level.class} |
| ) |
| }) |
| 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. |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies getLevel & setLevel methods with null.", |
| method = "getLevel", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies getLevel & setLevel methods with null.", |
| method = "setLevel", |
| args = {java.util.logging.Level.class} |
| ) |
| }) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies NullPointerException, SecurityException.", |
| method = "setLevel", |
| args = {java.util.logging.Level.class} |
| ) |
| 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 |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isLoggable", |
| args = {java.util.logging.LogRecord.class} |
| ) |
| 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 |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Verifies isLoggable method with filter.", |
| method = "isLoggable", |
| args = {java.util.logging.LogRecord.class} |
| ) |
| public void testIsLoggable_WithFilter() { |
| MockHandler h = new MockHandler(); |
| LogRecord r = new LogRecord(Level.CONFIG, null); |
| LogRecord r1 = new LogRecord(Level.CONFIG, null); |
| LogRecord r2 = new LogRecord(Level.CONFIG, null); |
| |
| h.setFilter(new MockFilter()); |
| assertFalse(h.isLoggable(r)); |
| assertSame(r,CallVerificationStack.getInstance().pop()); |
| |
| h.setLevel(Level.CONFIG); |
| assertFalse(h.isLoggable(r1)); |
| assertSame(r1, CallVerificationStack.getInstance().pop()); |
| |
| h.setLevel(Level.SEVERE); |
| assertFalse(h.isLoggable(r2)); |
| |
| try{ |
| CallVerificationStack.getInstance().pop(); |
| }catch(EmptyStackException e){ |
| //normal |
| } |
| } |
| |
| /** |
| * @tests java.util.logging.Handler#isLoggable(LogRecord) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies null as a parameter.", |
| method = "isLoggable", |
| args = {java.util.logging.LogRecord.class} |
| ) |
| 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. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "reportError", |
| args = {java.lang.String.class, java.lang.Exception.class, int.class} |
| ) |
| 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()); |
| assertNull(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); |
| } |
| } |
| |
| public static class NullOutputStream extends OutputStream{ |
| @Override |
| public void write(int arg0) throws IOException { |
| } |
| } |
| |
| } |