StackOverflowError for big String values (JSON to Java)

[GoogleCodeExporter]

import com.google.gson.Gson;
public class TestGson {

  public static void main(String[] args) {
    String str = getJsonString(Integer.parseInt(args[0]));
    GString gString = new Gson().fromJson(str, GString.class);
  }

  public static String getJsonString(int size) {
    StringBuilder builder = new StringBuilder();
    builder.append("{\"value\":\"");
    for (int i = 0; i <= size; i++) {
      builder.append("a");
    }
    builder.append("\"}");
    return builder.toString();
  }

}

public class GString {

  private String value = null;

  public String getValue() {
    return value;
  }

}

This will always end in an StackOverflowError for big Strings (e.g. 6112) 
at line 303 in JsonParser.java.

Original issue reported on code.google.com by dominik....@gmail.com on 22 Sep 2008 at 12:33

[GoogleCodeExporter]

Inderjeet knows more about this, but I believe this is a shortcoming with a 
JavaCC
parser.  It is not efficient at parsing long string values; therefore, if you 
have a
field in your JSON object with a very long String value (like a stack trace, 
etc.)
then this will occur.  We explicitly catch this "Error" and rethrow it as a
JsonParseException which should be safe as by the error is caught, all the 
recursive
function calls have popped off the stack.

We actually have a test for this scenario to ensure that a "JsonParseException" 
is
thrown instead of a StackOverflowError so that it will not take down the JVM 
(unless
the client doesn't not care about catching any JsonParseException).

This issue will be fixed once a new parser is implement.  See issue #28.

Original comment by joel.leitch@gmail.com on 23 Sep 2008 at 5:11

[GoogleCodeExporter]

Looks like this was fixed by Inderjeet in r256.

Original comment by ble...@gmail.com on 13 Oct 2008 at 3:22

[GoogleCodeExporter]

Yes, I have tested the new Gson with strings of size up to 20MB and it worked 
fine. 
It probably will work for even larger strings, but the test itself starts to 
generate 
too much GC. Previously, Gson was able to handle strings of about 100kb on the 
same 
test so I am excited about this fix.

Original comment by inder123 on 13 Oct 2008 at 3:37

• Changed state: Fixed