diff --git a/user/src/com/google/gwt/i18n/rebind/ConstantsWithLookupImplCreator.java b/user/src/com/google/gwt/i18n/rebind/ConstantsWithLookupImplCreator.java
index 89813c9..0a5de8b 100644
--- a/user/src/com/google/gwt/i18n/rebind/ConstantsWithLookupImplCreator.java
+++ b/user/src/com/google/gwt/i18n/rebind/ConstantsWithLookupImplCreator.java
@@ -25,17 +25,54 @@
 import com.google.gwt.core.ext.typeinfo.TypeOracleException;
 import com.google.gwt.i18n.rebind.AbstractResource.ResourceList;
 import com.google.gwt.i18n.shared.GwtLocale;
-import com.google.gwt.user.rebind.AbstractMethodCreator;
+import com.google.gwt.thirdparty.guava.common.collect.Lists;
 import com.google.gwt.user.rebind.SourceWriter;
 
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 
 class ConstantsWithLookupImplCreator extends ConstantsImplCreator {
+
+  /**
+   * Used partition size if no one is specified.
+   * 
+   * Used in constructor without a partition size.
+   */
+  private static final int DEFAULT_PARTITIONS_SIZE = 500;
+  
   final JMethod[] allInterfaceMethods;
 
-  private final Map<String, AbstractMethodCreator> namesToMethodCreators = new HashMap<String, AbstractMethodCreator>();
+  private final Map<String, LookupMethodCreator> namesToMethodCreators = new HashMap<>();
+  
+  private final Map<JMethod, List<List<JMethod>>> neededPartitionLookups = new HashMap<>();
 
+  private final int partitionsSize;
+
+  /**
+   * Constructor for <code>ConstantsWithLookupImplCreator</code>. The default partition size of
+   * {@value #DEFAULT_PARTITIONS_SIZE} is used.
+   * 
+   * @param logger logger to print errors
+   * @param writer <code>Writer</code> to print to
+   * @param localizableClass class/interface to conform to
+   * @param resourceList resource bundle used to generate the class
+   * @param oracle types
+   * @throws UnableToCompleteException
+   * 
+   * @see LookupMethodCreator#DEFAULT_PARTITIONS_SIZE
+   */
+  ConstantsWithLookupImplCreator(TreeLogger logger, SourceWriter writer,
+      JClassType localizableClass, ResourceList resourceList, TypeOracle oracle)
+      throws UnableToCompleteException {
+    this(logger, writer, localizableClass, resourceList, oracle, DEFAULT_PARTITIONS_SIZE);
+  }
+  
   /**
    * Constructor for <code>ConstantsWithLookupImplCreator</code>.
    * 
@@ -47,9 +84,10 @@
    * @throws UnableToCompleteException
    */
   ConstantsWithLookupImplCreator(TreeLogger logger, SourceWriter writer,
-      JClassType localizableClass, ResourceList resourceList, TypeOracle oracle)
-      throws UnableToCompleteException {
+      JClassType localizableClass, ResourceList resourceList, TypeOracle oracle, 
+      int partitionsSize) throws UnableToCompleteException {
     super(logger, writer, localizableClass, resourceList, oracle);
+    this.partitionsSize = partitionsSize;
     try {
 
       // Boolean
@@ -63,7 +101,9 @@
 
         @Override
         public String returnTemplate() {
-          return "boolean answer = {0}();\ncache.put(\"{0}\",new Boolean(answer));\nreturn answer;";
+          return "boolean answer = {0}();\n"
+              + "cache.put(\"{0}\",new Boolean(answer));\n"
+              + "return answer;";
         }
       };
       namesToMethodCreators.put("getBoolean", booleanMethod);
@@ -79,7 +119,9 @@
 
         @Override
         public String returnTemplate() {
-          return "double answer = {0}();\ncache.put(\"{0}\",new Double(answer));\nreturn answer;";
+          return "double answer = {0}();\n"
+              + "cache.put(\"{0}\",new Double(answer));\n"
+              + "return answer;";
         }
       };
       namesToMethodCreators.put("getDouble", doubleMethod);
@@ -94,7 +136,9 @@
 
         @Override
         public String returnTemplate() {
-          return "int answer = {0}();\ncache.put(\"{0}\",new Integer(answer));\nreturn answer;";
+          return "int answer = {0}();\n"
+              + "cache.put(\"{0}\",new Integer(answer));\n"
+              + "return answer;";
         }
       };
 
@@ -105,7 +149,9 @@
       LookupMethodCreator floatMethod = new LookupMethodCreator(this, floatType) {
         @Override
         public String returnTemplate() {
-          String val = "float answer = {0}();\ncache.put(\"{0}\", new Float(answer));\nreturn answer;";
+          String val = "float answer = {0}();\n"
+              + "cache.put(\"{0}\", new Float(answer));\n"
+              + "return answer;";
           return val;
         }
 
@@ -132,7 +178,9 @@
           stringType) {
         @Override
         public String returnTemplate() {
-          return "String answer = {0}();\ncache.put(\"{0}\",answer);\nreturn answer;";
+          return "String answer = {0}();\n"
+              + "cache.put(\"{0}\",answer);\n"
+              + "return answer;";
         }
       };
       namesToMethodCreators.put("getString", stringMethod);
