You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@ignite.apache.org by av...@apache.org on 2018/08/15 22:04:05 UTC

[18/19] ignite git commit: IGNITE-8493 GridToStringBuilder arrayToString refactoring. - Fixes #4501.

IGNITE-8493 GridToStringBuilder arrayToString refactoring. - Fixes #4501.

Signed-off-by: Dmitriy Pavlov <dp...@apache.org>


Project: http://git-wip-us.apache.org/repos/asf/ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/dd8c933f
Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/dd8c933f
Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/dd8c933f

Branch: refs/heads/ignite-9053
Commit: dd8c933fd44e4ad9b315daccce8e2327606867b0
Parents: 82131d2
Author: Evgeny Stanilovskiy <es...@gridgain.com>
Authored: Wed Aug 15 20:28:48 2018 +0300
Committer: Dmitriy Pavlov <dp...@apache.org>
Committed: Wed Aug 15 20:35:08 2018 +0300

----------------------------------------------------------------------
 .../util/tostring/GridToStringBuilder.java      | 129 ++++++++-----------
 .../tostring/GridToStringBuilderSelfTest.java   |  97 +++++++++-----
 ...niteHadoopFileSystemClientBasedOpenTest.java |   2 +-
 3 files changed, 116 insertions(+), 112 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ignite/blob/dd8c933f/modules/core/src/main/java/org/apache/ignite/internal/util/tostring/GridToStringBuilder.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/util/tostring/GridToStringBuilder.java b/modules/core/src/main/java/org/apache/ignite/internal/util/tostring/GridToStringBuilder.java
