Sofaboot 4.0 support

.github/workflows/build.yml

@@ -2,9 +2,9 @@ name: build
 
 on:
   push:
-    branches: [ master, 3.x,sofaboot-4.0-support  ]
+    branches: [ master, 3.x ]
   pull_request:
-    branches: [ master, 3.x, sofaboot-4.0-support ]
+    branches: [ master, 3.x ]
 
 jobs:
   build:

pom.xml

@@ -4,7 +4,7 @@
 
     <groupId>com.alipay.sofa</groupId>
     <artifactId>hessian</artifactId>
-    <version>3.5.0-beta1</version>
+    <version>3.5.0-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <name>${project.groupId}:${project.artifactId}</name>

src/main/java/com/caucho/hessian/io/Hessian2Input.java

@@ -3391,7 +3391,7 @@ protected IOException expect(String expect, int ch)
                 if (obj != null) {
                     return error("expected " + expect
                         + " at 0x" + Integer.toHexString(ch & 0xff)
-                        + " " + obj.getClass().getName() + " (" + obj + ")");
+                        + " " + obj.getClass().getName());
                 }
                 else
                     return error("expected " + expect

src/main/java/com/caucho/hessian/io/JavaDeserializer.java

@@ -617,7 +617,7 @@ else if (e instanceof IOException)
             throw new HessianFieldException(fieldName + ": " + e.getMessage(), e);
 
         if (value != null)
-            throw new HessianFieldException(fieldName + ": " + value.getClass().getName() + " (" + value + ")"
+            throw new HessianFieldException(fieldName + ": " + value.getClass().getName()
                 + " cannot be assigned to " + field.getType().getName());
         else
             throw new HessianFieldException(fieldName + ": " + field.getType().getName() +

src/main/java/com/caucho/hessian/io/atomic/AtomicDeserializer.java

@@ -6,7 +6,6 @@
 
 import com.caucho.hessian.io.AbstractDeserializer;
 import com.caucho.hessian.io.AbstractHessianInput;
-import com.caucho.hessian.io.ArrayDeserializer;
 import com.caucho.hessian.io.BasicDeserializer;
 
 import java.io.IOException;
@@ -27,9 +26,8 @@ public class AtomicDeserializer extends AbstractDeserializer {
 
     private Class<?>          _type;
 
-    private BasicDeserializer intArrayDsr    = new BasicDeserializer(BasicDeserializer.INTEGER_ARRAY);
-    private BasicDeserializer longArrayDsr   = new BasicDeserializer(BasicDeserializer.LONG_ARRAY);
-    private BasicDeserializer objectArrayDsr = new BasicDeserializer(BasicDeserializer.OBJECT_ARRAY);
+    private BasicDeserializer intArrayDsr  = new BasicDeserializer(BasicDeserializer.INTEGER_ARRAY);
+    private BasicDeserializer longArrayDsr = new BasicDeserializer(BasicDeserializer.LONG_ARRAY);
 
     public AtomicDeserializer(Class<?> cl) {
         this._type = cl;
@@ -39,42 +37,62 @@ public AtomicDeserializer(Class<?> cl) {
     public Object readObject(AbstractHessianInput in, String[] fieldNames) throws IOException {
 
         if (AtomicInteger.class.equals(_type)) {
-            return new AtomicInteger(in.readInt());
+            AtomicInteger tmp = new AtomicInteger();
+            in.addRef(tmp);
+            tmp.set(in.readInt());
+            return tmp;
         }
         else if (AtomicBoolean.class.equals(_type)) {
-            return new AtomicBoolean(in.readInt() == 1);
+            AtomicBoolean tmp = new AtomicBoolean();
+            in.addRef(tmp);
+            tmp.set(in.readInt() == 1);
+            return tmp;
         }
         else if (AtomicLong.class.equals(_type)) {
-            return new AtomicLong(in.readLong());
+            AtomicLong tmp = new AtomicLong();
+            in.addRef(tmp);
+            tmp.set(in.readLong());
+            return tmp;
         }
         else if (AtomicReference.class.equals(_type)) {
-            return new AtomicReference(in.readObject());
+            AtomicReference tmp = new AtomicReference();
+            in.addRef(tmp);
+            tmp.set(in.readObject());
+            return tmp;
         }
         else if (AtomicIntegerArray.class.equals(_type)) {
+            AtomicIntegerArray array = null;
+            int ref = in.addRef(array);
             int[] res = (int[]) intArrayDsr.readObject(in);
             int len = res.length;
-            AtomicIntegerArray array = new AtomicIntegerArray(len);
+            array = new AtomicIntegerArray(len);
             for (int i = 0; i < len; i++) {
                 array.set(i, res[i]);
             }
+            in.setRef(ref, array);
             return array;
         }
         else if (AtomicLongArray.class.equals(_type)) {
+            AtomicLongArray array = null;
+            int ref = in.addRef(array);
             long[] res = (long[]) longArrayDsr.readObject(in);
             int len = res.length;
-            AtomicLongArray array = new AtomicLongArray(len);
+            array = new AtomicLongArray(len);
             for (int i = 0; i < len; i++) {
                 array.set(i, res[i]);
             }
+            in.setRef(ref, array);
             return array;
         }
         else if (AtomicReferenceArray.class.equals(_type)) {
+            int ref = in.addRef(null);
             Object[] res = (Object[]) in.readObject((new Object[0]).getClass());
             int len = res.length;
             AtomicReferenceArray array = new AtomicReferenceArray(len);
             for (int i = 0; i < len; i++) {
                 array.set(i, res[i]);
             }
+            in.setRef(ref, array);
             return array;
         }
 

src/test/java/com/caucho/hessian/test/atomic/AtomicDeserializeTest.java

@@ -27,6 +27,8 @@
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicIntegerArray;
@@ -98,6 +100,81 @@ public void test_atomicWrapper() throws IOException {
             .get(1));
     }
 
+    @Test
+    public void test_ref() throws IOException {
+        List<AtomicWrapper> l = new ArrayList<AtomicWrapper>();
+
+        // prepare
+        AtomicInteger ai = new AtomicInteger(17);
+        AtomicBoolean ab = new AtomicBoolean(true);
+        AtomicLong al = new AtomicLong(2147483649L);
+        AtomicReference at = new AtomicReference(new Integer(1));
+        AtomicIntegerArray aia = new AtomicIntegerArray(2);
+        aia.set(0, 0);
+        aia.set(1, 1);
+        AtomicLongArray ala = new AtomicLongArray(2);
+        ala.set(0, 0L);
+        ala.set(1, 1L);
+        AtomicReferenceArray ara = new AtomicReferenceArray(2);
+        ara.set(0, new Integer(1));
+        ara.set(1, new Integer(2));
+
+        AtomicWrapper atomicWrapper1 = new AtomicWrapper();
+        atomicWrapper1.setaInteger(ai);
+        atomicWrapper1.setaBoolean(ab);
+        atomicWrapper1.setaLong(al);
+        atomicWrapper1.setaReference(at);
+        atomicWrapper1.setaIntegerArray(aia);
+        atomicWrapper1.setaLongArray(ala);
+        atomicWrapper1.setaReferenceArray(ara);
+
+        AtomicWrapper atomicWrapper2 = new AtomicWrapper();
+        atomicWrapper2.setaInteger(ai);
+        atomicWrapper2.setaBoolean(ab);
+        atomicWrapper2.setaLong(al);
+        atomicWrapper2.setaReference(at);
+        atomicWrapper2.setaIntegerArray(aia);
+        atomicWrapper2.setaLongArray(ala);
+        atomicWrapper2.setaReferenceArray(ara);
+        l.add(atomicWrapper1);
+        l.add(atomicWrapper2);
+
+        Object result = doEncodeNDecode(l);
+        Assert.assertTrue(result instanceof List);
+        List<AtomicWrapper> resultInstance = (List<AtomicWrapper>) result;
+
+        Assert.assertTrue(atomicWrapper1 instanceof AtomicWrapper);
+        AtomicWrapper actual = atomicWrapper1;
+        Assert.assertEquals(resultInstance.get(0).getaInteger().get(), actual.getaInteger().get());
+        Assert.assertEquals(resultInstance.get(0).getaBoolean().get(), actual.getaBoolean().get());
+        Assert.assertEquals(resultInstance.get(0).getaLong().get(), actual.getaLong().get());
+        Assert.assertEquals(resultInstance.get(0).getaReference().get(), actual.getaReference().get());
+
+        Assert.assertEquals(resultInstance.get(0).getaIntegerArray().get(0), actual.getaIntegerArray().get(0));
+        Assert.assertEquals(resultInstance.get(0).getaIntegerArray().get(1), actual.getaIntegerArray().get(1));
+        Assert.assertEquals(resultInstance.get(0).getaLongArray().get(0), actual.getaLongArray().get(0));
+        Assert.assertEquals(resultInstance.get(0).getaLongArray().get(1), actual.getaLongArray().get(1));
+        Assert.assertEquals(resultInstance.get(0).getaReferenceArray().get(0), actual.getaReferenceArray()
+            .get(0));
+        Assert.assertEquals(resultInstance.get(0).getaReferenceArray().get(1), actual.getaReferenceArray()
+            .get(1));
+
+        Assert.assertEquals(resultInstance.get(1).getaInteger().get(), actual.getaInteger().get());
+        Assert.assertEquals(resultInstance.get(1).getaBoolean().get(), actual.getaBoolean().get());
+        Assert.assertEquals(resultInstance.get(1).getaLong().get(), actual.getaLong().get());
+        Assert.assertEquals(resultInstance.get(1).getaReference().get(), actual.getaReference().get());
+
+        Assert.assertEquals(resultInstance.get(1).getaIntegerArray().get(0), actual.getaIntegerArray().get(0));
+        Assert.assertEquals(resultInstance.get(1).getaIntegerArray().get(1), actual.getaIntegerArray().get(1));
+        Assert.assertEquals(resultInstance.get(1).getaLongArray().get(0), actual.getaLongArray().get(0));
+        Assert.assertEquals(resultInstance.get(1).getaLongArray().get(1), actual.getaLongArray().get(1));
+        Assert.assertEquals(resultInstance.get(1).getaReferenceArray().get(0), actual.getaReferenceArray()
+            .get(0));
+        Assert.assertEquals(resultInstance.get(1).getaReferenceArray().get(1), actual.getaReferenceArray()
+            .get(1));
+
+    }
+
     @Test
     public void test_atomic_unwrappedInteger() throws IOException {
         os.reset();

src/test/java/com/caucho/hessian/test/stacktrace/ExceptionClassTest.java

@@ -19,12 +19,15 @@
 import com.caucho.hessian.io.Hessian2Input;
 import com.caucho.hessian.io.Hessian2Output;
 import com.caucho.hessian.io.SerializerFactory;
+import org.junit.Assert;
 import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  *
@@ -58,6 +61,36 @@ public void test_stacktrace() throws IOException {
 
     }
 
+    @Test
+    public void test_ref() throws IOException {
+        Throwable t = null;
+        try {
+            int x = 1 / 0;
+        } catch (Exception e) {
+            t = e;
+        }
+
+        ExceptionWrapper w1 = new ExceptionWrapper();
+        w1.setT(t);
+
+        ExceptionWrapper w2 = new ExceptionWrapper();
+        w2.setT(t);
+
+        List<ExceptionWrapper> l = new ArrayList<ExceptionWrapper>();
+        l.add(w1);
+        l.add(w2);
+
+        Object result = doEncodeNDecode(l);
+        Assert.assertTrue(result instanceof List);
+
+        List<ExceptionWrapper> resultInstance = (List<ExceptionWrapper>) result;
+
+        Assert.assertEquals(l.get(0).t.getMessage(), resultInstance.get(0).t.getMessage());
+        Assert.assertEquals(l.get(0).t.getStackTrace().length, resultInstance.get(0).t.getStackTrace().length);
+
+        Assert.assertEquals(l.get(1).t.getMessage(), resultInstance.get(1).t.getMessage());
+    }
+
     protected Object doEncodeNDecode(Object origin) throws IOException {
         os.reset();
         Hessian2Output output = new Hessian2Output(os);