@@ -149,6 +197,12 @@
     }
   }
 
+  @Override
+  protected void classEpilog() {
+    createNeededPartitionLookups();
+    super.classEpilog();
+  }
+
   /**
    * Create the method body associated with the given method. Arguments are
    * arg0...argN.
@@ -159,9 +213,9 @@
     checkMethod(logger, method);
     if (method.getParameters().length == 1) {
       String name = method.getName();
-      AbstractMethodCreator c = namesToMethodCreators.get(name);
+      LookupMethodCreator c = getLookupMethodCreator(name);
       if (c != null) {
-        c.createMethodFor(logger, method, name, null, locale);
+        createMethodWithPartitionCheckFor(c, method);
         return;
       }
     }
@@ -169,6 +223,68 @@
     super.emitMethodBody(logger, method, locale);
   }
 
+  void addNeededPartitionLookups(JMethod targetMethod,
+      List<List<JMethod>> methodToCreatePartitionLookups) {
+    neededPartitionLookups.put(targetMethod, methodToCreatePartitionLookups);
+  }
+
+  void createMethodWithPartitionCheckFor(LookupMethodCreator methodCreator, JMethod targetMethod) {
+    List<List<JMethod>> methodPartitions = findMethodsToCreateWithPartitionSize(targetMethod,
+        methodCreator.getReturnType());
+
+    String nextPartitionMethod = null;
+    final List<List<JMethod>> methodToCreatePartitionLookups;
+    final List<JMethod> methodsToCreate;
+    if (methodPartitions.size() > 1) {
+      nextPartitionMethod = createPartitionMethodName(targetMethod, 0);
+      methodsToCreate = methodPartitions.get(0);
+      methodToCreatePartitionLookups = methodPartitions.subList(1, methodPartitions.size());
+    } else {
+      methodsToCreate = methodPartitions.isEmpty() ? Collections.<JMethod> emptyList()
+          : methodPartitions.get(0);
+      methodToCreatePartitionLookups = Collections.emptyList();
+    }
+    addNeededPartitionLookups(targetMethod, methodToCreatePartitionLookups);
+    methodCreator.createCacheLookupFor();
+    methodCreator.createMethodFor(targetMethod, methodsToCreate, nextPartitionMethod);
+  }
+
+  String createPartitionMethodName(JMethod targetMethod, int partitionIndex) {
+    final String templatePartitionMethodName = "{0}FromPartition{1}";
+    return MessageFormat.format(templatePartitionMethodName, new Object[] {
+        targetMethod.getName(), partitionIndex});
+  }
+
+  List<JMethod> findAllMethodsToCreate(JMethod targetMethod, JType methodReturnType) {
+    JMethod[] allMethods = allInterfaceMethods;
+    JType erasedType = methodReturnType.getErasedType();
+    List<JMethod> methodsToCreate = new ArrayList<>();
+    for (JMethod methodToCheck : allMethods) {
+      if (methodToCheck.getReturnType().getErasedType().equals(erasedType)
+          && methodToCheck != targetMethod) {
+        methodsToCreate.add(methodToCheck);
+      }
+    }
+    return methodsToCreate;
+  }
+
+  List<List<JMethod>> findMethodsToCreateWithPartitionSize(JMethod targetMethod,
+      JType methodReturnType) {
+    List<JMethod> allMethodsToCreate = findAllMethodsToCreate(targetMethod, methodReturnType);
+    return Lists.partition(allMethodsToCreate, partitionsSize);
+  }
+
+  LookupMethodCreator getLookupMethodCreator(String name) {
+    return namesToMethodCreators.get(name);
+  }
+
+  /**
+   * Visible for testing only.
+   */
+  Map<JMethod, List<List<JMethod>>> getNeededPartitionLookups() {
+    return neededPartitionLookups;
+  }
+
   /**
    * Checks that the method has the right structure to implement
    * <code>Constant</code>.
@@ -177,7 +293,7 @@
    */
   private void checkMethod(TreeLogger logger, JMethod method)
       throws UnableToCompleteException {
-    if (namesToMethodCreators.get(method.getName()) != null) {
+    if (getLookupMethodCreator(method.getName()) != null) {
       JParameter[] params = method.getParameters();
       // user may have specified a method named getInt/etc with no parameters
       // this isn't a conflict, so treat them like any other Constant methods
@@ -195,4 +311,26 @@
       checkConstantMethod(logger, method);
     }
   }
+
+  private void createNeededPartitionLookups() {
+    for (Entry<JMethod, List<List<JMethod>>> neededPartitionLookup : 
+      neededPartitionLookups.entrySet()) {
+      JMethod targetMethod = neededPartitionLookup.getKey();
+      LookupMethodCreator lookupMethodCreator = getLookupMethodCreator(targetMethod.getName());
+      List<List<JMethod>> methodForPartitionLookups = neededPartitionLookup.getValue();
+      int partitionStartIndex = 0;
+      Iterator<List<JMethod>> neededPartitionIterator = methodForPartitionLookups.iterator();
+      while (neededPartitionIterator.hasNext()) {
+        String currentPartitionLookupMethodName = createPartitionMethodName(targetMethod,
+            partitionStartIndex++);
+        List<JMethod> methodsToCreate = neededPartitionIterator.next();
+        String nextPartitionMethod = null;
+        if (neededPartitionIterator.hasNext()) {
+          nextPartitionMethod = createPartitionMethodName(targetMethod, partitionStartIndex);
+        }
+        lookupMethodCreator.createPartitionLookup(currentPartitionLookupMethodName, targetMethod,
+            methodsToCreate, nextPartitionMethod);
+      }
+    }
+  }
 }