index 67b9af1..329682f 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/util/tostring/GridToStringBuilder.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/util/tostring/GridToStringBuilder.java
@@ -21,6 +21,7 @@ import java.io.Externalizable;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.Serializable;
+import java.lang.reflect.Array;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.ArrayList;
@@ -853,7 +854,7 @@ public class GridToStringBuilder {
      */
     private static void addArray(SBLimitedLength buf, Class arrType, Object obj) {
         if (arrType.getComponentType().isPrimitive()) {
-            buf.a(arrayToString(arrType, obj));
+            buf.a(arrayToString(obj));
 
             return;
         }
@@ -1075,95 +1076,40 @@ public class GridToStringBuilder {
     }
 
     /**
-     * @param arrType Type of the array.
-     * @param arr Array object.
+     * Returns limited string representation of array.
+     *
+     * @param arr Array object. Each value is automatically wrapped if it has a primitive type.
      * @return String representation of an array.
      */
-    @SuppressWarnings({"ConstantConditions", "unchecked"})
-    public static <T> String arrayToString(Class arrType, Object arr) {
+    public static String arrayToString(Object arr) {
         if (arr == null)
             return "null";
 
         String res;
-        int more = 0;
 
-        if (arrType.equals(byte[].class)) {
-            byte[] byteArr = (byte[])arr;
-            if (byteArr.length > COLLECTION_LIMIT) {
-                more = byteArr.length - COLLECTION_LIMIT;
-                byteArr = Arrays.copyOf(byteArr, COLLECTION_LIMIT);
-            }
-            res = Arrays.toString(byteArr);
-        }
-        else if (arrType.equals(boolean[].class)) {
-            boolean[] boolArr = (boolean[])arr;
-            if (boolArr.length > COLLECTION_LIMIT) {
-                more = boolArr.length - COLLECTION_LIMIT;
-                boolArr = Arrays.copyOf(boolArr, COLLECTION_LIMIT);
-            }
-            res = Arrays.toString(boolArr);
-        }
-        else if (arrType.equals(short[].class)) {
-            short[] shortArr = (short[])arr;
-            if (shortArr.length > COLLECTION_LIMIT) {
-                more = shortArr.length - COLLECTION_LIMIT;
-                shortArr = Arrays.copyOf(shortArr, COLLECTION_LIMIT);
-            }
-            res = Arrays.toString(shortArr);
-        }
-        else if (arrType.equals(int[].class)) {
-            int[] intArr = (int[])arr;
-            if (intArr.length > COLLECTION_LIMIT) {
-                more = intArr.length - COLLECTION_LIMIT;
-                intArr = Arrays.copyOf(intArr, COLLECTION_LIMIT);
-            }
-            res = Arrays.toString(intArr);
-        }
-        else if (arrType.equals(long[].class)) {
-            long[] longArr = (long[])arr;
-            if (longArr.length > COLLECTION_LIMIT) {
-                more = longArr.length - COLLECTION_LIMIT;
-                longArr = Arrays.copyOf(longArr, COLLECTION_LIMIT);
-            }
-            res = Arrays.toString(longArr);
-        }
-        else if (arrType.equals(float[].class)) {
-            float[] floatArr = (float[])arr;
-            if (floatArr.length > COLLECTION_LIMIT) {
-                more = floatArr.length - COLLECTION_LIMIT;
-                floatArr = Arrays.copyOf(floatArr, COLLECTION_LIMIT);
-            }
-            res = Arrays.toString(floatArr);
-        }
-        else if (arrType.equals(double[].class)) {
-            double[] doubleArr = (double[])arr;
-            if (doubleArr.length > COLLECTION_LIMIT) {
-                more = doubleArr.length - COLLECTION_LIMIT;
-                doubleArr = Arrays.copyOf(doubleArr, COLLECTION_LIMIT);
-            }
-            res = Arrays.toString(doubleArr);
-        }
-        else if (arrType.equals(char[].class)) {
-            char[] charArr = (char[])arr;
-            if (charArr.length > COLLECTION_LIMIT) {
-                more = charArr.length - COLLECTION_LIMIT;
-                charArr = Arrays.copyOf(charArr, COLLECTION_LIMIT);
-            }
-            res = Arrays.toString(charArr);
-        }
-        else {
+        int arrLen;
+
+        if (arr instanceof Object[]) {
             Object[] objArr = (Object[])arr;
-            if (objArr.length > COLLECTION_LIMIT) {
-                more = objArr.length - COLLECTION_LIMIT;
+
+            arrLen = objArr.length;
+
+            if (arrLen > COLLECTION_LIMIT)
                 objArr = Arrays.copyOf(objArr, COLLECTION_LIMIT);
-            }
+
             res = Arrays.toString(objArr);
+        } else {
+            res = toStringWithLimit(arr, COLLECTION_LIMIT);
+
+            arrLen = Array.getLength(arr);
         }
-        if (more > 0) {
+
+        if (arrLen > COLLECTION_LIMIT) {
             StringBuilder resSB = new StringBuilder(res);
 
             resSB.deleteCharAt(resSB.length() - 1);
-            resSB.append("... and ").append(more).append(" more]");
+
+            resSB.append("... and ").append(arrLen - COLLECTION_LIMIT).append(" more]");
 
             res = resSB.toString();
         }
@@ -1172,6 +1118,37 @@ public class GridToStringBuilder {
     }
 
     /**
+     * Returns limited string representation of array.
+     *
+     * @param arr Input array. Each value is automatically wrapped if it has a primitive type.
+     * @param limit max array items to string limit.
+     * @return String representation of an array.
+     */
+    private static String toStringWithLimit(Object arr, int limit) {
+        int arrIdxMax = Array.getLength(arr) - 1;
+
+        if (arrIdxMax == -1)
+            return "[]";
+
+        int idxMax = Math.min(arrIdxMax, limit);
+
+        StringBuilder b = new StringBuilder();
+
+        b.append('[');
+
+        for (int i = 0; i <= idxMax; ++i) {
+            b.append(Array.get(arr, i));
+            
+            if (i == idxMax)
+                return b.append(']').toString();
+
+            b.append(", ");
+        }
+
+        return b.toString();
+    }
+
+    /**
      * Produces uniformed output of string with context properties
      *
      * @param str Output prefix or {@code null} if empty.

http://git-wip-us.apache.org/repos/asf/ignite/blob/dd8c933f/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/GridToStringBuilderSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/GridToStringBuilderSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/GridToStringBuilderSelfTest.java
index 9a9e67e..d249914 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/GridToStringBuilderSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/util/tostring/GridToStringBuilderSelfTest.java
@@ -304,8 +304,8 @@ public class GridToStringBuilderSelfTest extends GridCommonAbstractTest {
      * @param limit Array limit.
      */
     private void checkArrayOverflow(Object[] arrOf, Object[] arr, int limit) {
-        String arrStr = GridToStringBuilder.arrayToString(arr.getClass(), arr);
-        String arrOfStr = GridToStringBuilder.arrayToString(arrOf.getClass(), arrOf);
+        String arrStr = GridToStringBuilder.arrayToString(arr);
+        String arrOfStr = GridToStringBuilder.arrayToString(arrOf);
 
         // Simulate overflow
         StringBuilder resultSB = new StringBuilder(arrStr);
@@ -332,75 +332,97 @@ public class GridToStringBuilderSelfTest extends GridCommonAbstractTest {
         for (Object val : vals)
             testArr(val, limit);
 
+        int[] intArr1 = new int[0];
+
+        assertEquals("[]", GridToStringBuilder.arrayToString(intArr1));
+        assertEquals("null", GridToStringBuilder.arrayToString(null));
+
+        int[] intArr2 = {1, 2, 3};
+
+        assertEquals("[1, 2, 3]", GridToStringBuilder.arrayToString(intArr2));
+
+        Object[] intArr3 = {2, 3, 4};
+
+        assertEquals("[2, 3, 4]", GridToStringBuilder.arrayToString(intArr3));
+
         byte[] byteArr = new byte[1];
+
         byteArr[0] = 1;
-        assertEquals(Arrays.toString(byteArr), GridToStringBuilder.arrayToString(byteArr.getClass(), byteArr));
+        assertEquals(Arrays.toString(byteArr), GridToStringBuilder.arrayToString(byteArr));
         byteArr = Arrays.copyOf(byteArr, 101);
         assertTrue("Can't find \"... and 1 more\" in overflowed array string!",
-            GridToStringBuilder.arrayToString(byteArr.getClass(), byteArr).contains("... and 1 more"));
+            GridToStringBuilder.arrayToString(byteArr).contains("... and 1 more"));
 
         boolean[] boolArr = new boolean[1];
+
         boolArr[0] = true;
-        assertEquals(Arrays.toString(boolArr), GridToStringBuilder.arrayToString(boolArr.getClass(), boolArr));
+        assertEquals(Arrays.toString(boolArr), GridToStringBuilder.arrayToString(boolArr));
         boolArr = Arrays.copyOf(boolArr, 101);
         assertTrue("Can't find \"... and 1 more\" in overflowed array string!",
-            GridToStringBuilder.arrayToString(boolArr.getClass(), boolArr).contains("... and 1 more"));
+            GridToStringBuilder.arrayToString(boolArr).contains("... and 1 more"));
 
         short[] shortArr = new short[1];
+
         shortArr[0] = 100;
-        assertEquals(Arrays.toString(shortArr), GridToStringBuilder.arrayToString(shortArr.getClass(), shortArr));
+        assertEquals(Arrays.toString(shortArr), GridToStringBuilder.arrayToString(shortArr));
         shortArr = Arrays.copyOf(shortArr, 101);
         assertTrue("Can't find \"... and 1 more\" in overflowed array string!",
-            GridToStringBuilder.arrayToString(shortArr.getClass(), shortArr).contains("... and 1 more"));
+            GridToStringBuilder.arrayToString(shortArr).contains("... and 1 more"));
 
         int[] intArr = new int[1];
+
         intArr[0] = 10000;
-        assertEquals(Arrays.toString(intArr), GridToStringBuilder.arrayToString(intArr.getClass(), intArr));
+        assertEquals(Arrays.toString(intArr), GridToStringBuilder.arrayToString(intArr));
         intArr = Arrays.copyOf(intArr, 101);
         assertTrue("Can't find \"... and 1 more\" in overflowed array string!",
-            GridToStringBuilder.arrayToString(intArr.getClass(), intArr).contains("... and 1 more"));
+            GridToStringBuilder.arrayToString(intArr).contains("... and 1 more"));
 
         long[] longArr = new long[1];
+
         longArr[0] = 10000000;
-        assertEquals(Arrays.toString(longArr), GridToStringBuilder.arrayToString(longArr.getClass(), longArr));
+        assertEquals(Arrays.toString(longArr), GridToStringBuilder.arrayToString(longArr));
         longArr = Arrays.copyOf(longArr, 101);
         assertTrue("Can't find \"... and 1 more\" in overflowed array string!",
-            GridToStringBuilder.arrayToString(longArr.getClass(), longArr).contains("... and 1 more"));
+            GridToStringBuilder.arrayToString(longArr).contains("... and 1 more"));
 
         float[] floatArr = new float[1];
+
         floatArr[0] = 1.f;
-        assertEquals(Arrays.toString(floatArr), GridToStringBuilder.arrayToString(floatArr.getClass(), floatArr));
+        assertEquals(Arrays.toString(floatArr), GridToStringBuilder.arrayToString(floatArr));
         floatArr = Arrays.copyOf(floatArr, 101);
         assertTrue("Can't find \"... and 1 more\" in overflowed array string!",
-            GridToStringBuilder.arrayToString(floatArr.getClass(), floatArr).contains("... and 1 more"));
+            GridToStringBuilder.arrayToString(floatArr).contains("... and 1 more"));
 
         double[] doubleArr = new double[1];
+
         doubleArr[0] = 1.;
-        assertEquals(Arrays.toString(doubleArr), GridToStringBuilder.arrayToString(doubleArr.getClass(), doubleArr));
+        assertEquals(Arrays.toString(doubleArr), GridToStringBuilder.arrayToString(doubleArr));
         doubleArr = Arrays.copyOf(doubleArr, 101);
         assertTrue("Can't find \"... and 1 more\" in overflowed array string!",
-            GridToStringBuilder.arrayToString(doubleArr.getClass(), doubleArr).contains("... and 1 more"));
+            GridToStringBuilder.arrayToString(doubleArr).contains("... and 1 more"));
+
+        char[] cArr = new char[1];
 
-        char[] charArr = new char[1];
-        charArr[0] = 'a';
-        assertEquals(Arrays.toString(charArr), GridToStringBuilder.arrayToString(charArr.getClass(), charArr));
-        charArr = Arrays.copyOf(charArr, 101);
+        cArr[0] = 'a';
+        assertEquals(Arrays.toString(cArr), GridToStringBuilder.arrayToString(cArr));
+        cArr = Arrays.copyOf(cArr, 101);
         assertTrue("Can't find \"... and 1 more\" in overflowed array string!",
-            GridToStringBuilder.arrayToString(charArr.getClass(), charArr).contains("... and 1 more"));
+            GridToStringBuilder.arrayToString(cArr).contains("... and 1 more"));
 
         Map<String, String> strMap = new TreeMap<>();
         List<String> strList = new ArrayList<>(limit+1);
 
