diff --git a/user/src/com/google/gwt/i18n/rebind/LookupMethodCreator.java b/user/src/com/google/gwt/i18n/rebind/LookupMethodCreator.java
index fed873c..71f7260 100644
--- a/user/src/com/google/gwt/i18n/rebind/LookupMethodCreator.java
+++ b/user/src/com/google/gwt/i18n/rebind/LookupMethodCreator.java
@@ -1,16 +1,14 @@
 /*
  * Copyright 2008 Google Inc.
  *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
  * the License.
  */
 package com.google.gwt.i18n.rebind;
@@ -31,23 +29,48 @@
  * Method creator to call the correct Map for the given Dictionary.
  */
 class LookupMethodCreator extends AbstractMethodCreator {
+
+  /**
+   * Used partition size if no one is specified.
+   * 
+   * Used in constructor without a partition size.
+   */
+  private static final int DEFAULT_PARTITIONS_SIZE = 500;
+
   private JType returnType;
 
+  private final int partitionsSize;
+
+  /**
+   * Constructor for <code>LookupMethodCreator</code>. The default partition size of 500 is used.
+   *
+   * @param classCreator parent class creator
+   * @param returnType associated return type
+   * 
+   * @see LookupMethodCreator#DEFAULT_PARTITIONS_SIZE
+   */
+  public LookupMethodCreator(AbstractGeneratorClassCreator classCreator, JType returnType) {
+    this(classCreator, returnType, DEFAULT_PARTITIONS_SIZE);
+    this.returnType = returnType;
+  }
+
   /**
    * Constructor for <code>LookupMethodCreator</code>.
    *
    * @param classCreator parent class creator
    * @param returnType associated return type
+   * @param partitionsSize max numbers of lookups per method.
    */
-  public LookupMethodCreator(AbstractGeneratorClassCreator classCreator,
-      JType returnType) {
+  public LookupMethodCreator(AbstractGeneratorClassCreator classCreator, JType returnType,
+      int partitionsSize) {
     super(classCreator);
     this.returnType = returnType;
+    this.partitionsSize = partitionsSize;
   }
 
   @Override
-  public void createMethodFor(TreeLogger logger, JMethod targetMethod,
-      String key, ResourceList resourceList, GwtLocale locale) {
+  public void createMethodFor(TreeLogger logger, JMethod targetMethod, String key,
+      ResourceList resourceList, GwtLocale locale) {
     createMethodFor(targetMethod);
   }
 
@@ -65,6 +88,15 @@
     return type;
   }
 
+  void printLookup(String methodName) {
+    String body = "if(arg0.equals(" + wrap(methodName) + ")) {";
+    println(body);
+    indent();
+    printFound(methodName);
+    outdent();
+    println("}");
+  }
+
   void createMethodFor(JMethod targetMethod) {
     String template = "{0} target = ({0}) cache.get(arg0);";
     String returnTypeName = getReturnTypeName();
@@ -76,24 +108,52 @@
     outdent();
     println("}");
     JMethod[] methods = ((ConstantsWithLookupImplCreator) currentCreator).allInterfaceMethods;
-    JType erasedType = returnType.getErasedType();
-    for (int i = 0; i < methods.length; i++) {
-      if (methods[i].getReturnType().getErasedType().equals(erasedType)
-          && methods[i] != targetMethod) {
-        String methodName = methods[i].getName();
-        String body = "if(arg0.equals(" + wrap(methodName) + ")) {";
-        println(body);
-        indent();
-        printFound(methodName);
-        outdent();
-        println("}");
-      }
+
+    final int partitions = (methods.length / partitionsSize) + 1;
+    println(returnTypeName + " tmp;");
+    for (int i = 0; i < partitions; i++) {
+      println("tmp = " + targetMethod.getName() + i + "(arg0);");
+      println("if (tmp != null) {");
+      indent();
+      println("return tmp;");
+      outdent();
+      println("}");
     }
+
     String format = "throw new java.util.MissingResourceException(\"Cannot find constant ''\" +"
         + "{0} + \"''; expecting a method name\", \"{1}\", {0});";
-    String result = MessageFormat.format(format, "arg0",
-        this.currentCreator.getTarget().getQualifiedSourceName());
+    String result = MessageFormat.format(format, "arg0", this.currentCreator.getTarget()
+        .getQualifiedSourceName());
     println(result);
+    outdent();
+    println("}");
+
+    println("");
+
+    final String argument0Type = targetMethod.getParameterTypes()[0].getQualifiedSourceName();
+    for (int p = 0; p < partitions; p++) {
+      final String templateNewMethod = "private {0} {1}{2}({3} arg0) '{";
+      final String header = MessageFormat.format(templateNewMethod, new Object[] {
+          returnTypeName, targetMethod.getName(), p, argument0Type});
+      println(header);
+      indent();
+      final JType erasedType = returnType.getErasedType();
+      for (int i = 0 + p * partitionsSize; i < methods.length && i < (p + 1)
+          * partitionsSize; i++) {
+        final JMethod method = methods[i];
+        if (method.getReturnType().getErasedType().equals(erasedType) && method != targetMethod) {
+          String methodName = method.getName();
+          printLookup(methodName);
+        }
+      }
+
+      println("return null;");
+      if (p < partitions - 1) {
+        outdent();
+        println("}");
+        println("");
+      }
+    }
   }
 
   void printFound(String methodName) {
diff --git a/user/src/com/google/gwt/user/rebind/AbstractSourceCreator.java b/user/src/com/google/gwt/user/rebind/AbstractSourceCreator.java
index 5f5e31f..ebe7fa3 100644
--- a/user/src/com/google/gwt/user/rebind/AbstractSourceCreator.java
+++ b/user/src/com/google/gwt/user/rebind/AbstractSourceCreator.java
@@ -82,6 +82,8 @@
   protected static String getJavaObjectTypeFor(JPrimitiveType type) {
     if (type == JPrimitiveType.INT) {
       return "Integer";
+    } else if (type == JPrimitiveType.CHAR){
+      return "Character";
     } else {
       String s = type.getSimpleSourceName();
       return s.substring(0, 1).toUpperCase(Locale.ROOT) + s.substring(1);
diff --git a/user/test/com/google/gwt/i18n/I18NJreSuite.java b/user/test/com/google/gwt/i18n/I18NJreSuite.java
index cf5d875..e5f5565 100644
--- a/user/test/com/google/gwt/i18n/I18NJreSuite.java
+++ b/user/test/com/google/gwt/i18n/I18NJreSuite.java
@@ -17,6 +17,7 @@
 
 import com.google.gwt.i18n.rebind.LocaleUtilsTest;
 import com.google.gwt.i18n.rebind.LocalizableGeneratorTest;
+import com.google.gwt.i18n.rebind.LookupMethodCreatorTest;
 import com.google.gwt.i18n.server.GwtLocaleTest;
 import com.google.gwt.i18n.server.MessageFormatParserTest;
 import com.google.gwt.i18n.server.PropertyCatalogFactoryTest;
@@ -28,6 +29,7 @@
 import com.google.gwt.i18n.shared.FirstStrongDirectionEstimatorTest;
 import com.google.gwt.i18n.shared.WordCountDirectionEstimatorTest;
 
+import junit.framework.JUnit4TestAdapter;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 
@@ -59,6 +61,7 @@
      */
     // suite.addTestSuite(TypeOracleMessageTest.class);
     suite.addTestSuite(WordCountDirectionEstimatorTest.class);
+    suite.addTest(new JUnit4TestAdapter(LookupMethodCreatorTest.class));
     // $JUnit-END$
 
     return suite;
diff --git a/user/test/com/google/gwt/i18n/rebind/LookupMethodCreatorTest.java b/user/test/com/google/gwt/i18n/rebind/LookupMethodCreatorTest.java
new file mode 100644
index 0000000..c9708eb
--- /dev/null
+++ b/user/test/com/google/gwt/i18n/rebind/LookupMethodCreatorTest.java
@@ -0,0 +1,238 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.i18n.rebind;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.core.ext.typeinfo.JClassType;
+import com.google.gwt.core.ext.typeinfo.JMethod;
+import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
+import com.google.gwt.core.ext.typeinfo.JType;
+import com.google.gwt.core.ext.typeinfo.TypeOracle;
+import com.google.gwt.core.ext.typeinfo.TypeOracleException;
+import com.google.gwt.dev.javac.TypeOracleTestingUtils;
+import com.google.gwt.dev.javac.testing.impl.MockJavaResource;
+import com.google.gwt.dev.shell.FailErrorLogger;
+import com.google.gwt.i18n.rebind.AbstractResource.ResourceList;
+import com.google.gwt.user.rebind.SourceWriter;
+import com.google.gwt.user.rebind.StringSourceWriter;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Tests for {@link LookupMethodCreator}.
+ */
+public class LookupMethodCreatorTest {
+
+  private TreeLogger logger = new FailErrorLogger();
+
+  private LookupMethodCreator underTest;
+
+  private SourceWriter sw = new StringSourceWriter();
+
+  private TypeOracle oracle;
+
+  private JMethod method;
+
+  private static final MockJavaResource SINGLE_ENTRY_MESSAGES = new MockJavaResource(
+      "foo.SingleEntryMessage") {
+    @Override
+    public CharSequence getContent() {
+      StringBuffer code = new StringBuffer();
+      code.append("package foo;\n");
+      code.append("public interface SingleEntryMessage extends foo.Lookup {\n");
+      code.append(" String singleEntry();\n");
+      code.append("}");
+      return code;
+    }
+  };
+
+  private static final MockJavaResource FOUR_ENTRY_MESSAGES = new MockJavaResource(
+      "foo.FourEntryMessage") {
+    @Override
+    public CharSequence getContent() {
+      StringBuffer code = new StringBuffer();
+      code.append("package foo;\n");
+      code.append("public interface FourEntryMessage extends foo.Lookup {\n");
+      code.append(" String first();\n");
+      code.append(" String second();\n");
+      code.append(" String third();\n");
+      code.append(" String fourth();\n");
+      code.append("}");
+      return code;
+    }
+  };
+
+  private static final MockJavaResource LOOKUP = new MockJavaResource("foo.Lookup") {
+    @Override
+    public CharSequence getContent() {
+      StringBuffer code = new StringBuffer();
+      code.append("package foo;\n");
+      code.append("public interface Lookup {\n");
+      code.append(" String getString(String arg0);\n");
+      code.append("}");
+      return code;
+    }
+  };
+
+  private void initLookupMethodCreator(MockJavaResource resource, int partitionsSize) {
+    JClassType clazz = oracle.findType(resource.getTypeName());
+    ConstantsWithLookupImplCreator mockCreator;
+    try {
+      mockCreator = new ConstantsWithLookupImplCreator(logger, sw, clazz, mock(ResourceList.class),
+          oracle);
+
+      JType stringType = oracle.findType("java.lang.String");
+      method = oracle.findType(LOOKUP.getTypeName()).findMethod("getString", new JType[] {
+          stringType});
+      underTest = new LookupMethodCreator(mockCreator, stringType, partitionsSize);
+    } catch (UnableToCompleteException e) {
+      fail(e.getMessage());
+    }
+  }
+
+  @Before
+  public void setupUp() throws TypeOracleException, UnableToCompleteException {
+    oracle = TypeOracleTestingUtils.buildStandardTypeOracleWith(logger, SINGLE_ENTRY_MESSAGES,
+        FOUR_ENTRY_MESSAGES, LOOKUP);
+    initLookupMethodCreator(SINGLE_ENTRY_MESSAGES, 3);
+  }
+
+  /**
+   * Test the "golden output".<br>
+   * In general, those tests are more trouble than they are worth but this will be a simple test for
+   * verify the general structure.
+   * 
+   * old version looks: <pre>
+   * java.lang.String target = (java.lang.String) cache.get(arg0);
+   * if (target != null) {
+   *   return target;
+   * }
+   * if(arg0.equals("singleEntry")) {
+   *   return singleEntry();
+   * }
+   * throw new java.util.MissingResourceException("Cannot find constant '" +arg0 + "'; expecting a method name", "foo.TestMessage", arg0);
+   * </pre>
+   *
+   * with first partition lookup it generates:
+   *
+   * <pre>
+   * java.lang.String target = (java.lang.String) cache.get(arg0);
+   * if (target != null) {
+   *   return target;
+   * }
+   * java.lang.String tmp;
+   * tmp = getString0(arg0);
+   * if (tmp != null) {
+   *   return tmp;
+   * }
+   * throw new java.util.MissingResourceException("Cannot find constant '" +arg0 + "'; expecting a method name", "foo.TestMessage", arg0);
+   * }
+   *
+   * public java.lang.String getString0(java.lang.String arg0) {
+   *   if(arg0.equals("singleEntry")) {
+   *     return singleEntry();
+   *   }
+   *   return null;
+   *
+   * </pre>
+   */
+  @Test
+  public void testCreateMethodForJMethodForSingleEntry() {
+    underTest.createMethodFor(method);
+
+    SourceWriter expected = new StringSourceWriter();
+    expected.println("java.lang.String target = (java.lang.String) cache.get(arg0);");
+    expected.println("if (target != null) {");
+    expected.indent();
+    expected.println("return target;");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("java.lang.String tmp;");
+    expected.println("tmp = getString0(arg0);");
+    expected.println("if (tmp != null) {");
+    expected.indent();
+    expected.println("return tmp;");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("throw new java.util.MissingResourceException("
+        + "\"Cannot find constant '\" +arg0 + \"'; expecting a method name\", \"foo.SingleEntryMessage\", arg0);");
+
+    // check partition method
+    assertTrue("No partition lookup created.", sw.toString().contains(
+        "java.lang.String getString0(java.lang.String arg0) {"));
+
+    expected.println("}");
+    expected.println();
+    expected.println("private java.lang.String getString0(java.lang.String arg0) {");
+    expected.indent();
+    expected.println("if(arg0.equals(\"singleEntry\")) {");
+    expected.indent();
+    expected.println("return singleEntry();");
+    expected.outdent();
+    expected.println("}");
+    expected.println("return null;");
+    expected.outdent();
+
+    assertEquals("Wrong source Lookup created.", expected.toString(), sw.toString());
+  }
+
+  @Test
+  public void testCreateMethodForJMethodForMultiMessageEntryCreateTwoPartitions() {
+    initLookupMethodCreator(FOUR_ENTRY_MESSAGES, 3);
+    underTest.createMethodFor(method);
+
+    String actual = sw.toString();
+
+    assertTrue("Missing partition lookup method (getString0).", actual.contains(
+        "java.lang.String getString0(java.lang.String arg0) {"));
+
+    assertTrue("Missing partition lookup method (getString1).", actual.contains(
+        "java.lang.String getString1(java.lang.String arg0) {"));
+  }
+
+  @Test
+  public void testPrintFound() {
+    underTest.printFound("callTest");
+
+    String returnStatement = sw.toString();
+    assertEquals("return callTest();\n", returnStatement);
+  }
+
+  @Test
+  public void testGetReturnTypeName() {
+    String returnType = underTest.getReturnTypeName();
+    assertEquals("java.lang.String", returnType);
+  }
+
+  @Test
+  public void testGetReturnTypeNameForPrimitveTypes() {
+    for (JPrimitiveType primitiveType : JPrimitiveType.values()) {
+      LookupMethodCreator primitiveMethodCreator = new LookupMethodCreator(null, primitiveType, 2);
+      String returnType = primitiveMethodCreator.getReturnTypeName();
+      String expectedType = primitiveType.getQualifiedBoxedSourceName().substring("java.lang."
+          .length());
+      assertEquals("Wrong Return Type for primitve type", expectedType, returnType);
+    }
+  }
+
+}
diff --git a/user/test/com/google/gwt/user/UserJreSuite.java b/user/test/com/google/gwt/user/UserJreSuite.java
new file mode 100644
index 0000000..d6b3369
--- /dev/null
+++ b/user/test/com/google/gwt/user/UserJreSuite.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user;
+
+import com.google.gwt.user.rebind.AbstractSourceCreatorTest;
+
+import junit.framework.JUnit4TestAdapter;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * User tests running as a regular JRE test.
+ */
+public class UserJreSuite {
+  public static Test suite() {
+    TestSuite suite = new TestSuite("Non-browser tests for com.google.gwt.user");
+
+    // $JUnit-BEGIN$
+    suite.addTest(new JUnit4TestAdapter(AbstractSourceCreatorTest.class));
+    // $JUnit-END$
+
+    return suite;
+  }
+
+}
diff --git a/user/test/com/google/gwt/user/rebind/AbstractSourceCreatorTest.java b/user/test/com/google/gwt/user/rebind/AbstractSourceCreatorTest.java
new file mode 100644
index 0000000..8a5b3c7
--- /dev/null
+++ b/user/test/com/google/gwt/user/rebind/AbstractSourceCreatorTest.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.rebind;
+
+import com.google.gwt.core.ext.typeinfo.JPrimitiveType;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class AbstractSourceCreatorTest {
+
+  @Test
+  public void testGetJavaObjectTypeForPrimitveTypes() {
+    for (JPrimitiveType primitiveType : JPrimitiveType.values()) {
+      String returnType = AbstractSourceCreator.getJavaObjectTypeFor(primitiveType);
+      String expectedType = primitiveType.getQualifiedBoxedSourceName().substring("java.lang."
+          .length());
+      assertEquals("Wrong Return Type for primitve type", expectedType, returnType);
+    }
+  }
+
+}