diff --git a/user/src/com/google/gwt/i18n/rebind/LookupMethodCreator.java b/user/src/com/google/gwt/i18n/rebind/LookupMethodCreator.java
index fed873c..6a4f29b 100644
--- a/user/src/com/google/gwt/i18n/rebind/LookupMethodCreator.java
+++ b/user/src/com/google/gwt/i18n/rebind/LookupMethodCreator.java
@@ -21,17 +21,18 @@
 import com.google.gwt.core.ext.typeinfo.JType;
 import com.google.gwt.i18n.rebind.AbstractResource.ResourceList;
 import com.google.gwt.i18n.shared.GwtLocale;
-import com.google.gwt.user.rebind.AbstractGeneratorClassCreator;
 import com.google.gwt.user.rebind.AbstractMethodCreator;
 import com.google.gwt.user.rebind.AbstractSourceCreator;
 
 import java.text.MessageFormat;
+import java.util.List;
 
 /**
  * Method creator to call the correct Map for the given Dictionary.
  */
 class LookupMethodCreator extends AbstractMethodCreator {
-  private JType returnType;
+
+  private final JType returnType;
 
   /**
    * Constructor for <code>LookupMethodCreator</code>.
@@ -39,18 +40,17 @@
    * @param classCreator parent class creator
    * @param returnType associated return type
    */
-  public LookupMethodCreator(AbstractGeneratorClassCreator classCreator,
-      JType returnType) {
+  public LookupMethodCreator(ConstantsWithLookupImplCreator classCreator, JType returnType) {
     super(classCreator);
     this.returnType = returnType;
   }
 
   @Override
-  public void createMethodFor(TreeLogger logger, JMethod targetMethod,
-      String key, ResourceList resourceList, GwtLocale locale) {
-    createMethodFor(targetMethod);
+  public void createMethodFor(TreeLogger logger, JMethod targetMethod, String key,
+      ResourceList resourceList, GwtLocale locale) {
+    getConstantsWithLookupCreator().createMethodWithPartitionCheckFor(this, targetMethod);
   }
-
+  
   /**
    * Returns a {@code String} containing the return type name.
    */
@@ -65,7 +65,7 @@
     return type;
   }
 
-  void createMethodFor(JMethod targetMethod) {
+  void createCacheLookupFor() {
     String template = "{0} target = ({0}) cache.get(arg0);";
     String returnTypeName = getReturnTypeName();
     String lookup = MessageFormat.format(template, new Object[] {returnTypeName});
@@ -75,27 +75,64 @@
     printReturnTarget();
     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("}");
-      }
+  }
+
+  /**
+   * 
+   * @param targetMethod the method to create the lookups for
+   * @param methodsToCreate the looked up methods
+   * @param nextPartitionMethod the name of next method is called or null if end this generated
+   *          method with throwing an exception
+   */
+  void createMethodFor(JMethod targetMethod, List<JMethod> methodsToCreate,
+      String nextPartitionMethod) {
+    createMethodLookups(methodsToCreate);
+    final String result;
+    boolean isLastPartition = nextPartitionMethod == null;
+    if (isLastPartition) {
+      result = createThrowMissingResourceException();
+    } else {
+      String callPartitionMethodTemplate = "return {0}(arg0);";
+      result = MessageFormat.format(callPartitionMethodTemplate, new Object[] {
+          nextPartitionMethod});
     }
-    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());
     println(result);
   }
 
+  void createMethodLookups(List<JMethod> methodsToCreate) {
+    for (JMethod methodToCreate : methodsToCreate) {
+      String methodName = methodToCreate.getName();
+      String body = "if (arg0.equals(" + wrap(methodName) + ")) {";
+      println(body);
+      indent();
+      printFound(methodName);
+      outdent();
+      println("}");
+    }
+  }
+
+  void createPartitionLookup(String partitionMethodName, JMethod targetMethod,
+      List<JMethod> methodsToCreate, String nextPartitionMethod) {
+    println("");
+    final String templatePartitionMethodName = "private {0} {1}({2} arg0) '{";
+    final String argument0Type = targetMethod.getParameterTypes()[0].getQualifiedSourceName();
+    String partitionMethodSignature = MessageFormat.format(templatePartitionMethodName,
+        new Object[] {getReturnTypeName(), partitionMethodName, argument0Type});
+    println(partitionMethodSignature);
+    indent();
+    createMethodFor(targetMethod, methodsToCreate, nextPartitionMethod);
+    outdent();
+    println("}");
+  }
+  
+  ConstantsWithLookupImplCreator getConstantsWithLookupCreator() {
+    return ((ConstantsWithLookupImplCreator) currentCreator);
+  }
+
+  JType getReturnType() {
+    return returnType;
+  }
+
   void printFound(String methodName) {
     println(MessageFormat.format(returnTemplate(), new Object[] {methodName}));
   }
@@ -107,4 +144,13 @@
   String returnTemplate() {
     return "return {0}();";
   }
+
+  private String createThrowMissingResourceException() {
+    final String result;
+    String format = "throw new java.util.MissingResourceException(\"Cannot find constant ''\" +"
+        + "{0} + \"''; expecting a method name\", \"{1}\", {0});";
+    result = MessageFormat.format(format, "arg0", this.currentCreator.getTarget()
+        .getQualifiedSourceName());
+    return result;
+  }
 }