-        TestClass1 testClass = new TestClass1();
-        testClass.strMap = strMap;
-        testClass.strListIncl = strList;
+        TestClass1 testCls = new TestClass1();
+
+        testCls.strMap = strMap;
+        testCls.strListIncl = strList;
 
         for (int i = 0; i < limit; i++) {
             strMap.put("k" + i, "v");
             strList.add("e");
         }
 
-        checkColAndMap(testClass);
+        checkColAndMap(testCls);
     }
 
     /**
@@ -459,21 +481,26 @@ public class GridToStringBuilderSelfTest extends GridCommonAbstractTest {
     public void testToStringSizeLimits() throws Exception {
         int limit = IgniteSystemProperties.getInteger(IGNITE_TO_STRING_MAX_LENGTH, 10_000);
         int tailLen = limit / 10 * 2;
+
         StringBuilder sb = new StringBuilder(limit + 10);
-        for (int i = 0; i < limit - 100; i++) {
+
+        for (int i = 0; i < limit - 100; i++)
             sb.append('a');
-        }
+
         String actual = GridToStringBuilder.toString(TestClass2.class, new TestClass2(sb.toString()));
-        String expected = "TestClass2 [str=" + sb.toString() + ", nullArr=null]";
-        assertEquals(expected, actual);
+        String exp = "TestClass2 [str=" + sb + ", nullArr=null]";
 
-        for (int i = 0; i < 110; i++) {
+        assertEquals(exp, actual);
+
+        for (int i = 0; i < 110; i++)
             sb.append('b');
-        }
+
         actual = GridToStringBuilder.toString(TestClass2.class, new TestClass2(sb.toString()));
-        expected = "TestClass2 [str=" + sb.toString() + ", nullArr=null]";
-        assertEquals(expected.substring(0, limit - tailLen), actual.substring(0, limit - tailLen));
-        assertEquals(expected.substring(expected.length() - tailLen), actual.substring(actual.length() - tailLen));
+        exp = "TestClass2 [str=" + sb + ", nullArr=null]";
+
+        assertEquals(exp.substring(0, limit - tailLen), actual.substring(0, limit - tailLen));
+        assertEquals(exp.substring(exp.length() - tailLen), actual.substring(actual.length() - tailLen));
+
         assertTrue(actual.contains("... and"));
         assertTrue(actual.contains("skipped ..."));
     }
@@ -620,7 +647,7 @@ public class GridToStringBuilderSelfTest extends GridCommonAbstractTest {
         /**
          * @param str String.
          */
