switch to long for parsing of memory sizes (#175)

Author: chewiebug

src/main/java/com/tagtraum/perf/gcviewer/imp/DataReaderIBM_J9_R28.java

@@ -207,14 +207,14 @@ else if (xmlEvent.isEndElement()) {
     }
 
     private void setTotalAndPreUsed(GCEvent event, StartElement startEl) {
-        long total = NumberParser.parseInt(getAttributeValue(startEl, "total"));
+        long total = NumberParser.parseLong(getAttributeValue(startEl, "total"));
         event.setTotal(toKiloBytes(total));
-        event.setPreUsed(toKiloBytes(total - NumberParser.parseInt(getAttributeValue(startEl, "free"))));
+        event.setPreUsed(toKiloBytes(total - NumberParser.parseLong(getAttributeValue(startEl, "free"))));
     }
 
     private void setPostUsed(GCEvent event, StartElement startEl) {
-        long total = NumberParser.parseInt(getAttributeValue(startEl, "total"));
-        event.setPostUsed(toKiloBytes(total - NumberParser.parseInt(getAttributeValue(startEl, "free"))));
+        long total = NumberParser.parseLong(getAttributeValue(startEl, "total"));
+        event.setPostUsed(toKiloBytes(total - NumberParser.parseLong(getAttributeValue(startEl, "free"))));
     }
 
     private String getAttributeValue(StartElement event, String name) {

src/main/java/com/tagtraum/perf/gcviewer/util/NumberParser.java

@@ -124,14 +124,16 @@ public static long parseLong(String s, int offset, int length) throws NumberForm
         if (length > 0) {
             if (s.charAt(offset) == '-') {
                 // shortcut for ints
-                if (length <= MAX_NEGATIVE_INTEGER_CHARS) return parseInt(s, offset, length);
+                // => shortcut doesn't work!! (e.g. -6442450944 is too big for an int, but has not too many characters)
+                // if (length <= MAX_NEGATIVE_INTEGER_CHARS) return parseInt(s, offset, length);
                 if (length > MAX_NEGATIVE_LONG_CHARS) throw new NumberFormatException(s);
                 negative = true;
                 limit = Long.MIN_VALUE;
                 i++;
             } else {
                 // shortcut for ints
-                if (length <= MAX_POSITIVE_INTEGER_CHARS) return parseInt(s, offset, length);
+                // => shortcut doesn't work!! (e.g. 6442450944 is too big for an int, but has not too many characters)
+                //if (length <= MAX_POSITIVE_INTEGER_CHARS) return parseInt(s, offset, length);
                 if (length > MAX_POSITIVE_LONG_CHARS) throw new NumberFormatException(s);
                 limit = -Long.MAX_VALUE;
             }
@@ -172,14 +174,16 @@ public static long parseLong(char[] cb, int offset, int length) throws NumberFor
         if (length > 0) {
             if (cb[offset] == '-') {
                 // shortcut for ints
-                if (length <= MAX_NEGATIVE_INTEGER_CHARS) return parseInt(cb, offset, length);
+                // => shortcut doesn't work!! (e.g. -6442450944 is too big for an int, but has not too many characters)
+                //if (length <= MAX_NEGATIVE_INTEGER_CHARS) return parseInt(cb, offset, length);
                 if (length > MAX_NEGATIVE_LONG_CHARS) throw new NumberFormatException(new String(cb, offset, length));
                 negative = true;
                 limit = Long.MIN_VALUE;
                 i++;
             } else {
                 // shortcut for ints
-                if (length <= MAX_POSITIVE_INTEGER_CHARS) return parseInt(cb, offset, length);
+                // => shortcut doesn't work!! (e.g. 6442450944 is too big for an int, but has not too many characters)
+                //if (length <= MAX_POSITIVE_INTEGER_CHARS) return parseInt(cb, offset, length);
                 if (length > MAX_POSITIVE_LONG_CHARS) throw new NumberFormatException(new String(cb, offset, length));
                 limit = -Long.MAX_VALUE;
             }

src/test/java/com/tagtraum/perf/gcviewer/util/TestNumberParser.java

@@ -0,0 +1,66 @@
+package com.tagtraum.perf.gcviewer.util;
+
+import org.hamcrest.Matchers;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * Test methods of {@link NumberParser}.
+ */
+public class TestNumberParser {
+
+    @Test
+    public void testParseIntString() throws Exception {
+        int result = NumberParser.parseInt("1442450944");
+        Assert.assertThat("string int", result, Matchers.is(1442450944));
+    }
+
+    @Test
+    public void testParseIntStringNegative() throws Exception {
+        int result = NumberParser.parseInt("-1442450944");
+        Assert.assertThat("string negative int", result, Matchers.is(-1442450944));
+    }
+
+    @Test
+    public void testParseIntChar() throws Exception {
+        int result = NumberParser.parseInt(new char[] {'1', '4', '4', '2', '4', '5', '0', '9', '4', '4'}, 0, 10);
+        Assert.assertThat("char int", result, Matchers.is(1442450944));
+    }
+
+    @Test
+    public void testParseIntCharNegative() throws Exception {
+        int result = NumberParser.parseInt(new char[] {'-', '1', '4', '4', '2', '4', '5', '0', '9', '4', '4'}, 0, 11);
+        Assert.assertThat("char negative int", result, Matchers.is(-1442450944));
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void testParseIntTooLarge() throws Exception {
+        NumberParser.parseInt("6442450944");
+    }
+
+    @Test
+    public void testParseLongString() throws Exception {
+        long result = NumberParser.parseLong("6442450944");
+        Assert.assertThat("string long", result, Matchers.is(6442450944L));
+    }
+
+    @Test
+    public void testParseLongStringNegative() throws Exception {
+        long result = NumberParser.parseLong("-6442450944");
+        Assert.assertThat("string negative long", result, Matchers.is(-6442450944L));
+
+    }
+
+    @Test
+    public void testParseLongChar() throws Exception {
+        long result = NumberParser.parseLong(new char[] {'6', '4', '4', '2', '4', '5', '0', '9', '4', '4'}, 0, 10);
+        Assert.assertThat("char long", result, Matchers.is(6442450944L));
+    }
+
+    @Test
+    public void testParseLongCharNegative() throws Exception {
+        long result = NumberParser.parseLong(new char[] {'-', '6', '4', '4', '2', '4', '5', '0', '9', '4', '4'}, 0, 11);
+        Assert.assertThat("char negative long", result, Matchers.is(-6442450944L));
+    }
+
+}