diff --git a/user/src/com/google/gwt/user/rebind/AbstractGeneratorClassCreator.java b/user/src/com/google/gwt/user/rebind/AbstractGeneratorClassCreator.java
index a77c502..fe18ed4 100644
--- a/user/src/com/google/gwt/user/rebind/AbstractGeneratorClassCreator.java
+++ b/user/src/com/google/gwt/user/rebind/AbstractGeneratorClassCreator.java
@@ -45,7 +45,7 @@
    * @return interface methods.
    */
   public static JMethod[] getAllInterfaceMethods(JClassType type) {
-    Map<String, JMethod> methods = new LinkedHashMap<String, JMethod>();
+    Map<String, JMethod> methods = new LinkedHashMap<>();
     getAllInterfaceMethodsAux(type, methods);
     return methods.values().toArray(new JMethod[methods.size()]);
   }
diff --git a/user/src/com/google/gwt/user/rebind/AbstractSourceCreator.java b/user/src/com/google/gwt/user/rebind/AbstractSourceCreator.java
index 5f5e31f..6939704 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..970373c 100644
--- a/user/test/com/google/gwt/i18n/I18NJreSuite.java
+++ b/user/test/com/google/gwt/i18n/I18NJreSuite.java
@@ -15,8 +15,10 @@
  */
 package com.google.gwt.i18n;
 
+import com.google.gwt.i18n.rebind.ConstantsWithLookupImplCreatorTest;
 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;
@@ -59,6 +61,8 @@
      */
     // suite.addTestSuite(TypeOracleMessageTest.class);
     suite.addTestSuite(WordCountDirectionEstimatorTest.class);
+    suite.addTestSuite(LookupMethodCreatorTest.class);
+    suite.addTestSuite(ConstantsWithLookupImplCreatorTest.class);
     // $JUnit-END$
 
     return suite;
