Merging XStreamTest into XStream2Test for clarity.

core/src/test/java/hudson/util/XStream2Test.java

@@ -25,21 +25,22 @@ package hudson.util;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-import junit.framework.TestCase;
+import hudson.XmlFile;
 import hudson.matrix.MatrixRun;
 import hudson.model.Result;
 import hudson.model.Run;
-
-import org.jvnet.hudson.test.Bug;
-
+import java.io.File;
 import java.io.InputStream;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-
 import jenkins.model.CauseOfInterruption;
 import jenkins.model.InterruptedBuildAction;
+import junit.framework.TestCase;
+import org.apache.commons.io.FileUtils;
+import org.jvnet.hudson.test.Bug;
 
 /**
  * Tests for XML serialization of java objects.
@@ -276,4 +277,38 @@ public class XStream2Test extends TestCase {
             (CauseOfInterruption.UserInterruption) action.getCauses().get(0);
         assertNotNull(cause);
     }
+
+    public static class Foo2 {
+        ConcurrentHashMap<String,String> m = new ConcurrentHashMap<String,String>();
+    }
+
+    /**
+     * Tests that ConcurrentHashMap is serialized into a more compact format,
+     * but still can deserialize to older, verbose format.
+     */
+    public void testConcurrentHashMapSerialization() throws Exception {
+        Foo2 foo = new Foo2();
+        foo.m.put("abc","def");
+        foo.m.put("ghi","jkl");
+        File v = File.createTempFile("hashmap", "xml");
+        try {
+            new XmlFile(v).write(foo);
+
+            // should serialize like map
+            String xml = FileUtils.readFileToString(v);
+            assertFalse(xml.contains("java.util.concurrent"));
+            //System.out.println(xml);
+            Foo2 deserialized = (Foo2) new XStream2().fromXML(xml);
+            assertEquals(2,deserialized.m.size());
+            assertEquals("def", deserialized.m.get("abc"));
+            assertEquals("jkl", deserialized.m.get("ghi"));
+        } finally {
+            v.delete();
+        }
+
+        // should be able to read in old data just fine
+        Foo2 map = (Foo2) new XStream2().fromXML(getClass().getResourceAsStream("old-concurrentHashMap.xml"));
+        assertEquals(1,map.m.size());
+        assertEquals("def",map.m.get("abc"));
+    }
 }

core/src/test/java/hudson/util/XStreamTest.java

-/*
- * The MIT License
- *
- * Copyright (c) 2010, InfraDNA, Inc.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-package hudson.util;
-
-import hudson.XmlFile;
-import junit.framework.TestCase;
-import org.apache.commons.io.FileUtils;
-
-import java.io.File;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * @author Kohsuke Kawaguchi
- */
-public class XStreamTest extends TestCase {
-    
-    private XStream2 xstream = new XStream2();
-    
-    public static class Foo {
-        ConcurrentHashMap<String,String> m = new ConcurrentHashMap<String,String>();
-    }
-
-    /**
-     * Tests that ConcurrentHashMap is serialized into a more compact format,
-     * but still can deserialize to older, verbose format.
-     */
-    public void testConcurrentHashMapSerialization() throws Exception {
-        Foo foo = new Foo();
-        foo.m.put("abc","def");
-        foo.m.put("ghi","jkl");
-        File v = File.createTempFile("hashmap", "xml");
-        try {
-            new XmlFile(v).write(foo);
-
-            // should serialize like map
-            String xml = FileUtils.readFileToString(v);
-            assertFalse(xml.contains("java.util.concurrent"));
-            //System.out.println(xml);
-            Foo deserialized = (Foo)xstream.fromXML(xml);
-            assertEquals(2,deserialized.m.size());
-            assertEquals("def", deserialized.m.get("abc"));
-            assertEquals("jkl", deserialized.m.get("ghi"));
-        } finally {
-            v.delete();
-        }
-
-        // should be able to read in old data just fine
-        Foo map = (Foo)new XStream2().fromXML(getClass().getResourceAsStream("old-concurrentHashMap.xml"));
-        assertEquals(1,map.m.size());
-        assertEquals("def",map.m.get("abc"));
-    }
-}

core/src/test/resources/hudson/util/old-concurrentHashMap.xml

-<hudson.util.XStreamTest_-Foo>
+<hudson.util.XStream2Test_-Foo2>
   <m serialization="custom">
     <unserializable-parents/>
     <java.util.concurrent.ConcurrentHashMap>
@@ -222,4 +222,4 @@
       <null/>
     </java.util.concurrent.ConcurrentHashMap>
   </m>
-</hudson.util.XStreamTest_-Foo>
\ No newline at end of file
+</hudson.util.XStream2Test_-Foo2>
\ No newline at end of file