-        public TestClass2(String str) {
+        TestClass2(String str) {
             this.str = str;
         }
     }

http://git-wip-us.apache.org/repos/asf/ignite/blob/dd8c933f/modules/hadoop/src/test/java/org/apache/ignite/internal/processors/hadoop/impl/igfs/IgniteHadoopFileSystemClientBasedOpenTest.java
----------------------------------------------------------------------
diff --git a/modules/hadoop/src/test/java/org/apache/ignite/internal/processors/hadoop/impl/igfs/IgniteHadoopFileSystemClientBasedOpenTest.java b/modules/hadoop/src/test/java/org/apache/ignite/internal/processors/hadoop/impl/igfs/IgniteHadoopFileSystemClientBasedOpenTest.java
index 289e63d..932f4d8 100644
--- a/modules/hadoop/src/test/java/org/apache/ignite/internal/processors/hadoop/impl/igfs/IgniteHadoopFileSystemClientBasedOpenTest.java
+++ b/modules/hadoop/src/test/java/org/apache/ignite/internal/processors/hadoop/impl/igfs/IgniteHadoopFileSystemClientBasedOpenTest.java
@@ -176,7 +176,7 @@ public class IgniteHadoopFileSystemClientBasedOpenTest extends GridCommonAbstrac
      */
     private void checkFsOpenWithAllNodesTypes() throws Exception {
         for (int i = 0; i < nodesTypes.length; ++i) {
-            log.info("Begin test case for nodes: " + S.arrayToString(NodeType.class, nodesTypes[i]));
+            log.info("Begin test case for nodes: " + S.arrayToString(nodesTypes[i]));
 
             startNodes(nodesTypes[i]);