/*
* 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.Serializable;
import java.util.ResourceBundle;
import java.util.logging.Handler;
import java.util.logging.Level;
import junit.framework.TestCase;
import org.apache.harmony.testframework.serialization.SerializationTest;
import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
/*
* This class implements Serializable, so that the non-static inner class
* MockLevel can be Serializable.
*/
//@TestTargetClass(Level.class)
public class LevelTest extends TestCase implements Serializable {
private static final long serialVersionUID = 1L;
/**
* Test the constructor without resource bundle parameter using normal
* values. As byproducts, getName & intValue are also tested.
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks the constructor without resource bundle parameter using normal values.",
method = "Level",
args = {java.lang.String.class, int.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks the constructor without resource bundle parameter using normal values.",
method = "getName",
args = {}
)
})
*/
public void testConstructorNoResBundle_Normal() {
MockLevel l = new MockLevel("level1", 1);
assertEquals("level1", l.getName());
assertEquals(1, l.intValue());
assertNull(l.getResourceBundleName());
}
/**
* Test the constructor without resource bundle parameter using null name.
* As byproducts, getName & intValue are also tested.
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks the constructor without resource bundle parameter using null name.",
method = "Level",
args = {java.lang.String.class, int.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks the constructor without resource bundle parameter using null name.",
method = "getName",
args = {}
)
})
*/
public void testConstructorNoResBundle_NullName() {
try {
new MockLevel(null, -2);
fail("No expected NullPointerException");
} catch (NullPointerException ignore) {
// expected
}
}
/*
* Test the constructor without resource bundle parameter using empty name.
* As byproducts, getName & intValue are also tested.
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks the constructor without resource bundle parameter using empty name.",
method = "Level",
args = {java.lang.String.class, int.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks the constructor without resource bundle parameter using empty name.",
method = "getName",
args = {}
)
})
*/
public void testConstructorNoResBundle_EmptyName() {
MockLevel l = new MockLevel("", -3);
assertEquals("", l.getName());
assertEquals(-3, l.intValue());
assertNull(l.getResourceBundleName());
}
/*
* Test the constructor having resource bundle parameter using normal
* values. As byproducts, getName & intValue are also tested.
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "Level",
args = {java.lang.String.class, int.class, java.lang.String.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "getName",
args = {}
)
})
*/
public void testConstructorHavingResBundle_Normal() {
MockLevel l = new MockLevel("level1", 1, "resourceBundle");
assertEquals("level1", l.getName());
assertEquals(1, l.intValue());
assertEquals("resourceBundle", l.getResourceBundleName());
}
/*
* Test the constructor having resource bundle parameter using null names.
* As byproducts, getName & intValue are also tested.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks NullPointerException.",
method = "Level",
args = {java.lang.String.class, int.class, java.lang.String.class}
)
*/
public void testConstructorHavingResBundle_NullName() {
try {
new MockLevel(null, -123, "qwe");
fail("No expected NullPointerException");
} catch (NullPointerException ignore) {
// expected
}
}
/*
* Test the constructor having resource bundle parameter using empty
names.
* As byproducts, getName & intValue are also tested.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies the constructor having resource bundle parameter using empty names.",
method = "Level",
args = {java.lang.String.class, int.class, java.lang.String.class}
)
*/
public void testConstructorHavingResBundle_EmptyName() {
MockLevel l = new MockLevel("", -1000, "");
assertEquals("", l.getName());
assertEquals(-1000, l.intValue());
assertEquals("", l.getResourceBundleName());
}
/*
* Test method parse, with the pre-defined string consts.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies parse, with the pre-defined string consts.",
method = "parse",
args = {java.lang.String.class}
)
*/
public void testParse_PredefinedConstStrings() {
assertSame(Level.SEVERE, Level.parse("SEVERE"));
assertSame(Level.WARNING, Level.parse("WARNING"));
assertSame(Level.INFO, Level.parse("INFO"));
assertSame(Level.CONFIG, Level.parse("CONFIG"));
assertSame(Level.FINE, Level.parse("FINE"));
assertSame(Level.FINER, Level.parse("FINER"));
assertSame(Level.FINEST, Level.parse("FINEST"));
assertSame(Level.OFF, Level.parse("OFF"));
assertSame(Level.ALL, Level.parse("ALL"));
}
/*
* Test method parse, with an undefined string.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "IllegalArgumentException is verified.",
method = "parse",
args = {java.lang.String.class}
)
*/
public void testParse_IllegalConstString() {
try {
Level.parse("SEVERe");
fail("Should throw IllegalArgumentException if undefined string.");
} catch (IllegalArgumentException e) {
// expected
}
}
/*
* Test method parse, with a null string.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies null as a parameter.",
method = "parse",
args = {java.lang.String.class}
)
*/
public void testParse_NullString() {
try {
Level.parse(null);
fail("Should throw NullPointerException.");
} catch (NullPointerException e) {
// expected
}
}
/*
* Test method parse, with pre-defined valid number strings.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies parse, with pre-defined valid number strings.",
method = "parse",
args = {java.lang.String.class}
)
*/
public void testParse_PredefinedNumber() {
assertSame(Level.SEVERE, Level.parse("SEVERE"));
assertSame(Level.WARNING, Level.parse("WARNING"));
assertSame(Level.INFO, Level.parse("INFO"));
assertSame(Level.CONFIG, Level.parse("CONFIG"));
assertSame(Level.FINE, Level.parse("FINE"));
assertSame(Level.FINER, Level.parse("FINER"));
assertSame(Level.FINEST, Level.parse("FINEST"));
assertSame(Level.OFF, Level.parse("OFF"));
assertSame(Level.ALL, Level.parse("ALL"));
assertSame(Level.SEVERE, Level.parse("1000"));
assertSame(Level.WARNING, Level.parse("900"));
assertSame(Level.INFO, Level.parse("800"));
assertSame(Level.CONFIG, Level.parse("700"));
assertSame(Level.FINE, Level.parse("500"));
assertSame(Level.FINER, Level.parse("400"));
assertSame(Level.FINEST, Level.parse("300"));
assertSame(Level.OFF, Level.parse(String.valueOf(Integer.MAX_VALUE)));
assertSame(Level.ALL, Level.parse(String.valueOf(Integer.MIN_VALUE)));
}
/*
* Test method parse, with an undefined valid number strings.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies parse, with an undefined valid number strings.",
method = "parse",
args = {java.lang.String.class}
)
*/
public void testParse_UndefinedNumber() {
Level l = Level.parse("0");
assertEquals(0, l.intValue());
assertEquals("0", l.getName());
assertNull(l.getResourceBundleName());
}
/*
* Test method parse, with an undefined valid number strings with spaces.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies parse, with an undefined valid number strings with spaces.",
method = "parse",
args = {java.lang.String.class}
)
*/
public void testParse_UndefinedNumberWithSpaces() {
try {
Level.parse(" 0");
} catch (IllegalArgumentException e) {
// expected
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies negative number.",
method = "parse",
args = {java.lang.String.class}
)
*/
public void testParse_NegativeNumber() {
Level l = Level.parse("-4");
assertEquals(-4, l.intValue());
assertEquals("-4", l.getName());
assertNull(l.getResourceBundleName());
}
/*
* Test method parse, expecting the same objects will be returned given the
* same name, even for non-predefined levels.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies parse, expecting the same objects will be returned given the same name, even for non-predefined levels.",
method = "parse",
args = {java.lang.String.class}
)
*/
public void testParse_SameObject() {
Level l = Level.parse("-100");
assertSame(l, Level.parse("-100"));
}
/*
* Test method hashCode, with normal fields.
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "hashCode",
args = {}
)
*/
public void testHashCode_Normal() {
assertEquals(100, Level.parse("100").hashCode());
assertEquals(-1, Level.parse("-1").hashCode());
assertEquals(0, Level.parse("0").hashCode());
assertEquals(Integer.MIN_VALUE, Level.parse("ALL").hashCode());
}
/*
* Test equals when two objects are equal.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't check negative case.",
method = "equals",
args = {java.lang.Object.class}
)
*/
public void testEquals_Equal() {
MockLevel l1 = new MockLevel("level1", 1);
MockLevel l2 = new MockLevel("level2", 1);
assertEquals(l1, l2);
assertEquals(l2, l1);
}
/*
* Test equals when two objects are not equal.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks negative case.",
method = "equals",
args = {java.lang.Object.class}
)
*/
public void testEquals_NotEqual() {
MockLevel l1 = new MockLevel("level1", 1);
MockLevel l2 = new MockLevel("level1", 2);
assertFalse(l1.equals(l2));
assertFalse(l2.equals(l1));
}
/*
* Test equals when the other object is null.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks null as a parameter.",
method = "equals",
args = {java.lang.Object.class}
)
*/
public void testEquals_Null() {
assertFalse(Level.ALL.equals(null));
}
/*
* Test equals when the other object is not an instance of Level.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks negative case.",
method = "equals",
args = {java.lang.Object.class}
)
*/
public void testEquals_NotLevel() {
assertFalse(Level.ALL.equals(new Object()));
}
/*
* Test equals when the other object is itself.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks equals when the other object is itself.",
method = "equals",
args = {java.lang.Object.class}
)
*/
public void testEquals_Itself() {
assertTrue(Level.ALL.equals(Level.ALL));
}
/*
* Test toString of a normal Level.
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
*/
public void testToString_Normal() {
assertEquals("ALL", Level.ALL.toString());
MockLevel l = new MockLevel("name", 2);
assertEquals("name", l.toString());
MockLevel emptyLevel = new MockLevel("", 3);
assertEquals("", emptyLevel.toString());
}
// comparator for Level objects:
// is used because Level.equals() method only takes into account
// 'level' value but ignores 'name' and 'resourceBundleName' values
private static final SerializableAssert LEVEL_COMPARATOR = new SerializableAssert() {
public void assertDeserialized(Serializable initial,
Serializable deserialized) {
Level init = (Level) initial;
Level dser = (Level) deserialized;
assertEquals("Class", init.getClass(), dser.getClass());
assertEquals("Name", init.getName(), dser.getName());
assertEquals("Value", init.intValue(), dser.intValue());
assertEquals("ResourceBundleName", init.getResourceBundleName(),
dser.getResourceBundleName());
}
};
/**
* @tests serialization/deserialization compatibility.
*
* Test serialization of pre-defined const levels. It is expected that the
* deserialized cost level should be the same instance as the existing one.
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Serialization of pre-defined const levels. ",
method = "!SerializationSelf",
args = {}
)
*/
public void testSerialization_ConstLevel() throws Exception {
SerializationTest.verifySelf(Level.ALL,
SerializationTest.SAME_COMPARATOR);
}
/**
* @tests serialization/deserialization compatibility.
*
* Test serialization of normal instance of Level. It is expected that the
* deserialized level object should be equal to the original one.
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Test serialization of normal instance of Level.",
method = "!SerializationSelf",
args = {}
)
*/
public void testSerialization_InstanceLevel() throws Exception {
// tests that objects are the same
Level[] objectsToTest = new Level[] { Level.parse("550")};
SerializationTest.verifySelf(objectsToTest,
SerializationTest.SAME_COMPARATOR);
// tests that objects are the equals
objectsToTest = new Level[] {
new MockLevel("123", 123, "bundle"),
new MockLevel("123", 123, null) };
SerializationTest.verifySelf(objectsToTest, LEVEL_COMPARATOR);
}
/**
* @tests serialization/deserialization compatibility with RI.
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Serialization/deserialization compatibility",
method = "!SerializationGolden",
args = {}
)
*/
public void testSerializationCompatibility() throws Exception {
SerializationTest.verifyGolden(this,
new MockLevel("123", 123, "bundle"), LEVEL_COMPARATOR);
}
/*
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getLocalizedName",
args = {}
)
*/
public void testGetLocalName() {
ResourceBundle rb = ResourceBundle.getBundle("bundles/java/util/logging/res");
Level l = new MockLevel("level1", 120,
"bundles/java/util/logging/res");
assertEquals(rb.getString("level1"), l.getLocalizedName());
// regression test for HARMONY-2415
rb = ResourceBundle.getBundle(
"org.apache.harmony.logging.tests.java.util.logging.LevelTestResource");
l = new MockLevel("Level_error", 120,
"org.apache.harmony.logging.tests.java.util.logging.LevelTestResource");
assertEquals(rb.getString("Level_error"), l.getLocalizedName());
l = new MockLevel("bad name", 120, "res");
assertEquals("bad name", l.getLocalizedName());
l = new MockLevel("level1", 11120, "bad name");
assertEquals("level1", l.getLocalizedName());
l = new MockLevel("level1", 1120);
assertEquals("level1", l.getLocalizedName());
}
/*
* test for method public String getResourceBundleName()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getResourceBundleName",
args = {}
)
*/
public void testGetResourceBundleName() {
String bundleName = "bundles/java/util/logging/res";
Level l = new MockLevel("level1", 120);
assertNull("level's localization resource bundle name is not null", l
.getResourceBundleName());
l = new MockLevel("level1", 120, bundleName);
assertEquals("bundleName is non equal to actual value", bundleName, l
.getResourceBundleName());
l = new MockLevel("level1", 120, bundleName + "+abcdef");
assertEquals("bundleName is non equal to actual value", bundleName
+ "+abcdef", l.getResourceBundleName());
}
/*
* test for method public final int intValue()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "intValue",
args = {}
)
*/
public void testIntValue() {
int value1 = 120;
Level l = new MockLevel("level1", value1);
assertEquals(
"integer value for this level is non equal to actual value",
value1, l.intValue());
}
/*
* Test defining new levels in subclasses of Level
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "Test defining new levels in subclasses of Level",
method = "parse",
args = {java.lang.String.class}
)
*/
public void testSubclassNewLevel() {
MyLevel.DUPLICATENAME.getName();// just to load MyLevel class
// test duplicated name and num
assertEquals("INFO", MyLevel.parse("800").getName());
assertEquals(800, MyLevel.parse("INFO").intValue());
// test duplicated name
assertEquals("FINE", MyLevel.parse("499").getName());
assertEquals("FINE", MyLevel.parse("500").getName());
assertEquals(500, MyLevel.parse("FINE").intValue());
// test duplicated number
assertEquals("FINEST", MyLevel.parse("300").getName());
assertEquals(300, MyLevel.parse("FINEST").intValue());
assertEquals(300, MyLevel.parse("MYLEVEL1").intValue());
// test a normal new level, without duplicated elements
assertEquals("MYLEVEL2", MyLevel.parse("299").getName());
assertEquals(299, MyLevel.parse("MYLEVEL2").intValue());
}
/*
* This subclass is to test whether subclasses of Level can add new defined
* levels.
*/
static class MyLevel extends Level implements Serializable {
private static final long serialVersionUID = 1L;
public MyLevel(String name, int value) {
super(name, value);
}
public static final Level DUPLICATENAMENUM = new MyLevel("INFO", 800);
public static final Level DUPLICATENAME = new MyLevel("FINE", 499);
public static final Level DUPLICATENUM = new MyLevel("MYLEVEL1", 300);
public static final Level NORMAL = new MyLevel("MYLEVEL2", 299);
}
/*
* This Mock is used to expose the protected constructors.
*/
public class MockLevel extends Level implements Serializable {
private static final long serialVersionUID = 1L;
public MockLevel(String name, int value) {
super(name, value);
}
public MockLevel(String name, int value, String resourceBundleName) {
super(name, value, resourceBundleName);
}
}
}