diff --git a/user/test/com/google/gwt/i18n/rebind/ConstantsWithLookupImplCreatorTest.java b/user/test/com/google/gwt/i18n/rebind/ConstantsWithLookupImplCreatorTest.java
new file mode 100644
index 0000000..c1e8d03
--- /dev/null
+++ b/user/test/com/google/gwt/i18n/rebind/ConstantsWithLookupImplCreatorTest.java
@@ -0,0 +1,356 @@
+/*
+ * 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.i18n.server.GwtLocaleFactoryImpl;
+import com.google.gwt.i18n.shared.GwtLocale;
+import com.google.gwt.i18n.shared.GwtLocaleFactory;
+import com.google.gwt.user.rebind.SourceWriter;
+import com.google.gwt.user.rebind.StringSourceWriter;
+
+import junit.framework.TestCase;
+
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Tests for {@link ConstantsWithLookupImplCreator}.
+ */
+public class ConstantsWithLookupImplCreatorTest extends TestCase {
+
+  private static final int TEST_PARTITION_SIZE = 3;
+
+  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 stringEntry();\n");
+      code.append(" int intEntry();\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 PARTITION_SIZE_ENTRY_MESSAGES = new MockJavaResource(
+      "foo.PartitionSizeEntryMessage") {
+    @Override
+    public CharSequence getContent() {
+      StringBuffer code = new StringBuffer();
+      code.append("package foo;\n");
+      code.append("public interface PartitionSizeEntryMessage extends foo.Lookup {\n");
+      for (int i = 1; i <= TEST_PARTITION_SIZE; i++) {
+        code.append(" String lookupMethod");
+        code.append(i);
+        code.append("();\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(" int getInt(String arg0);\n");
+      code.append("}");
+      return code;
+    }
+  };
+
+  private TreeLogger logger = new FailErrorLogger();
+
+  private GwtLocale locale;
+
+  private ConstantsWithLookupImplCreator constantsWithLookupImplCreator;
+
+  private SourceWriter sw = new StringSourceWriter();
+
+  private TypeOracle oracle;
+
+  private JMethod stringMethod;
+
+  private JMethod intMethod;
+
+  @Override
+  public void setUp() throws TypeOracleException, UnableToCompleteException {
+    GwtLocaleFactory factory = new GwtLocaleFactoryImpl();
+    locale = factory.fromString("en");
+    oracle = TypeOracleTestingUtils.buildStandardTypeOracleWith(logger, SINGLE_ENTRY_MESSAGES,
+        FOUR_ENTRY_MESSAGES, LOOKUP, PARTITION_SIZE_ENTRY_MESSAGES);
+    initLookupMethodCreator(SINGLE_ENTRY_MESSAGES);
+  }
+
+  public void testClassEpilogCallCreatesNeededPartitonLookups() {
+    List<JMethod> missingPartition0 = Arrays.asList(stringMethod, intMethod);
+    List<List<JMethod>> methodToCreatePartitionLookups = new ArrayList<>();
+    methodToCreatePartitionLookups.add(missingPartition0);
+    constantsWithLookupImplCreator.addNeededPartitionLookups(stringMethod,
+        methodToCreatePartitionLookups);
+
+    constantsWithLookupImplCreator.classEpilog();
+
+    String actual = sw.toString().trim();
+
+    assertTrue("Missing partition lookup method (getStringFromPartition0).", actual.contains(
+        "java.lang.String getStringFromPartition0(java.lang.String arg0) {"));
+  }
+
+  public void testCodeForIntIsGeneratedSameAsWithoutPartitions() throws TypeOracleException,
+      UnableToCompleteException {
+    initLookupMethodCreator(SINGLE_ENTRY_MESSAGES);
+    constantsWithLookupImplCreator.emitMethodBody(logger, intMethod, locale);
+
+    // Same generated code as in version 2.8.1
+    SourceWriter expected = new StringSourceWriter();
+    expected.println("Integer target = (Integer) cache.get(arg0);");
+    expected.println("if (target != null) {");
+    expected.indent();
+    expected.println("return target.intValue();");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("if(arg0.equals(\"intEntry\")) {");
+    expected.indent();
+    expected.println("int answer = intEntry();");
+    // Needed because the return template use '\n'
+    expected.outdent();
+    expected.println("cache.put(\"intEntry\",new Integer(answer));");
+    expected.println("return answer;");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("throw new java.util.MissingResourceException("
+        + "\"Cannot find constant '\" +arg0 + \"'; expecting a method name\", \"foo.SingleEntryMessage\", arg0);");
+    expected.outdent();
+
+    String actual = sw.toString();
+    assertEquals("Wrong source Lookup created.", expected.toString(), actual);
+  }
+
+  public void testCodeIsGeneratedSameAsWithoutPartitions() throws TypeOracleException,
+      UnableToCompleteException {
+    initLookupMethodCreator(PARTITION_SIZE_ENTRY_MESSAGES);
+    constantsWithLookupImplCreator.emitMethodBody(logger, stringMethod, locale);
+
+    // Same generated code as in version 2.8.1
+    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("if(arg0.equals(\"lookupMethod1\")) {");
+    expected.indent();
+    expected.print("String answer = lookupMethod1();");
+    expected.print("\n");
+    expected.print("cache.put(\"lookupMethod1\",answer);");
+    expected.print("\n");
+    expected.println("return answer;");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("if(arg0.equals(\"lookupMethod2\")) {");
+    expected.indent();
+    expected.print("String answer = lookupMethod2();");
+    expected.print("\n");
+    expected.print("cache.put(\"lookupMethod2\",answer);");
+    expected.print("\n");
+    expected.println("return answer;");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("if(arg0.equals(\"lookupMethod3\")) {");
+    expected.indent();
+    expected.print("String answer = lookupMethod3();");
+    expected.print("\n");
+    expected.print("cache.put(\"lookupMethod3\",answer);");
+    expected.print("\n");
+    expected.println("return answer;");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("throw new java.util.MissingResourceException("
+        + "\"Cannot find constant '\" +arg0 + \"'; expecting a method name\", \"foo.PartitionSizeEntryMessage\", arg0);");
+    expected.outdent();
+
+    String actual = sw.toString();
+    assertEquals("Wrong source Lookup created.", expected.toString(), actual);
+  }
+
+  public void testCreateMethodForJMethodForSingleEntry() throws UnableToCompleteException {
+    constantsWithLookupImplCreator.emitMethodBody(logger, stringMethod, locale);
+
+    assertFalse("No partition lookup should created.", sw.toString().contains(
+        "java.lang.String getString0(java.lang.String arg0) {"));
+  }
+
+  public void testCreateMethodForJMethodForSingleIntEntry() throws UnableToCompleteException {
+    constantsWithLookupImplCreator.emitMethodBody(logger, intMethod, locale);
+
+    String createdSource = sw.toString();
+    assertTrue("Lookup for intMethod not created.", createdSource.contains(
+        "int answer = intEntry();"));
+  }
+
+  public void testCreateMethodForPartitionSizeEntriesNoPartitionNeeded() throws TypeOracleException,
+      UnableToCompleteException {
+    initLookupMethodCreator(PARTITION_SIZE_ENTRY_MESSAGES);
+    constantsWithLookupImplCreator.emitMethodBody(logger, stringMethod, locale);
+
+    String actual = sw.toString();
+
+    assertFalse("Missing partition lookup method (getStringFromPartitionN).", actual.contains(
+        "getStringFromPartition"));
+  }
+
+  public void testCreatePartitionMethodName() {
+    String partitionMethodName = constantsWithLookupImplCreator.createPartitionMethodName(
+        stringMethod, 1);
+    String expectedPartitionMethodName = "getStringFromPartition1";
+    assertEquals(expectedPartitionMethodName, partitionMethodName);
+  }
+
+  public void testEmitClassWithMultiMessageEntryCreateOneAdditionalPartition()
+      throws TypeOracleException, UnableToCompleteException {
+    initLookupMethodCreator(FOUR_ENTRY_MESSAGES);
+    constantsWithLookupImplCreator.emitClass(logger, locale);
+
+    String actual = sw.toString().trim();
+
+    assertTrue("Missing partition lookup method (getStringFromPartition0).", actual.contains(
+        "java.lang.String getStringFromPartition0(java.lang.String arg0) {"));
+  }
+
+  public void testEmitMethodBodyForJMethodForMultiMessageEntryNeedOneAdditionalPartition()
+      throws TypeOracleException, UnableToCompleteException {
+    initLookupMethodCreator(FOUR_ENTRY_MESSAGES);
+    constantsWithLookupImplCreator.emitMethodBody(logger, stringMethod, locale);
+
+    String actual = sw.toString().trim();
+
+    assertTrue("Method should end with call partition lookup method.", actual.endsWith(
+        "return getStringFromPartition0(arg0);"));
+    assertFalse("Partition method should not be created", actual.contains(
+        "java.lang.String getStringFromPartition0(java.lang.String arg0) {"));
+
+    assertEquals(1, constantsWithLookupImplCreator.getNeededPartitionLookups().size());
+  }
+
+  public void testFindMethodsToCreate() throws TypeOracleException {
+    initLookupMethodCreator(SINGLE_ENTRY_MESSAGES);
+
+    JType intType = oracle.parse(int.class.getName());
+    List<JMethod> intMethods = constantsWithLookupImplCreator.findAllMethodsToCreate(intMethod,
+        intType);
+
+    JMethod expectedIntMethod = oracle.findType(SINGLE_ENTRY_MESSAGES.getTypeName()).findMethod(
+        "intEntry", new JType[0]);
+
+    assertEquals(1, intMethods.size());
+    assertEquals(expectedIntMethod, intMethods.get(0));
+  }
+
+  public void testFindMethodsToCreateWithDifferentTargetMethod() throws TypeOracleException {
+    initLookupMethodCreator(SINGLE_ENTRY_MESSAGES);
+
+    JType intType = oracle.parse(int.class.getName());
+    List<JMethod> foundMethods = constantsWithLookupImplCreator.findAllMethodsToCreate(stringMethod,
+        intType);
+
+    JMethod expectedIntMethod = oracle.findType(SINGLE_ENTRY_MESSAGES.getTypeName()).findMethod(
+        "intEntry", new JType[0]);
+
+    assertEquals(2, foundMethods.size());
+    assertTrue(foundMethods.contains(intMethod));
+    assertTrue(foundMethods.contains(expectedIntMethod));
+  }
+
+  public void testGetReturnTypeNameForPrimitveTypes() {
+    for (JPrimitiveType primitiveType : JPrimitiveType.values()) {
+      LookupMethodCreator primitiveMethodCreator = new LookupMethodCreator(null, primitiveType);
+      String returnType = primitiveMethodCreator.getReturnTypeName();
+      String expectedType = primitiveType.getQualifiedBoxedSourceName().substring("java.lang."
+          .length());
+      assertEquals("Wrong Return Type for primitve type", expectedType, returnType);
+    }
+  }
+
+  private void initLookupMethodCreator(MockJavaResource resource) throws TypeOracleException {
+    initLookupMethodCreator(resource, TEST_PARTITION_SIZE);
+  }
+
+  private void initLookupMethodCreator(MockJavaResource resource, int partitionsSize)
+      throws TypeOracleException {
+    JClassType clazz = oracle.findType(resource.getTypeName());
+    try {
+      ResourceList resourceList = mock(ResourceList.class);
+      when(resourceList.getRequiredStringExt(anyString(), anyString())).thenReturn(
+          "Required value");
+      constantsWithLookupImplCreator = new ConstantsWithLookupImplCreator(logger, sw, clazz,
+          resourceList, oracle, partitionsSize);
+
+      JType stringType = oracle.parse(String.class.getName());
+      stringMethod = oracle.findType(LOOKUP.getTypeName()).findMethod("getString", new JType[] {
+          stringType});
+      intMethod = oracle.findType(LOOKUP.getTypeName()).findMethod("getInt", new JType[] {
+          stringType});
+    } catch (UnableToCompleteException e) {
+      fail(e.getMessage());
+    }
+  }
+
+}
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..3fb045b
--- /dev/null
+++ b/user/test/com/google/gwt/i18n/rebind/LookupMethodCreatorTest.java
@@ -0,0 +1,265 @@
+/*
+ * 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.i18n.server.GwtLocaleFactoryImpl;
+import com.google.gwt.i18n.shared.GwtLocale;
+import com.google.gwt.i18n.shared.GwtLocaleFactory;
+import com.google.gwt.user.rebind.SourceWriter;
+import com.google.gwt.user.rebind.StringSourceWriter;
+
+import junit.framework.TestCase;
+
+import static org.mockito.Mockito.mock;
+
+import java.util.List;
+
+/**
+ * Tests for {@link LookupMethodCreator}.
+ */
+public class LookupMethodCreatorTest extends TestCase {
+
+  private static final int TEST_PARTITION_SIZE = 3;
+
+  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 stringEntry();\n");
+      code.append(" int intEntry();\n");
+      code.append("}");
+      return code;
+    }
+  };
+  private static final MockJavaResource PARTITION_SIZE_ENTRY_MESSAGES = new MockJavaResource(
+      "foo.PartitionSizeEntryMessage") {
+    @Override
+    public CharSequence getContent() {
+      StringBuffer code = new StringBuffer();
+      code.append("package foo;\n");
+      code.append("public interface PartitionSizeEntryMessage extends foo.Lookup {\n");
+      for (int i = 1; i <= TEST_PARTITION_SIZE; i++) {
+        code.append(" String lookupMethod");
+        code.append(i);
+        code.append("();\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(" int getInt(String arg0);\n");
+      code.append("}");
+      return code;
+    }
+  };
+
+  private TreeLogger logger = new FailErrorLogger();
+
+  private LookupMethodCreator stringCreator;
+  private LookupMethodCreator intCreator;
+
+  private SourceWriter sw = new StringSourceWriter();
+
+  private TypeOracle oracle;
+
+  private JMethod stringMethod;
+
+  private JMethod intMethod;
+
+  private GwtLocale locale;
+
+  @Override
+  public void setUp() throws TypeOracleException, UnableToCompleteException {
+    GwtLocaleFactory factory = new GwtLocaleFactoryImpl();
+    locale = factory.fromString("en");
+    oracle = TypeOracleTestingUtils.buildStandardTypeOracleWith(logger, SINGLE_ENTRY_MESSAGES,
+        LOOKUP, PARTITION_SIZE_ENTRY_MESSAGES);
+    initLookupMethodCreator(SINGLE_ENTRY_MESSAGES);
+  }
+
+  public void testCodeForIntIsGeneratedSameAsWithoutPartitions() throws TypeOracleException {
+    initLookupMethodCreator(SINGLE_ENTRY_MESSAGES);
+    intCreator.createMethodFor(logger, intMethod, intMethod.getName(), null, locale);
+
+    // Same generated code as in version 2.8.1
+    SourceWriter expected = new StringSourceWriter();
+    expected.println("Integer target = (Integer) cache.get(arg0);");
+    expected.println("if (target != null) {");
+    expected.indent();
+    expected.println("return target.intValue();");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("if (arg0.equals(\"intEntry\")) {");
+    expected.indent();
+    expected.println("int answer = intEntry();");
+    // Needed because the return template use '\n'
+    expected.outdent();
+    expected.println("cache.put(\"intEntry\",new Integer(answer));");
+    expected.println("return answer;");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("throw new java.util.MissingResourceException("
+        + "\"Cannot find constant '\" +arg0 + \"'; expecting a method name\", \"foo.SingleEntryMessage\", arg0);");
+    expected.outdent();
+
+    String actual = sw.toString();
+    assertEquals("Wrong source Lookup created.", expected.toString(), actual);
+  }
+
+  public void testCodeIsGeneratedSameAsWithoutPartitions() throws TypeOracleException {
+    initLookupMethodCreator(PARTITION_SIZE_ENTRY_MESSAGES);
+    stringCreator.createMethodFor(logger, stringMethod, stringMethod.getName(), null, locale);
+
+    // Same generated code as in version 2.8.1
+    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("if (arg0.equals(\"lookupMethod1\")) {");
+    expected.indent();
+    expected.println("return lookupMethod1();");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("if (arg0.equals(\"lookupMethod2\")) {");
+    expected.indent();
+    expected.println("return lookupMethod2();");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("if (arg0.equals(\"lookupMethod3\")) {");
+    expected.indent();
+    expected.println("return lookupMethod3();");
+    expected.outdent();
+    expected.println("}");
+
+    expected.println("throw new java.util.MissingResourceException("
+        + "\"Cannot find constant '\" +arg0 + \"'; expecting a method name\", \"foo.PartitionSizeEntryMessage\", arg0);");
+    expected.outdent();
+
+    String actual = sw.toString();
+    assertEquals("Wrong source Lookup created.", expected.toString(), actual);
+  }
+
+  public void testCreateMethodForJMethodForSingleEntry() throws TypeOracleException {
+    JType stringType = oracle.parse(String.class.getName());
+    List<JMethod> methodsToCreate = stringCreator.getConstantsWithLookupCreator()
+        .findAllMethodsToCreate(stringMethod, stringType);
+    stringCreator.createMethodFor(stringMethod, methodsToCreate, null);
+
+    assertFalse("No partition lookup should created.", sw.toString().contains(
+        "java.lang.String getString0(java.lang.String arg0) {"));
+  }
+
+  public void testCreateMethodForJMethodForSingleIntEntry() throws TypeOracleException {
+    JType intType = oracle.parse(int.class.getName());
+    List<JMethod> methodsToCreate = intCreator.getConstantsWithLookupCreator()
+        .findAllMethodsToCreate(intMethod, intType);
+    intCreator.createMethodFor(intMethod, methodsToCreate, null);
+
+    String createdSource = sw.toString();
+    assertTrue("Lookup for intMethod not created.", createdSource.contains(
+        "int answer = intEntry();"));
+  }
+
+  public void testGetReturnTypeName() {
+    String returnType = stringCreator.getReturnTypeName();
+    assertEquals("java.lang.String", returnType);
+  }
+
+  public void testGetReturnTypeNameForPrimitveTypes() {
+    for (JPrimitiveType primitiveType : JPrimitiveType.values()) {
+      LookupMethodCreator primitiveMethodCreator = new LookupMethodCreator(null, primitiveType);
+      String returnType = primitiveMethodCreator.getReturnTypeName();
+      String expectedType = primitiveType.getQualifiedBoxedSourceName().substring("java.lang."
+          .length());
+      assertEquals("Wrong Return Type for primitve type", expectedType, returnType);
+    }
+  }
+
+  public void testPrintFound() {
+    stringCreator.printFound("callTest");
+
+    String returnStatement = sw.toString();
+    assertEquals("return callTest();\n", returnStatement);
+  }
+
+  private void initLookupMethodCreator(MockJavaResource resource) throws TypeOracleException {
+    initLookupMethodCreator(resource, TEST_PARTITION_SIZE);
+  }
+
+  private void initLookupMethodCreator(MockJavaResource resource, int partitionsSize)
+      throws TypeOracleException {
+    JClassType clazz = oracle.findType(resource.getTypeName());
+    ConstantsWithLookupImplCreator mockCreator;
+    try {
+      mockCreator = new ConstantsWithLookupImplCreator(logger, sw, clazz, mock(ResourceList.class),
+          oracle, partitionsSize);
+
+      JType stringType = oracle.parse(String.class.getName());
+      stringMethod = oracle.findType(LOOKUP.getTypeName()).findMethod("getString", new JType[] {
+          stringType});
+      JType intType = oracle.parse(int.class.getName());
+      intMethod = oracle.findType(LOOKUP.getTypeName()).findMethod("getInt", new JType[] {
+          stringType});
+
+      stringCreator = new LookupMethodCreator(mockCreator, stringType);
+      intCreator = new LookupMethodCreator(mockCreator, intType) {
+        @Override
+        public void printReturnTarget() {
+          println("return target.intValue();");
+        }
+
+        @Override
+        public String returnTemplate() {
+          return "int answer = {0}();\ncache.put(\"{0}\",new Integer(answer));\nreturn answer;";
+        }
+      };
+    } catch (UnableToCompleteException e) {
+      fail(e.getMessage());
+    }
+  }
+
+}
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..43c2b97
--- /dev/null
+++ b/user/test/com/google/gwt/user/UserJreSuite.java
@@ -0,0 +1,37 @@
+/*
+ * 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
+ *
+ * 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.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.addTestSuite(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..95dff8d
--- /dev/null
+++ b/user/test/com/google/gwt/user/rebind/AbstractSourceCreatorTest.java
@@ -0,0 +1,36 @@
+/*
+ * 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 junit.framework.TestCase;
+
+/**
+ * Used to test the {@link AbstractSourceCreator}.
+ */
+public class AbstractSourceCreatorTest extends TestCase {
+
+  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);
+    }
+  }
+
+}