import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests resolution of resource bundle for serialization/deserialization.
 */
public void testSerializationResourceBundle() throws Exception {

    // test case: valid resource bundle name
    lr.setResourceBundleName("bundles/java/util/logging/res2");
    lr.setResourceBundle(ResourceBundle.getBundle(
            "bundles/java/util/logging/res", Locale.US));

    LogRecord result = (LogRecord) SerializationTest.copySerializable(lr);
    assertNotNull(result.getResourceBundle());

    // test case: invalid resource bundle name, it is not resolved during
    // deserialization LogRecord object so check for returned null value
    lr.setResourceBundleName("bad bundle name");
    lr.setResourceBundle(ResourceBundle.getBundle(
            "bundles/java/util/logging/res", Locale.US));

    result = (LogRecord) SerializationTest.copySerializable(lr);
    assertNull(result.getResourceBundle());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @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.
 */
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);
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility with RI.
 */
public void testSerializationCompatibility() throws Exception {

    // regression test for Harmony-1163
    HashMap<Color, Integer> enumColorMap = new HashMap<Color, Integer>();
    enumColorMap.put(Color.Red, 1);
    enumColorMap.put(Color.Blue, 3);

    Object[] testCases = { Sample.CURLY, new MockEnum(),
    // test a class that has enums and a string of same name as its fields.
            new MockEnum2(),
            // test a map class that has enums.
            enumColorMap, };

    SerializationTest.verifyGolden(this, testCases);
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
public void assertDeserialized(Serializable initial, Serializable deserialized) {

      // do common checks for all throwable objects
      SerializationTest.THROWABLE_COMPARATOR.assertDeserialized(initial, deserialized);

      PatternSyntaxException initPatternSyntaxException = (PatternSyntaxException) initial;
      PatternSyntaxException dserPatternSyntaxException = (PatternSyntaxException) deserialized;

      // verify fields
      assertEquals(initPatternSyntaxException.getDescription(),
                   dserPatternSyntaxException.getDescription());
      assertEquals(initPatternSyntaxException.getPattern(),
                   dserPatternSyntaxException.getPattern());
      assertEquals(initPatternSyntaxException.getIndex(),
                   dserPatternSyntaxException.getIndex());
    }
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
public void testSerializationComptibility() throws Exception {
    final BeanContextServicesSupport ctx = new BeanContextServicesSupport(
            null, Locale.ITALY, true, true);
    final BeanContextServicesSupport ctx2 = new BeanContextServicesSupport(
            null, Locale.CHINA, true, true);
    
    BeanContextEvent event = new MockBeanContextEvent(ctx);
    event.setPropagatedFrom(ctx2);
    SerializationTest.verifyGolden(this, event, new SerializableAssert(){
        public void assertDeserialized(Serializable arg0, Serializable arg1) {
            BeanContextEvent e1 = (BeanContextEvent)arg0;
            BeanContextEvent e2 = (BeanContextEvent)arg1;
            assertNull((BeanContextServicesSupport)e2.getSource());
            assertNotNull((BeanContextServicesSupport)e1.getSource());
            assertEqualsSerially((BeanContextServicesSupport)e1.getPropagatedFrom(), (BeanContextServicesSupport)e2.getPropagatedFrom());
            assertEqualsSerially(ctx2, (BeanContextServicesSupport)e2.getPropagatedFrom());
        }
    });
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
public void assertDeserialized(Serializable initial,
        Serializable deserialized) {

    // do common checks for all throwable objects
    SerializationTest.THROWABLE_COMPARATOR.assertDeserialized(initial,
            deserialized);

    DataTruncation initThr = (DataTruncation) initial;
    DataTruncation dserThr = (DataTruncation) deserialized;

    // verify index
    assertEquals(initThr.getIndex(), dserThr.getIndex());

    // verify parameter
    assertEquals(initThr.getParameter(), dserThr.getParameter());

    // verify read
    assertEquals(initThr.getRead(), dserThr.getRead());

    // verify dataSize
    assertEquals(initThr.getDataSize(), dserThr.getDataSize());

    // verify transferSize
    assertEquals(initThr.getTransferSize(), dserThr.getTransferSize());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests java.util.HashSet#SerializationTest
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationSelf",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationGolden",
        args = {}
    )
})
public void test_Serialization() throws Exception{
    HashSet<String> hs = new HashSet<String>();
    hs.add("hello");
    hs.add("world");
    SerializationTest.verifySelf(hs, comparator);
    SerializationTest.verifyGolden(this, hs, comparator);
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
@TestTargets({
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization.",
        method = "!SerializationSelf",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization.",
        method = "!SerializationGolden",
        args = {}
    )
})
public void testSerialization() throws Exception {
    Pattern pat = Pattern.compile("a*bc");
    SerializableAssert comparator = new SerializableAssert() {
        public void assertDeserialized(Serializable initial,
                Serializable deserialized) {
            assertEquals(((Pattern) initial).toString(),
                    ((Pattern) deserialized).toString());
        }
    };
    SerializationTest.verifyGolden(this, pat, comparator);
    SerializationTest.verifySelf(pat, comparator);
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility with RI.
 */
@TestTargetNew(
    level = TestLevel.COMPLETE,
    notes = "Serialization test",
    method = "!SerializationGolden",
    args = {}
)
public void testSerializationCompatibility() throws Exception {

    SQLException nextSQLException = new SQLException("nextReason",
            "nextSQLState", 33);

    int vendorCode = 10;
    SQLException object = new SQLException("reason", "SQLState", vendorCode);

    object.setNextException(nextSQLException);

    SerializationTest.verifyGolden(this, object, SQLEXCEPTION_COMPARATOR);
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationSelf",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "",
        method = "ReadOnlyBufferException",
        args = {}
    )
})
public void testSerializationSelf() throws Exception {

    SerializationTest.verifySelf(new ReadOnlyBufferException());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationSelf",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "CancelledKeyException",
        args = {}
    )
})
public void testSerializationSelf() throws Exception {

    SerializationTest.verifySelf(new CancelledKeyException());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility with RI.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationGolden",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "FileLockInterruptionException",
        args = {}
    )
})
public void testSerializationCompatibility() throws Exception {

    SerializationTest.verifyGolden(this,
            new FileLockInterruptionException());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility with RI.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationGolden",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "ClosedByInterruptException",
        args = {}
    )
})
public void testSerializationCompatibility() throws Exception {

    SerializationTest.verifyGolden(this, new ClosedByInterruptException());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility with RI.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationGolden",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "ClosedSelectorException",
        args = {}
    )
})
public void testSerializationCompatibility() throws Exception {

    SerializationTest.verifyGolden(this, new ClosedSelectorException());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationSelf",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "NonWritableChannelException",
        args = {}
    )
})
public void testSerializationSelf() throws Exception {

    SerializationTest.verifySelf(new NonWritableChannelException());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility with RI.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationGolden",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "NonWritableChannelException",
        args = {}
    )
})
public void testSerializationCompatibility() throws Exception {

    SerializationTest.verifyGolden(this, new NonWritableChannelException());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility with RI.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationGolden",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "ConnectionPendingException",
        args = {}
    )
})
public void testSerializationCompatibility() throws Exception {

    SerializationTest.verifyGolden(this, new ConnectionPendingException());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests java.util.InvalidPropertiesFormatException#SerializationTest()
 */
@TestTargetNew(
    level = TestLevel.COMPLETE,
    notes = "Verifies serialization/deserialization compatibility.",
    method = "!SerializationSelf",
    args = {}
)
public void test_Serialization() throws Exception {
    InvalidPropertiesFormatException ipfe = new InvalidPropertiesFormatException(
            "Hey, this is InvalidPropertiesFormatException");
    try {
        SerializationTest.verifySelf(ipfe);
    } catch (NotSerializableException e) {
        // expected
    }
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationSelf",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "NotYetBoundException",
        args = {}
    )
})
public void testSerializationSelf() throws Exception {

    SerializationTest.verifySelf(new NotYetBoundException());
}
 

import org.apache.harmony.testframework.serialization.SerializationTest; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationSelf",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "NonReadableChannelException",
        args = {}
    )
})
public void testSerializationSelf() throws Exception {

    SerializationTest.verifySelf(new NonReadableChannelException());
}