Java Examples for com.google.protobuf.Descriptors.Descriptor

/**
   * Turn a generic message into a Tuple.  Individual fields that are enums
   * are converted into their string equivalents.  Fields that are not filled
   * out in the protobuf are set to null, unless there is a default field value in
   * which case that is used instead.
   * @param msg the protobuf message
   * @return a pig tuple representing the message.
   */
public Tuple toTuple(Message msg) {
    if (msg == null) {
        // Also, we can be called with null here in recursive calls.
        return null;
    }
    Descriptor msgDescriptor = msg.getDescriptorForType();
    Tuple tuple = tupleFactory_.newTuple(msgDescriptor.getFields().size());
    int curField = 0;
    try {
        // Walk through all the possible fields in the message.
        for (FieldDescriptor fieldDescriptor : msgDescriptor.getFields()) {
            // Get the set value, or the default value, or null.
            Object fieldValue = msg.getField(fieldDescriptor);
            if (fieldDescriptor.getType() == FieldDescriptor.Type.MESSAGE) {
                tuple.set(curField++, messageToTuple(fieldDescriptor, fieldValue));
            } else {
                tuple.set(curField++, singleFieldToTuple(fieldDescriptor, fieldValue));
            }
        }
    } catch (ExecException e) {
        LOG.warn("Could not convert msg " + msg + " to tuple", e);
    }
    return tuple;
}

private void populate(Message.Builder builder, JsonParser parser, DeserializationContext context) throws IOException {
    JsonToken token = parser.getCurrentToken();
    if (token == JsonToken.START_ARRAY) {
        token = parser.nextToken();
    }
    switch(token) {
        case END_OBJECT:
            return;
        case START_OBJECT:
            token = parser.nextToken();
            if (token == JsonToken.END_OBJECT) {
                return;
            }
            break;
        default:
            // make findbugs happy
            break;
    }
    final Descriptor descriptor = builder.getDescriptorForType();
    final Map<String, FieldDescriptor> fieldLookup = buildFieldLookup(descriptor, context);
    final Map<String, ExtensionInfo> extensionLookup;
    if (builder instanceof ExtendableMessageOrBuilder<?>) {
        extensionLookup = buildExtensionLookup(descriptor, context);
    } else {
        extensionLookup = Collections.emptyMap();
    }
    do {
        if (!token.equals(JsonToken.FIELD_NAME)) {
            throw context.wrongTokenException(parser, JsonToken.FIELD_NAME, "");
        }
        String name = parser.getCurrentName();
        FieldDescriptor field = fieldLookup.get(name);
        Message defaultInstance = null;
        if (field == null) {
            ExtensionInfo extensionInfo = extensionLookup.get(name);
            if (extensionInfo != null) {
                field = extensionInfo.descriptor;
                defaultInstance = extensionInfo.defaultInstance;
            }
        }
        if (field == null) {
            if (!context.handleUnknownProperty(parser, this, builder, name)) {
                context.reportUnknownProperty(builder, name, this);
            }
            parser.nextToken();
            parser.skipChildren();
            continue;
        }
        parser.nextToken();
        setField(builder, field, defaultInstance, parser, context);
    } while ((token = parser.nextToken()) != JsonToken.END_OBJECT);
}

/**
     * Gets the descriptor.
     *
     * @param cls the cls
     * @return the descriptor
     * @throws IOException Signals that an I/O exception has occurred.
     */
public static Descriptor getDescriptor(Class<?> cls) throws IOException {
    String idl = ProtobufIDLGenerator.getIDL(cls);
    ProtoFile file = ProtoParser.parse(ProtobufIDLProxy.DEFAULT_FILE_NAME, idl);
    FileDescriptorProtoPOJO fileDescriptorProto = new FileDescriptorProtoPOJO();
    fileDescriptorProto.name = ProtobufIDLProxy.DEFAULT_FILE_NAME;
    fileDescriptorProto.pkg = file.packageName();
    fileDescriptorProto.dependencies = file.dependencies();
    fileDescriptorProto.publicDependency = convertList(file.publicDependencies());
    // XXX
    fileDescriptorProto.weakDependency = null;
    fileDescriptorProto.messageTypes = new ArrayList<DescriptorProtoPOJO>();
    fileDescriptorProto.enumTypes = new ArrayList<EnumDescriptorProtoPOJO>();
    fileDescriptorProto.services = new ArrayList<ServiceDescriptorProtoPOJO>();
    Set<String> messageSet = new HashSet<String>();
    Set<String> enumSet = new HashSet<String>();
    List<TypeElement> typeElements = file.typeElements();
    if (typeElements != null) {
        for (TypeElement typeElement : typeElements) {
            if (typeElement instanceof MessageElement) {
                messageSet.add(typeElement.name());
            } else if (typeElement instanceof EnumElement) {
                enumSet.add(typeElement.name());
            }
        }
        for (TypeElement typeElement : typeElements) {
            if (typeElement instanceof MessageElement) {
                fileDescriptorProto.messageTypes.add(getDescritorProtoPOJO(fileDescriptorProto, (MessageElement) typeElement, messageSet, enumSet));
            } else if (typeElement instanceof EnumElement) {
                fileDescriptorProto.enumTypes.add(getDescritorProtoPOJO(fileDescriptorProto, (EnumElement) typeElement, messageSet, enumSet));
            }
        }
    }
    FileDescriptorProto fileproto;
    try {
        byte[] bs = descriptorCodec.encode(fileDescriptorProto);
        fileproto = FileDescriptorProto.parseFrom(bs);
    } catch (InvalidProtocolBufferException e) {
        throw new IOException("Failed to parse protocol buffer descriptor for generated code.", e);
    }
    FileDescriptor fileDescriptor;
    try {
        fileDescriptor = FileDescriptor.buildFrom(fileproto, new com.google.protobuf.Descriptors.FileDescriptor[] {});
    } catch (DescriptorValidationException e) {
        throw new IOException(e.getMessage(), e);
    }
    return fileDescriptor.getMessageTypes().get(0);
}

/**
     * @param refType The type of the {@link EReference} ({@link EReference#getEReferenceType()})
     * @param refSourceType The type of the actual object stored in the reference
     * @param refSource The actual object stored in the reference
     * @param refTargetType The *.Ref ProtoBuf message type
     * @param containment Whether the {@link EReference} is a containment ({@link EReference#isContainment()})
     * @return
     */
private DynamicMessage createReference(EClass refType, EClass refSourceType, EObject refSource, Descriptors.Descriptor refTargetType, boolean containment) {
    DynamicMessage.Builder refTarget = DynamicMessage.newBuilder(refTargetType);
    // lookup message defining extension for 'refTargetType'
    Descriptors.Descriptor refTargetExtension = getMappingContext().lookup(refSourceType);
    // lookup extension field
    FieldDescriptor refTargetField = refTargetExtension.findFieldByName(naming.getRefMessageExtensionField(refType, refSourceType));
    DynamicMessage refTargetFieldValue;
    if (containment) {
        refTargetFieldValue = convert(refSource, refTargetField.getMessageType());
    } else {
        refTargetFieldValue = DynamicMessage.newBuilder(refTargetExtension).setField(refTargetExtension.findFieldByName(naming.getInternalIdField()), pool.getId(refSource)).build();
    }
    refTarget.setField(refTargetField, refTargetFieldValue);
    return refTarget.build();
}

public static void setUpdatedAt(Builder item) {
    Descriptor descriptor = item.getDescriptorForType();
    Optional<FieldDescriptor> itemStateField = getClassState(descriptor).getItemStateField();
    if (itemStateField.isPresent()) {
        ItemStateData itemStateData;
        try {
            itemStateData = (ItemStateData) item.getField(itemStateField.get());
        } catch (Exception e) {
            throw new IllegalArgumentException("Error reading item state field", e);
        }
        ItemStateData.Builder b = ItemStateData.newBuilder(itemStateData);
        b.setUpdatedAt(Clock.getTimestamp());
        item.setField(itemStateField.get(), b.build());
    }
}

private NameContext resolveName(final String name, final FileDescriptor fileProto, final Map<String, NameContext> cache) {
    NameContext nameContext = cache.get(name);
    if (nameContext != null) {
        return nameContext;
    }
    final EnumDescriptor enumDesc = fileProto.findEnumTypeByName(name);
    if (enumDesc != null) {
        nameContext = NameContext.newResolvedInstance(enumDesc.getFullName(), true);
    } else {
        final Descriptor descriptor = fileProto.findMessageTypeByName(name);
        if (descriptor != null) {
            nameContext = NameContext.newResolvedInstance(descriptor.getFullName(), false);
        }
    }
    if ((nameContext == null) && !fileProto.getMessageTypes().isEmpty()) {
        nameContext = resolveName(name, fileProto.getMessageTypes());
    }
    if (nameContext == null) {
        nameContext = NameContext.emptyInstance();
    }
    cache.put(name, nameContext);
    return nameContext;
}

private SoyExpression messageToSoyExpression(Expression field) {
    if (node.getType().getKind() == SoyType.Kind.PROTO) {
        SoyProtoType fieldProtoType = (SoyProtoType) node.getType();
        SoyRuntimeType protoRuntimeType = SoyRuntimeType.getUnboxedType(fieldProtoType).get();
        return SoyExpression.forProto(protoRuntimeType, // cast needed for extensions
        field.checkedCast(protoRuntimeType.runtimeType()), renderContext);
    } else {
        // All other are special sanitized types
        ContentKind kind = ((SanitizedType) node.getType()).getContentKind();
        Descriptor messageType = descriptor.getMessageType();
        MethodRef methodRef = SAFE_PROTO_TO_ACCESSOR.get(messageType.getFullName());
        return SoyExpression.forSanitizedString(field.checkedCast(// cast needed for extensions
        methodRef.owner().type()).invoke(methodRef), kind);
    }
}

private SoyExpression messageToSoyExpression(Expression field) {
    if (node.getType().getKind() == SoyType.Kind.PROTO) {
        SoyProtoType fieldProtoType = (SoyProtoType) node.getType();
        SoyRuntimeType protoRuntimeType = SoyRuntimeType.getUnboxedType(fieldProtoType).get();
        return SoyExpression.forProto(protoRuntimeType, // cast needed for extensions
        field.checkedCast(protoRuntimeType.runtimeType()), renderContext);
    } else {
        // All other are special sanitized types
        ContentKind kind = ((SanitizedType) node.getType()).getContentKind();
        Descriptor messageType = descriptor.getMessageType();
        MethodRef methodRef = SAFE_PROTO_TO_ACCESSOR.get(messageType.getFullName());
        return SoyExpression.forSanitizedString(field.checkedCast(// cast needed for extensions
        methodRef.owner().type()).invoke(methodRef), kind);
    }
}

private void generateProtoFromDescriptor(Descriptor descriptor, Appendable out, HashMap<Descriptor, Boolean> descriptors) throws IOException {
    generateProtoFromDescriptor(descriptor, out, "", descriptors);
    // make sure all message type definitions are generated
    for (Descriptor d : new LinkedHashSet<Descriptor>(descriptors.keySet())) {
        if (!descriptors.get(d)) {
            generateProtoFromDescriptor(d, out, descriptors);
        }
    }
}

/**
   * Assigns all fields in {@link JsonNode} instance to a {@link Builder}.
   *
   * @param builder the builder to be populated
   * @param root    the JSON object
   * @return the original builder, populated with any fields that were discovered
   */
public static Builder toProto(final Builder builder, final JsonNode root) {
    Descriptor type = builder.getDescriptorForType();
    for (final FieldDescriptor fieldDesc : type.getFields()) {
        final String attrName = fieldDesc.getName();
        final JsonNode node = root.get(attrName);
        if (node == null) {
            continue;
        }
        if (node.isNull()) {
            continue;
        }
        if (fieldDesc.isRepeated()) {
            final Iterator<JsonNode> iter = node.getElements();
            while (iter.hasNext()) {
                builder.addRepeatedField(fieldDesc, toJavaObj(builder, fieldDesc, iter.next()));
            }
        } else {
            builder.setField(fieldDesc, toJavaObj(builder, fieldDesc, node));
        }
    }
    return builder;
}

/** Creates a human-readable string to help the user build a message to send to an end-point */
private static String renderDescriptor(Descriptor descriptor, String indent) {
    if (descriptor.getFields().size() == 0) {
        return indent + "<empty>";
    }
    List<String> fieldsAsStrings = descriptor.getFields().stream().map( field -> renderDescriptor(field, indent + "  ")).collect(Collectors.toList());
    return Joiner.on(System.lineSeparator()).join(fieldsAsStrings);
}

/**
     * Set the urn field for the store based on the name of the field.
     * @param fieldName to find.
     * @return builder
     * @throws IllegalStateException if you have not set the prototype first
     * @throws IllegalArgumentException if you pass a name not found.
     */
public Builder<M> setUrnField(String fieldName) {
    if (null == prototype) {
        throw new IllegalStateException("Can't choose field based on name " + "because no prototype has been set");
    }
    Descriptor descriptor = prototype.getDescriptorForType();
    for (FieldDescriptor field : descriptor.getFields()) {
        if (field.getName().equals(fieldName)) {
            result.urnField = field;
            return this;
        }
    }
    throw new IllegalArgumentException("Supplied field name " + fieldName + " did not match any descriptor field names");
}

/**
   * Recursively checks whether the specified class uses any Protocol Buffers fields that cannot
   * be deterministically encoded.
   *
   * @throws NonDeterministicException if the object cannot be encoded deterministically.
   */
static void verifyDeterministic(ProtoCoder<?> coder) throws NonDeterministicException {
    Class<? extends Message> message = coder.getMessageType();
    ExtensionRegistry registry = coder.getExtensionRegistry();
    Set<Descriptor> descriptors = getRecursiveDescriptorsForClass(message, registry);
    for (Descriptor d : descriptors) {
        for (FieldDescriptor fd : d.getFields()) {
            // be encoded deterministically.
            if (fd.isMapField()) {
                String reason = String.format("Protocol Buffers message %s transitively includes Map field %s (from file %s)." + " Maps cannot be deterministically encoded.", message.getName(), fd.getFullName(), fd.getFile().getFullName());
                throw new NonDeterministicException(coder, reason);
            }
        }
    }
}

/**
   * Returns the qualified type of the protobuf message, for example:
   * <ul>
   * <li>org.waveprotocol.pst.examples.Example1.Person =
   *     "org.waveprotocol.pst.examples.Example1.Person"</li>
   * </ul>
   *
   * @return the full type of the protocol buffer message
   */
public String getProtoType() {
    Deque<String> scopes = Lists.newLinkedList();
    for (Descriptor message = descriptor; message != null; message = message.getContainingType()) {
        scopes.push(message.getName());
    }
    scopes.push(descriptor.getFile().getOptions().getJavaOuterClassname());
    scopes.push(getPackageBase());
    return Joiner.on('.').join(scopes);
}

/**
	 * Returns a {@code Schema} that will serialize and parse {@link Message}
	 * corresponding to the given {@link Descriptor}.
	 *
	 * @param descriptor a descriptor of message.
	 * @see Message#getDescriptorForType()
	 */
public static NamedSchema of(Descriptor descriptor, String name) {
    Preconditions.checkNotNull(descriptor, "The descriptor should not be null");
    Preconditions.checkNotNull(name, "The name should not be null");
    Preconditions.checkArgument(!name.isEmpty(), "The name should not be empty");
    return new NamedSchema(descriptor, name, ImmutableSet.<String>of(), ImmutableMap.<String, String>of(), CaseFormat.LOWER_CAMEL, ImmutableMap.<String, String>of(), ImmutableMap.<String, FormatTransformer>of(), ImmutableMap.<String, FieldDescriptor>of(), ImmutableMap.<String, String>of(), ImmutableMap.<String, String>of(), ImmutableMap.<String, String>of(), false);
}

/**
   * Returns the qualified type of the protobuf message, for example:
   * <ul>
   * <li>org.waveprotocol.pst.examples.Example1.Person =
   *     "org.waveprotocol.pst.examples.Example1.Person"</li>
   * </ul>
   *
   * @return the full type of the protocol buffer message
   */
public String getProtoType() {
    Deque<String> scopes = Lists.newLinkedList();
    for (Descriptor message = descriptor; message != null; message = message.getContainingType()) {
        scopes.push(message.getName());
    }
    scopes.push(descriptor.getFile().getOptions().getJavaOuterClassname());
    scopes.push(getPackageBase());
    return Joiner.on('.').join(scopes);
}

final IgnoreCriteria toIgnoreCriteria(final Descriptor descriptor) {
    if (!validatedDescriptors.contains(descriptor)) {
        validate(descriptor);
        validatedDescriptors.add(descriptor);
    }
    final Cache cache = new Cache();
    return new IgnoreCriteria() {

        @Override
        public boolean isIgnored(Message message1, Message message2, @Nullable FieldDescriptor fieldDescriptor, List<SpecificField> fieldPath) {
            ImmutableList.Builder<Message> subMessages = ImmutableList.builder();
            if (fieldDescriptor != null) {
                addSubMessages(fieldDescriptor, message1, subMessages);
                addSubMessages(fieldDescriptor, message2, subMessages);
            }
            Context context = Context.create(descriptor, fieldPath, fieldDescriptor, subMessages);
            cache.clearMethodCaches();
            return !matchesFieldPath(context, cache) && matchStateAppliesForAllSubPaths(context, cache);
        }
    };
}

/**
   * Returns the qualified type of the protobuf message, for example:
   * <ul>
   * <li>org.waveprotocol.pst.examples.Example1.Person =
   *     "org.waveprotocol.pst.examples.Example1.Person"</li>
   * </ul>
   *
   * @return the full type of the protocol buffer message
   */
public String getProtoType() {
    Deque<String> scopes = Lists.newLinkedList();
    for (Descriptor message = descriptor; message != null; message = message.getContainingType()) {
        scopes.push(message.getName());
    }
    scopes.push(descriptor.getFile().getOptions().getJavaOuterClassname());
    scopes.push(getPackageBase());
    return Joiner.on('.').join(scopes);
}

/**
   * Returns the qualified type of the protobuf message, for example:
   * <ul>
   * <li>org.waveprotocol.pst.examples.Example1.Person =
   *     "org.waveprotocol.pst.examples.Example1.Person"</li>
   * </ul>
   *
   * @return the full type of the protocol buffer message
   */
public String getProtoType() {
    Deque<String> scopes = Lists.newLinkedList();
    for (Descriptor message = descriptor; message != null; message = message.getContainingType()) {
        scopes.push(message.getName());
    }
    scopes.push(descriptor.getFile().getOptions().getJavaOuterClassname());
    scopes.push(getPackageBase());
    return Joiner.on('.').join(scopes);
}

/**
   * Returns the qualified type of the protobuf message, for example:
   * <ul>
   * <li>org.waveprotocol.pst.examples.Example1.Person =
   *     "org.waveprotocol.pst.examples.Example1.Person"</li>
   * </ul>
   *
   * @return the full type of the protocol buffer message
   */
public String getProtoType() {
    Deque<String> scopes = Lists.newLinkedList();
    for (Descriptor message = descriptor; message != null; message = message.getContainingType()) {
        scopes.push(message.getName());
    }
    scopes.push(descriptor.getFile().getOptions().getJavaOuterClassname());
    scopes.push(getPackageBase());
    return Joiner.on('.').join(scopes);
}

private void registerDesc(String name, InputStream in) {
    try {
        FileDescriptorSet descriptorSet = FileDescriptorSet.parseFrom(in);
        for (FileDescriptorProto fdp : descriptorSet.getFileList()) {
            FileDescriptor fd = FileDescriptor.buildFrom(fdp, new FileDescriptor[] {});
            for (Descriptor desc : fd.getMessageTypes()) {
                FieldDescriptor fdesc = desc.findFieldByName("protoType");
                if (fdesc == null) {
                    throw new IllegalArgumentException(name + ".proto file must define protoType field " + "with unqiue number that identify proto type");
                }
                String packageName = fdp.getOptions().getJavaPackage();
                if (Strings.isNullOrEmpty(packageName)) {
                    throw new IllegalArgumentException(name + ".proto file must define java_package");
                }
                String simpleClassName = fdp.getOptions().getJavaOuterClassname();
                if (Strings.isNullOrEmpty(simpleClassName)) {
                    throw new IllegalArgumentException(name + " .proto file must define java_outer_classname");
                }
                String className = packageName + "." + simpleClassName + "$" + desc.getName();
                Class<?> cls = Thread.currentThread().getContextClassLoader().loadClass(className);
                protoToNum.put(desc.getFullName(), fdesc.getNumber());
                numToMethod.put(fdesc.getNumber(), cls.getMethod("parseFrom", byte[].class));
                log.debug("Registered protobuf resource {}.", name);
            }
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

/**
   * Internal helper to return a modifiable map containing all the fields.
   * The returned Map is modifialbe so that the caller can add additional
   * extension fields to implement {@link #getAllFields()}.
   *
   * @param getBytesForString whether to generate ByteString for string fields
   */
private Map<FieldDescriptor, Object> getAllFieldsMutable(boolean getBytesForString) {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    final List<FieldDescriptor> fields = descriptor.getFields();
    for (int i = 0; i < fields.size(); i++) {
        FieldDescriptor field = fields.get(i);
        final OneofDescriptor oneofDescriptor = field.getContainingOneof();
        /*
       * If the field is part of a Oneof, then at maximum one field in the Oneof is set
       * and it is not repeated. There is no need to iterate through the others.
       */
        if (oneofDescriptor != null) {
            // Skip other fields in the Oneof we know are not set
            i += oneofDescriptor.getFieldCount() - 1;
            if (!hasOneof(oneofDescriptor)) {
                // If no field is set in the Oneof, skip all the fields in the Oneof
                continue;
            }
            // Get the pointer to the only field which is set in the Oneof
            field = getOneofFieldDescriptor(oneofDescriptor);
        } else {
            // If we are not in a Oneof, we need to check if the field is set and if it is repeated
            if (field.isRepeated()) {
                final List<?> value = (List<?>) getField(field);
                if (!value.isEmpty()) {
                    result.put(field, value);
                }
                continue;
            }
            if (!hasField(field)) {
                continue;
            }
        }
        // Add the field to the map
        if (getBytesForString && field.getJavaType() == FieldDescriptor.JavaType.STRING) {
            result.put(field, getFieldRaw(field));
        } else {
            result.put(field, getField(field));
        }
    }
    return result;
}

@SuppressWarnings("unchecked")
private Message recursiveConvert(Tuple input, Builder<?> builder) throws ExecException {
    Descriptor descr = builder.getDescriptorForType();
    if (descr.getFields().size() != input.size()) {
        throw new ExecException("Input tuple size doesn't match protobuf schema size");
    }
    for (FieldDescriptor protobufField : descr.getFields()) {
        Object tupleField = input.get(protobufField.getIndex());
        Type protobufType = protobufField.getType();
        if (tupleField == null) {
            if (protobufField.isRequired()) {
                throw new ExecException("There is no data for required field " + protobufField.getName());
            }
            continue;
        }
        if (protobufField.isRepeated()) {
            //repeated field
            if (!(tupleField instanceof DataBag)) {
                throw new ExecException("Data for repeated field must be in a DataBag, instead of" + tupleField.getClass().getName());
            }
            for (Tuple tpl : ((DataBag) tupleField)) {
                if (!protobufToJavaTypes.containsKey(protobufType)) {
                    throw new ExecException("Type not supported: " + protobufType);
                }
                if (protobufType.equals(Type.MESSAGE)) {
                    Builder<?> subbuilder = DynamicMessage.newBuilder(protobufField.getMessageType());
                    builder.addRepeatedField(protobufField, recursiveConvert(tpl, subbuilder));
                } else {
                    //scalar type
                    Object tplObj = tpl.get(0);
                    if (!protobufToJavaTypes.get(protobufType).isAssignableFrom(tplObj.getClass())) {
                        throw new ExecException("Data type not compatible: " + protobufType + ", " + tplObj.getClass().getName());
                    }
                    if (protobufType.equals(Type.ENUM)) {
                        EnumDescriptor enumDescr = protobufField.getEnumType();
                        EnumValueDescriptor enumValueDescr = enumDescr.findValueByName((String) tplObj);
                        builder.addRepeatedField(protobufField, enumValueDescr);
                    } else {
                        builder.addRepeatedField(protobufField, tplObj);
                    }
                }
            }
        } else {
            //not repeated
            if (!protobufToJavaTypes.get(protobufType).isAssignableFrom(tupleField.getClass())) {
                throw new ExecException("Data type not compatible: " + protobufType + ", " + tupleField.getClass().getName());
            }
            if (protobufType.equals(Type.MESSAGE)) {
                Builder<?> subbuilder = DynamicMessage.newBuilder(protobufField.getMessageType());
                builder.setField(protobufField, recursiveConvert((Tuple) tupleField, subbuilder));
            } else if (protobufType.equals(Type.ENUM)) {
                EnumDescriptor enumDescr = protobufField.getEnumType();
                EnumValueDescriptor enumValueDescr = enumDescr.findValueByName((String) tupleField);
                builder.setField(protobufField, enumValueDescr);
            } else {
                //scalar type
                builder.setField(protobufField, tupleField);
            }
        }
    }
    return builder.build();
}

/**
   * Internal helper to return a modifiable map containing all the fields.
   * The returned Map is modifialbe so that the caller can add additional
   * extension fields to implement {@link #getAllFields()}.
   *
   * @param getBytesForString whether to generate ByteString for string fields
   */
private Map<FieldDescriptor, Object> getAllFieldsMutable(boolean getBytesForString) {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    final List<FieldDescriptor> fields = descriptor.getFields();
    for (int i = 0; i < fields.size(); i++) {
        FieldDescriptor field = fields.get(i);
        final OneofDescriptor oneofDescriptor = field.getContainingOneof();
        /*
       * If the field is part of a Oneof, then at maximum one field in the Oneof is set
       * and it is not repeated. There is no need to iterate through the others.
       */
        if (oneofDescriptor != null) {
            // Skip other fields in the Oneof we know are not set
            i += oneofDescriptor.getFieldCount() - 1;
            if (!hasOneof(oneofDescriptor)) {
                // If no field is set in the Oneof, skip all the fields in the Oneof
                continue;
            }
            // Get the pointer to the only field which is set in the Oneof
            field = getOneofFieldDescriptor(oneofDescriptor);
        } else {
            // If we are not in a Oneof, we need to check if the field is set and if it is repeated
            if (field.isRepeated()) {
                final List<?> value = (List<?>) getField(field);
                if (!value.isEmpty()) {
                    result.put(field, value);
                }
                continue;
            }
            if (!hasField(field)) {
                continue;
            }
        }
        // Add the field to the map
        if (getBytesForString && field.getJavaType() == FieldDescriptor.JavaType.STRING) {
            result.put(field, getFieldRaw(field));
        } else {
            result.put(field, getField(field));
        }
    }
    return result;
}

public void testFindFieldByNumber() throws Exception {
    Descriptor descriptor = TypicalData.Builder.getDescriptor();
    Collection<FieldDescriptor> fields = descriptor.getFields();
    for (FieldDescriptor field : fields) {
        FieldDescriptor.Type type = field.getType();
        int fieldId = field.getNumber();
        switch(fieldId) {
            case 1:
                assertEquals(Type.INT32, type);
                break;
            case 2:
                assertEquals(Type.BYTES, type);
                break;
            case 3:
                assertEquals(Type.ENUM, type);
                break;
        }
        FieldDescriptor result = descriptor.findFieldByNumber(fieldId);
        assertEquals(field.getNumber(), result.getNumber());
        assertEquals(field.getName(), result.getName());
    }
}

@Override
public GeneratedMessage deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    JsonObject jsonObject = json.getAsJsonObject();
    @SuppressWarnings("unchecked") Class<? extends GeneratedMessage> protoClass = (Class<? extends GeneratedMessage>) typeOfT;
    try {
        // Invoke the ProtoClass.newBuilder() method
        Object protoBuilder = getCachedMethod(protoClass, "newBuilder").invoke(null);
        Class<?> builderClass = protoBuilder.getClass();
        Descriptor protoDescriptor = (Descriptor) getCachedMethod(protoClass, "getDescriptor").invoke(null);
        // Call setters on all of the available fields
        for (FieldDescriptor fieldDescriptor : protoDescriptor.getFields()) {
            String name = fieldDescriptor.getName();
            if (jsonObject.has(name)) {
                JsonElement jsonElement = jsonObject.get(name);
                String fieldName = camelCaseField(name + "_");
                Field field = protoClass.getDeclaredField(fieldName);
                Type fieldType = field.getGenericType();
                if (fieldType.equals(Object.class)) {
                    // TODO(drt24): this is very evil.
                    // In NigoriMessages protobuf strings are stored in a field of type Object so that they
                    // can use either String of ByteString as the implementation, however this causes a type
                    // error when calling the set method. So we make a (potentially false) assumption that
                    // all fields of type Object in NigoriMessages have that type because they actually
                    // should have Strings set.
                    fieldType = String.class;
                }
                Object fieldValue = context.deserialize(jsonElement, fieldType);
                if (fieldDescriptor.getJavaType() == FieldDescriptor.JavaType.ENUM) {
                    Method methodVD = getCachedMethod(fieldValue.getClass(), "getValueDescriptor");
                    fieldValue = methodVD.invoke(fieldValue);
                }
                Method method = getCachedMethod(builderClass, "setField", FieldDescriptor.class, Object.class);
                method.invoke(protoBuilder, fieldDescriptor, fieldValue);
            }
        }
        // Invoke the build method to return the final proto
        return (GeneratedMessage) getCachedMethod(builderClass, "build").invoke(protoBuilder);
    } catch (SecurityException e) {
        throw new JsonParseException(e);
    } catch (NoSuchMethodException e) {
        throw new JsonParseException(e);
    } catch (IllegalArgumentException e) {
        throw new JsonParseException(e);
    } catch (IllegalAccessException e) {
        throw new JsonParseException(e);
    } catch (InvocationTargetException e) {
        throw new JsonParseException(e);
    } catch (NoSuchFieldException e) {
        throw new JsonParseException(e);
    }
}

private static Builder parseObject(Builder builder, JsonParser parser, ExtensionRegistry extnRegistry, Map<Feature, Object> featureMap) throws IOException {
    if (!JsonToken.START_OBJECT.equals(parser.getCurrentToken())) {
        throw new ParseException("Parser should point to a START_OBJECT event");
    }
    Descriptor descriptor = builder.getDescriptorForType();
    while (!parser.nextToken().equals(JsonToken.END_OBJECT)) {
        JsonToken currToken = parser.getCurrentToken();
        assert (currToken.equals(JsonToken.FIELD_NAME));
        String fieldName = parser.getCurrentName();
        fieldName = AbstractCodec.stripFieldName(fieldName, featureMap);
        fieldName = AbstractCodec.substituteFieldNameForReading(fieldName, featureMap);
        FieldDescriptor field = null;
        if (AbstractCodec.isExtensionFieldName(fieldName, featureMap)) {
            fieldName = JsonCodec.parseExtensionFieldName(fieldName, featureMap);
            ExtensionInfo extnInfo = extnRegistry.findExtensionByName(fieldName);
            if (extnInfo == null) {
                // Move, we are skipping this field
                parser.nextToken();
                if (JsonToken.START_ARRAY.equals(parser.getCurrentToken()) || JsonToken.START_OBJECT.equals(parser.getCurrentToken())) {
                    parser.skipChildren();
                }
                continue;
            }
            field = extnInfo.descriptor;
        } else if (AbstractCodec.isFieldNameUnknownField(fieldName, featureMap)) {
            parser.nextToken();
            if (AbstractCodec.supportUnknownFields(featureMap)) {
                String unknownFieldsText = parser.getText();
                AbstractCodec.mergeUnknownFieldsFromString(builder, extnRegistry, unknownFieldsText);
            }
            continue;
        } else {
            field = descriptor.findFieldByName(fieldName);
        }
        if (field == null) {
            throw new ParseException("Field cannot be null, processing fieldName " + fieldName);
        }
        parser.nextToken();
        setFields(builder, field, parser, extnRegistry, featureMap);
    }
    return builder;
}

private void addMessageType(Descriptor msgType, String scope, Set<String> msgDupes, Set<String> enumDupes) {
    String msgTypeNameFull = msgType.getFullName();
    String msgTypeNameShort = (scope == null ? msgType.getName() : scope + "." + msgType.getName());
    if (mMsgDescriptorMapFull.containsKey(msgTypeNameFull))
        throw new IllegalArgumentException("duplicate name: " + msgTypeNameFull);
    if (mMsgDescriptorMapShort.containsKey(msgTypeNameShort))
        msgDupes.add(msgTypeNameShort);
    mMsgDescriptorMapFull.put(msgTypeNameFull, msgType);
    mMsgDescriptorMapShort.put(msgTypeNameShort, msgType);
    for (Descriptor nestedType : msgType.getNestedTypes()) addMessageType(nestedType, msgTypeNameShort, msgDupes, enumDupes);
    for (EnumDescriptor enumType : msgType.getEnumTypes()) addEnumType(enumType, msgTypeNameShort, enumDupes);
}

public static ProtobufRowDataConverter forGroup(Group group, FileDescriptor fileDescriptor) {
    // Find the group message.
    Descriptor groupMessage = null;
    List<Descriptor> messages = fileDescriptor.getMessageTypes();
    for (int i = messages.size() - 1; i >= 0; i--) {
        Descriptor message = messages.get(i);
        if (message.getOptions().getExtension(TableOptions.fdbsql).getIsGroup()) {
            groupMessage = message;
            break;
        }
    }
    if (groupMessage != null) {
        return new GroupConverter(group, groupMessage);
    } else {
        assert (messages.size() == 1 && group.getRoot().getChildJoins().isEmpty());
        return new TableConverter(group.getRoot(), messages.get(0));
    }
}

/**
   * Internal helper to return a modifiable map containing all the fields.
   * The returned Map is modifialbe so that the caller can add additional
   * extension fields to implement {@link #getAllFields()}.
   *
   * @param getBytesForString whether to generate ByteString for string fields
   */
private Map<FieldDescriptor, Object> getAllFieldsMutable(boolean getBytesForString) {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    final List<FieldDescriptor> fields = descriptor.getFields();
    for (int i = 0; i < fields.size(); i++) {
        FieldDescriptor field = fields.get(i);
        final OneofDescriptor oneofDescriptor = field.getContainingOneof();
        /*
       * If the field is part of a Oneof, then at maximum one field in the Oneof is set
       * and it is not repeated. There is no need to iterate through the others.
       */
        if (oneofDescriptor != null) {
            // Skip other fields in the Oneof we know are not set
            i += oneofDescriptor.getFieldCount() - 1;
            if (!hasOneof(oneofDescriptor)) {
                // If no field is set in the Oneof, skip all the fields in the Oneof
                continue;
            }
            // Get the pointer to the only field which is set in the Oneof
            field = getOneofFieldDescriptor(oneofDescriptor);
        } else {
            // If we are not in a Oneof, we need to check if the field is set and if it is repeated
            if (field.isRepeated()) {
                final List<?> value = (List<?>) getField(field);
                if (!value.isEmpty()) {
                    result.put(field, value);
                }
                continue;
            }
            if (!hasField(field)) {
                continue;
            }
        }
        // Add the field to the map
        if (getBytesForString && field.getJavaType() == FieldDescriptor.JavaType.STRING) {
            result.put(field, getFieldRaw(field));
        } else {
            result.put(field, getField(field));
        }
    }
    return result;
}

@Override
protected Object getRecordState(Object r, Schema s) {
    Descriptor d = ((MessageOrBuilder) r).getDescriptorForType();
    FieldDescriptor[] fields = fieldCache.get(d);
    if (fields == null) {
        // cache miss
        fields = new FieldDescriptor[s.getFields().size()];
        for (Field f : s.getFields()) fields[f.pos()] = d.findFieldByName(f.name());
        // update cache
        fieldCache.put(d, fields);
    }
    return fields;
}

// TODO(b/35724557): share this list with other code analyzing types for immutability
// TODO(cushon): generate this at build-time to get type-safety without added compile-time deps
private static ImmutableMap<String, ImmutableAnnotationInfo> getBootstrapClasses() {
    return new Builder().addAll(Primitives.allPrimitiveTypes()).addAll(Primitives.allWrapperTypes()).add("com.google.protobuf.ByteString").add("com.google.protobuf.Descriptors$Descriptor").add("com.google.protobuf.Descriptors$EnumDescriptor").add("com.google.protobuf.Descriptors$EnumValueDescriptor").add("com.google.protobuf.Descriptors$FieldDescriptor").add("com.google.protobuf.Descriptors$FileDescriptor").add("com.google.protobuf.Descriptors$ServiceDescriptor").add("com.google.protobuf.Extension").add("com.google.protobuf.ExtensionRegistry$ExtensionInfo").add("com.google.re2j.Pattern").add(com.google.common.base.CharMatcher.class).add(com.google.common.base.Converter.class).add(com.google.common.base.Joiner.class).add(com.google.common.base.Optional.class, "T").add(com.google.common.base.Splitter.class).add(com.google.common.collect.ImmutableBiMap.class, "K", "V").add(com.google.common.collect.ImmutableCollection.class, "E").add(com.google.common.collect.ImmutableList.class, "E").add(com.google.common.collect.ImmutableListMultimap.class, "K", "V").add(com.google.common.collect.ImmutableMap.class, "K", "V").add(com.google.common.collect.ImmutableMultimap.class, "K", "V").add(com.google.common.collect.ImmutableMultiset.class, "E").add(com.google.common.collect.ImmutableRangeMap.class, "K", "V").add(com.google.common.collect.ImmutableRangeSet.class, "C").add(com.google.common.collect.ImmutableSet.class, "E").add(com.google.common.collect.ImmutableSetMultimap.class, "K", "V").add(com.google.common.collect.ImmutableSortedMap.class, "K", "V").add(com.google.common.collect.ImmutableSortedMultiset.class, "E").add(com.google.common.collect.ImmutableSortedSet.class, "E").add(com.google.common.collect.ImmutableTable.class, "R", "C", "V").add(com.google.common.collect.Range.class, "C").add(com.google.common.graph.ImmutableGraph.class, "N").add(com.google.common.graph.ImmutableNetwork.class, "N", "E").add(com.google.common.graph.ImmutableValueGraph.class, "N", "V").add(com.google.common.hash.HashCode.class).add(com.google.common.io.BaseEncoding.class).add(com.google.common.net.MediaType.class).add(com.google.common.primitives.UnsignedLong.class).add(java.lang.Class.class).add(java.lang.String.class).add(java.lang.annotation.Annotation.class).add(java.math.BigDecimal.class).add(java.math.BigInteger.class).add(java.net.InetAddress.class).add(java.net.URI.class).add(java.util.Locale.class).add(java.util.regex.Pattern.class).add("android.net.Uri").add("java.util.Optional", "T").add("java.time.Duration").add("java.time.Instant").add("java.time.LocalDate").add("java.time.LocalDateTime").add("java.time.LocalTime").add("java.time.MonthDay").add("java.time.OffsetDateTime").add("java.time.OffsetTime").add("java.time.Period").add("java.time.Year").add("java.time.YearMonth").add("java.time.ZoneId").add("java.time.ZoneOffset").add("java.time.ZonedDateTime").add("java.time.chrono.AbstractChronology").add("java.time.chrono.ChronoLocalDate").add("java.time.chrono.ChronoLocalDateTime", "D").add("java.time.chrono.ChronoPeriod").add("java.time.chrono.ChronoZonedDateTime", "D").add("java.time.chrono.Chronology").add("java.time.chrono.Era").add("java.time.chrono.HijrahChronology").add("java.time.chrono.HijrahDate").add("java.time.chrono.IsoChronology").add("java.time.chrono.JapaneseChronology").add("java.time.chrono.JapaneseDate").add("java.time.chrono.JapaneseEra").add("java.time.chrono.MinguoChronology").add("java.time.chrono.MinguoDate").add("java.time.chrono.ThaiBuddhistChronology").add("java.time.chrono.ThaiBuddhistDate").add("java.time.format.DateTimeFormatter").add("java.time.format.DecimalStyle").add("java.time.temporal.TemporalField").add("java.time.temporal.TemporalUnit").add("java.time.temporal.ValueRange").add("java.time.temporal.WeekFields").add("java.time.zone.ZoneOffsetTransition").add("java.time.zone.ZoneOffsetTransitionRule").add("java.time.zone.ZoneRules").add("java.time.zone.ZoneRulesProvider").add("org.joda.time.DateTime").add("org.joda.time.DateTimeZone").add("org.joda.time.Duration").add("org.joda.time.Instant").add("org.joda.time.LocalDate").add("org.joda.time.LocalDateTime").add("org.joda.time.Period").add("org.joda.time.format.DateTimeFormatter").build();
}

/**
   * Return a Name made from the component array in a Protobuf message object,
   * assuming that it was defined with "repeated bytes". For example:
   * message Name {
   *   repeated bytes component = 8;
   * }
   * (See the TestEncodeDecodeFibEntry example.)
   * @param nameMessage The Protobuf message object containing the "repeated
   * bytes" component array.
   * @return A new name.
   */
public static Name toName(Message nameMessage) {
    Name name = new Name();
    Descriptor descriptor = nameMessage.getDescriptorForType();
    FieldDescriptor field = (FieldDescriptor) descriptor.getFields().get(0);
    for (int i = 0; i < nameMessage.getRepeatedFieldCount(field); ++i) name.append(new Blob(((ByteString) nameMessage.getRepeatedField(field, i)).asReadOnlyByteBuffer(), true));
    return name;
}

public static Descriptor getMessageDescriptor(Class<? extends Message> protoClass) {
    try {
        Method getDescriptor = protoClass.getMethod("getDescriptor", new Class[] {});
        return (Descriptor) getDescriptor.invoke(null, new Object[] {});
    } catch (NoSuchMethodException e) {
        LOG.error("Could not find method getDescriptor in class " + protoClass, e);
        throw new IllegalArgumentException(e);
    } catch (IllegalAccessException e) {
        LOG.error("Could not access method getDescriptor in class " + protoClass, e);
        throw new IllegalArgumentException(e);
    } catch (InvocationTargetException e) {
        LOG.error("Error invoking method getDescriptor in class " + protoClass, e);
    }
    return null;
}

private static List<Map<String, String>> configToRecords(ZepConfig config) throws ZepException {
    final List<Map<String, String>> records = new ArrayList<Map<String, String>>();
    final Descriptor descriptor = config.getDescriptorForType();
    for (FieldDescriptor field : descriptor.getFields()) {
        final Object value = config.getField(field);
        if (value != null) {
            Map<String, String> record = new HashMap<String, String>(2);
            record.put(COLUMN_CONFIG_NAME, field.getName());
            record.put(COLUMN_CONFIG_VALUE, valueToString(field, value));
            records.add(record);
        }
    }
    return records;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private void processFileDescriptor(FileDescriptor fd) {
    String fdName = fd.getName();
    checkState(!fileDescriptorsByName.containsKey(fdName), "File name already used: %s", fdName);
    fileDescriptorsByName.put(fdName, fd);
    for (ServiceDescriptor service : fd.getServices()) {
        processService(service, fd);
    }
    for (Descriptor type : fd.getMessageTypes()) {
        processType(type, fd);
    }
    for (FieldDescriptor extension : fd.getExtensions()) {
        processExtension(extension, fd);
    }
}

/**
   * Parse a single field from {@code tokenizer} and merge it into
   * {@code builder}.
   */
private static void mergeField(final Tokenizer tokenizer, final ExtensionRegistry extensionRegistry, final Message.Builder builder) throws ParseException {
    FieldDescriptor field;
    final Descriptor type = builder.getDescriptorForType();
    ExtensionRegistry.ExtensionInfo extension = null;
    if (tokenizer.tryConsume("[")) {
        // An extension.
        final StringBuilder name = new StringBuilder(tokenizer.consumeIdentifier());
        while (tokenizer.tryConsume(".")) {
            name.append('.');
            name.append(tokenizer.consumeIdentifier());
        }
        extension = extensionRegistry.findExtensionByName(name.toString());
        if (extension == null) {
            throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" not found in the ExtensionRegistry.");
        } else if (extension.descriptor.getContainingType() != type) {
            throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + type.getFullName() + "\".");
        }
        tokenizer.consume("]");
        field = extension.descriptor;
    } else {
        final String name = tokenizer.consumeIdentifier();
        field = type.findFieldByName(name);
        // names.
        if (field == null) {
            // Explicitly specify US locale so that this code does not break when
            // executing in Turkey.
            final String lowerName = name.toLowerCase(Locale.US);
            field = type.findFieldByName(lowerName);
            // If the case-insensitive match worked but the field is NOT a group,
            if (field != null && field.getType() != FieldDescriptor.Type.GROUP) {
                field = null;
            }
        }
        // Again, special-case group names as described above.
        if (field != null && field.getType() == FieldDescriptor.Type.GROUP && !field.getMessageType().getName().equals(name)) {
            field = null;
        }
        if (field == null) {
            throw tokenizer.parseExceptionPreviousToken("Message type \"" + type.getFullName() + "\" has no field named \"" + name + "\".");
        }
    }
    Object value = null;
    if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
        // optional
        tokenizer.tryConsume(":");
        final String endToken;
        if (tokenizer.tryConsume("<")) {
            endToken = ">";
        } else {
            tokenizer.consume("{");
            endToken = "}";
        }
        final Message.Builder subBuilder;
        if (extension == null) {
            subBuilder = builder.newBuilderForField(field);
        } else {
            subBuilder = extension.defaultInstance.newBuilderForType();
        }
        while (!tokenizer.tryConsume(endToken)) {
            if (tokenizer.atEnd()) {
                throw tokenizer.parseException("Expected \"" + endToken + "\".");
            }
            mergeField(tokenizer, extensionRegistry, subBuilder);
        }
        value = subBuilder.build();
    } else {
        tokenizer.consume(":");
        switch(field.getType()) {
            case INT32:
            case SINT32:
            case SFIXED32:
                value = tokenizer.consumeInt32();
                break;
            case INT64:
            case SINT64:
            case SFIXED64:
                value = tokenizer.consumeInt64();
                break;
            case UINT32:
            case FIXED32:
                value = tokenizer.consumeUInt32();
                break;
            case UINT64:
            case FIXED64:
                value = tokenizer.consumeUInt64();
                break;
            case FLOAT:
                value = tokenizer.consumeFloat();
                break;
            case DOUBLE:
                value = tokenizer.consumeDouble();
                break;
            case BOOL:
                value = tokenizer.consumeBoolean();
                break;
            case STRING:
                value = tokenizer.consumeString();
                break;
            case BYTES:
                value = tokenizer.consumeByteString();
                break;
            case ENUM:
                final EnumDescriptor enumType = field.getEnumType();
                if (tokenizer.lookingAtInteger()) {
                    final int number = tokenizer.consumeInt32();
                    value = enumType.findValueByNumber(number);
                    if (value == null) {
                        throw tokenizer.parseExceptionPreviousToken("Enum type \"" + enumType.getFullName() + "\" has no value with number " + number + '.');
                    }
                } else {
                    final String id = tokenizer.consumeIdentifier();
                    value = enumType.findValueByName(id);
                    if (value == null) {
                        throw tokenizer.parseExceptionPreviousToken("Enum type \"" + enumType.getFullName() + "\" has no value named \"" + id + "\".");
                    }
                }
                break;
            case MESSAGE:
            case GROUP:
                throw new RuntimeException("Can't get here.");
        }
    }
    if (field.isRepeated()) {
        builder.addRepeatedField(field, value);
    } else {
        builder.setField(field, value);
    }
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

/**
   * Parse a single field from {@code tokenizer} and merge it into
   * {@code builder}.
   */
private static void mergeField(final Tokenizer tokenizer, final ExtensionRegistry extensionRegistry, final Message.Builder builder) throws ParseException {
    FieldDescriptor field;
    final Descriptor type = builder.getDescriptorForType();
    ExtensionRegistry.ExtensionInfo extension = null;
    if (tokenizer.tryConsume("[")) {
        // An extension.
        final StringBuilder name = new StringBuilder(tokenizer.consumeIdentifier());
        while (tokenizer.tryConsume(".")) {
            name.append('.');
            name.append(tokenizer.consumeIdentifier());
        }
        extension = extensionRegistry.findExtensionByName(name.toString());
        if (extension == null) {
            throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" not found in the ExtensionRegistry.");
        } else if (extension.descriptor.getContainingType() != type) {
            throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + type.getFullName() + "\".");
        }
        tokenizer.consume("]");
        field = extension.descriptor;
    } else {
        final String name = tokenizer.consumeIdentifier();
        field = type.findFieldByName(name);
        // names.
        if (field == null) {
            // Explicitly specify US locale so that this code does not break when
            // executing in Turkey.
            final String lowerName = name.toLowerCase(Locale.US);
            field = type.findFieldByName(lowerName);
            // If the case-insensitive match worked but the field is NOT a group,
            if (field != null && field.getType() != FieldDescriptor.Type.GROUP) {
                field = null;
            }
        }
        // Again, special-case group names as described above.
        if (field != null && field.getType() == FieldDescriptor.Type.GROUP && !field.getMessageType().getName().equals(name)) {
            field = null;
        }
        if (field == null) {
            throw tokenizer.parseExceptionPreviousToken("Message type \"" + type.getFullName() + "\" has no field named \"" + name + "\".");
        }
    }
    Object value = null;
    if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
        // optional
        tokenizer.tryConsume(":");
        final String endToken;
        if (tokenizer.tryConsume("<")) {
            endToken = ">";
        } else {
            tokenizer.consume("{");
            endToken = "}";
        }
        final Message.Builder subBuilder;
        if (extension == null) {
            subBuilder = builder.newBuilderForField(field);
        } else {
            subBuilder = extension.defaultInstance.newBuilderForType();
        }
        while (!tokenizer.tryConsume(endToken)) {
            if (tokenizer.atEnd()) {
                throw tokenizer.parseException("Expected \"" + endToken + "\".");
            }
            mergeField(tokenizer, extensionRegistry, subBuilder);
        }
        value = subBuilder.build();
    } else {
        tokenizer.consume(":");
        switch(field.getType()) {
            case INT32:
            case SINT32:
            case SFIXED32:
                value = tokenizer.consumeInt32();
                break;
            case INT64:
            case SINT64:
            case SFIXED64:
                value = tokenizer.consumeInt64();
                break;
            case UINT32:
            case FIXED32:
                value = tokenizer.consumeUInt32();
                break;
            case UINT64:
            case FIXED64:
                value = tokenizer.consumeUInt64();
                break;
            case FLOAT:
                value = tokenizer.consumeFloat();
                break;
            case DOUBLE:
                value = tokenizer.consumeDouble();
                break;
            case BOOL:
                value = tokenizer.consumeBoolean();
                break;
            case STRING:
                value = tokenizer.consumeString();
                break;
            case BYTES:
                value = tokenizer.consumeByteString();
                break;
            case ENUM:
                final EnumDescriptor enumType = field.getEnumType();
                if (tokenizer.lookingAtInteger()) {
                    final int number = tokenizer.consumeInt32();
                    value = enumType.findValueByNumber(number);
                    if (value == null) {
                        throw tokenizer.parseExceptionPreviousToken("Enum type \"" + enumType.getFullName() + "\" has no value with number " + number + '.');
                    }
                } else {
                    final String id = tokenizer.consumeIdentifier();
                    value = enumType.findValueByName(id);
                    if (value == null) {
                        throw tokenizer.parseExceptionPreviousToken("Enum type \"" + enumType.getFullName() + "\" has no value named \"" + id + "\".");
                    }
                }
                break;
            case MESSAGE:
            case GROUP:
                throw new RuntimeException("Can't get here.");
        }
    }
    if (field.isRepeated()) {
        builder.addRepeatedField(field, value);
    } else {
        builder.setField(field, value);
    }
}

private Map<FieldDescriptor, Object> getAllFieldsMutable() {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    for (final FieldDescriptor field : descriptor.getFields()) {
        if (field.isRepeated()) {
            final List<?> value = (List<?>) getField(field);
            if (!value.isEmpty()) {
                result.put(field, value);
            }
        } else {
            if (hasField(field)) {
                result.put(field, getField(field));
            }
        }
    }
    return result;
}

/**
     * Parse a single field from {@code tokenizer} and merge it into
     * {@code builder}.
     */
private void mergeField(final Tokenizer tokenizer, final ExtensionRegistry extensionRegistry, final MessageReflection.MergeTarget target) throws ParseException {
    FieldDescriptor field = null;
    final Descriptor type = target.getDescriptorForType();
    ExtensionRegistry.ExtensionInfo extension = null;
    if (tokenizer.tryConsume("[")) {
        // An extension.
        final StringBuilder name = new StringBuilder(tokenizer.consumeIdentifier());
        while (tokenizer.tryConsume(".")) {
            name.append('.');
            name.append(tokenizer.consumeIdentifier());
        }
        extension = target.findExtensionByName(extensionRegistry, name.toString());
        if (extension == null) {
            if (!allowUnknownFields) {
                throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" not found in the ExtensionRegistry.");
            } else {
                logger.warning("Extension \"" + name + "\" not found in the ExtensionRegistry.");
            }
        } else {
            if (extension.descriptor.getContainingType() != type) {
                throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + type.getFullName() + "\".");
            }
            field = extension.descriptor;
        }
        tokenizer.consume("]");
    } else {
        final String name = tokenizer.consumeIdentifier();
        field = type.findFieldByName(name);
        // names.
        if (field == null) {
            // Explicitly specify US locale so that this code does not break when
            // executing in Turkey.
            final String lowerName = name.toLowerCase(Locale.US);
            field = type.findFieldByName(lowerName);
            // If the case-insensitive match worked but the field is NOT a group,
            if (field != null && field.getType() != FieldDescriptor.Type.GROUP) {
                field = null;
            }
        }
        // Again, special-case group names as described above.
        if (field != null && field.getType() == FieldDescriptor.Type.GROUP && !field.getMessageType().getName().equals(name)) {
            field = null;
        }
        if (field == null) {
            if (!allowUnknownFields) {
                throw tokenizer.parseExceptionPreviousToken("Message type \"" + type.getFullName() + "\" has no field named \"" + name + "\".");
            } else {
                logger.warning("Message type \"" + type.getFullName() + "\" has no field named \"" + name + "\".");
            }
        }
    }
    // Skips unknown fields.
    if (field == null) {
        // to be a message or the input is ill-formed.
        if (tokenizer.tryConsume(":") && !tokenizer.lookingAt("{") && !tokenizer.lookingAt("<")) {
            skipFieldValue(tokenizer);
        } else {
            skipFieldMessage(tokenizer);
        }
        return;
    }
    // Handle potential ':'.
    if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
        // optional
        tokenizer.tryConsume(":");
    } else {
        // required
        tokenizer.consume(":");
    }
    // Ex."foo: [1, 2, 3]"
    if (field.isRepeated() && tokenizer.tryConsume("[")) {
        while (true) {
            consumeFieldValue(tokenizer, extensionRegistry, target, field, extension);
            if (tokenizer.tryConsume("]")) {
                // End of list.
                break;
            }
            tokenizer.consume(",");
        }
    } else {
        consumeFieldValue(tokenizer, extensionRegistry, target, field, extension);
    }
}

/**
   * Internal helper to return a modifiable map containing all the fields.
   * The returned Map is modifialbe so that the caller can add additional
   * extension fields to implement {@link #getAllFields()}.
   *
   * @param getBytesForString whether to generate ByteString for string fields
   */
private Map<FieldDescriptor, Object> getAllFieldsMutable(boolean getBytesForString) {
    final TreeMap<FieldDescriptor, Object> result = new TreeMap<FieldDescriptor, Object>();
    final Descriptor descriptor = internalGetFieldAccessorTable().descriptor;
    final List<FieldDescriptor> fields = descriptor.getFields();
    for (int i = 0; i < fields.size(); i++) {
        FieldDescriptor field = fields.get(i);
        final OneofDescriptor oneofDescriptor = field.getContainingOneof();
        /*
       * If the field is part of a Oneof, then at maximum one field in the Oneof is set
       * and it is not repeated. There is no need to iterate through the others.
       */
        if (oneofDescriptor != null) {
            // Skip other fields in the Oneof we know are not set
            i += oneofDescriptor.getFieldCount() - 1;
            if (!hasOneof(oneofDescriptor)) {
                // If no field is set in the Oneof, skip all the fields in the Oneof
                continue;
            }
            // Get the pointer to the only field which is set in the Oneof
            field = getOneofFieldDescriptor(oneofDescriptor);
        } else {
            // If we are not in a Oneof, we need to check if the field is set and if it is repeated
            if (field.isRepeated()) {
                final List<?> value = (List<?>) getField(field);
                if (!value.isEmpty()) {
                    result.put(field, value);
                }
                continue;
            }
            if (!hasField(field)) {
                continue;
            }
        }
        // Add the field to the map
        if (getBytesForString && field.getJavaType() == FieldDescriptor.JavaType.STRING) {
            result.put(field, getFieldRaw(field));
        } else {
            result.put(field, getField(field));
        }
    }
    return result;
}

/**
     * Parse a single field from {@code tokenizer} and merge it into
     * {@code builder}.
     */
private void mergeField(final Tokenizer tokenizer, final ExtensionRegistry extensionRegistry, final MessageReflection.MergeTarget target) throws ParseException {
    FieldDescriptor field = null;
    final Descriptor type = target.getDescriptorForType();
    ExtensionRegistry.ExtensionInfo extension = null;
    if (tokenizer.tryConsume("[")) {
        // An extension.
        final StringBuilder name = new StringBuilder(tokenizer.consumeIdentifier());
        while (tokenizer.tryConsume(".")) {
            name.append('.');
            name.append(tokenizer.consumeIdentifier());
        }
        extension = target.findExtensionByName(extensionRegistry, name.toString());
        if (extension == null) {
            if (!allowUnknownFields) {
                throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" not found in the ExtensionRegistry.");
            } else {
                logger.warning("Extension \"" + name + "\" not found in the ExtensionRegistry.");
            }
        } else {
            if (extension.descriptor.getContainingType() != type) {
                throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + type.getFullName() + "\".");
            }
            field = extension.descriptor;
        }
        tokenizer.consume("]");
    } else {
        final String name = tokenizer.consumeIdentifier();
        field = type.findFieldByName(name);
        // names.
        if (field == null) {
            // Explicitly specify US locale so that this code does not break when
            // executing in Turkey.
            final String lowerName = name.toLowerCase(Locale.US);
            field = type.findFieldByName(lowerName);
            // If the case-insensitive match worked but the field is NOT a group,
            if (field != null && field.getType() != FieldDescriptor.Type.GROUP) {
                field = null;
            }
        }
        // Again, special-case group names as described above.
        if (field != null && field.getType() == FieldDescriptor.Type.GROUP && !field.getMessageType().getName().equals(name)) {
            field = null;
        }
        if (field == null) {
            if (!allowUnknownFields) {
                throw tokenizer.parseExceptionPreviousToken("Message type \"" + type.getFullName() + "\" has no field named \"" + name + "\".");
            } else {
                logger.warning("Message type \"" + type.getFullName() + "\" has no field named \"" + name + "\".");
            }
        }
    }
    // Skips unknown fields.
    if (field == null) {
        // to be a message or the input is ill-formed.
        if (tokenizer.tryConsume(":") && !tokenizer.lookingAt("{") && !tokenizer.lookingAt("<")) {
            skipFieldValue(tokenizer);
        } else {
            skipFieldMessage(tokenizer);
        }
        return;
    }
    // Handle potential ':'.
    if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
        // optional
        tokenizer.tryConsume(":");
    } else {
        // required
        tokenizer.consume(":");
    }
    // Ex."foo: [1, 2, 3]"
    if (field.isRepeated() && tokenizer.tryConsume("[")) {
        while (true) {
            consumeFieldValue(tokenizer, extensionRegistry, target, field, extension);
            if (tokenizer.tryConsume("]")) {
                // End of list.
                break;
            }
            tokenizer.consume(",");
        }
    } else {
        consumeFieldValue(tokenizer, extensionRegistry, target, field, extension);
    }
}

/**
     * Parse a single field from {@code tokenizer} and merge it into
     * {@code builder}.
     */
private void mergeField(final Tokenizer tokenizer, final ExtensionRegistry extensionRegistry, final MessageReflection.MergeTarget target) throws ParseException {
    FieldDescriptor field = null;
    final Descriptor type = target.getDescriptorForType();
    ExtensionRegistry.ExtensionInfo extension = null;
    if (tokenizer.tryConsume("[")) {
        // An extension.
        final StringBuilder name = new StringBuilder(tokenizer.consumeIdentifier());
        while (tokenizer.tryConsume(".")) {
            name.append('.');
            name.append(tokenizer.consumeIdentifier());
        }
        extension = target.findExtensionByName(extensionRegistry, name.toString());
        if (extension == null) {
            if (!allowUnknownFields) {
                throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" not found in the ExtensionRegistry.");
            } else {
                logger.warning("Extension \"" + name + "\" not found in the ExtensionRegistry.");
            }
        } else {
            if (extension.descriptor.getContainingType() != type) {
                throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + type.getFullName() + "\".");
            }
            field = extension.descriptor;
        }
        tokenizer.consume("]");
    } else {
        final String name = tokenizer.consumeIdentifier();
        field = type.findFieldByName(name);
        // names.
        if (field == null) {
            // Explicitly specify US locale so that this code does not break when
            // executing in Turkey.
            final String lowerName = name.toLowerCase(Locale.US);
            field = type.findFieldByName(lowerName);
            // If the case-insensitive match worked but the field is NOT a group,
            if (field != null && field.getType() != FieldDescriptor.Type.GROUP) {
                field = null;
            }
        }
        // Again, special-case group names as described above.
        if (field != null && field.getType() == FieldDescriptor.Type.GROUP && !field.getMessageType().getName().equals(name)) {
            field = null;
        }
        if (field == null) {
            if (!allowUnknownFields) {
                throw tokenizer.parseExceptionPreviousToken("Message type \"" + type.getFullName() + "\" has no field named \"" + name + "\".");
            } else {
                logger.warning("Message type \"" + type.getFullName() + "\" has no field named \"" + name + "\".");
            }
        }
    }
    // Skips unknown fields.
    if (field == null) {
        // to be a message or the input is ill-formed.
        if (tokenizer.tryConsume(":") && !tokenizer.lookingAt("{") && !tokenizer.lookingAt("<")) {
            skipFieldValue(tokenizer);
        } else {
            skipFieldMessage(tokenizer);
        }
        return;
    }
    // Handle potential ':'.
    if (field.getJavaType() == FieldDescriptor.JavaType.MESSAGE) {
        // optional
        tokenizer.tryConsume(":");
    } else {
        // required
        tokenizer.consume(":");
    }
    // Ex."foo: [1, 2, 3]"
    if (field.isRepeated() && tokenizer.tryConsume("[")) {
        while (true) {
            consumeFieldValue(tokenizer, extensionRegistry, target, field, extension);
            if (tokenizer.tryConsume("]")) {
                // End of list.
                break;
            }
            tokenizer.consume(",");
        }
    } else {
        consumeFieldValue(tokenizer, extensionRegistry, target, field, extension);
    }
}

private static Message readMessage(JsonParser jp, Builder builder, ExtensionRegistry registry) throws IOException {
    JsonToken tok = jp.getCurrentToken();
    Descriptor descriptor = builder.getDescriptorForType();
    if (tok != JsonToken.START_OBJECT) {
        throw new IOException("Expected START_OBJECT, found: " + tok);
    }
    while ((tok = jp.nextToken()) != JsonToken.END_OBJECT) {
        if (tok != JsonToken.FIELD_NAME) {
            throw new IOException("Expected FIELD_NAME, found: " + tok);
        }
        final String fieldName = jp.getCurrentName();
        FieldDescriptor fieldDesc = descriptor.findFieldByName(fieldName);
        if (fieldDesc == null) {
            ExtensionInfo extensionInfo = registry.findExtensionByName(fieldName);
            if (extensionInfo != null) {
                fieldDesc = extensionInfo.descriptor;
            }
        }
        if (fieldDesc != null) {
            /* Advance to value token */
            tok = jp.nextToken();
            if (fieldDesc.isRepeated()) {
                if (tok != JsonToken.START_ARRAY) {
                    throw new IOException("Expected START_ARRAY, found: " + tok);
                }
                builder.setField(fieldDesc, readRepeatable(jp, builder, registry, fieldDesc));
            } else {
                builder.setField(fieldDesc, readValue(jp, builder, registry, fieldDesc));
            }
        } else {
            /* Skip unknown field type */
            tok = jp.nextToken();
            if (tok == JsonToken.START_ARRAY || tok == JsonToken.START_OBJECT) {
                jp.skipChildren();
            }
        }
    }
    return builder.build();
}

/**
   * Parse a single field from {@code tokenizer} and merge it into {@code builder}. If a ',' is
   * detected after the field ends, the next field will be parsed automatically
   */
protected void mergeField(Tokenizer tokenizer, ExtensionRegistry extensionRegistry, Message.Builder builder) throws ParseException {
    FieldDescriptor field;
    Descriptor type = builder.getDescriptorForType();
    ExtensionRegistry.ExtensionInfo extension = null;
    boolean unknown = false;
    String name = tokenizer.consumeIdentifier();
    field = type.findFieldByName(name);
    // names.
    if (field == null) {
        // Explicitly specify US locale so that this code does not break when
        // executing in Turkey.
        String lowerName = name.toLowerCase(Locale.US);
        field = type.findFieldByName(lowerName);
        // If the case-insensitive match worked but the field is NOT a group,
        if ((field != null) && (field.getType() != FieldDescriptor.Type.GROUP)) {
            field = null;
        }
    }
    // Again, special-case group names as described above.
    if ((field != null) && (field.getType() == FieldDescriptor.Type.GROUP) && !field.getMessageType().getName().equals(name)) {
        field = null;
    }
    // which indicates a possible unknown field
    if (field == null && TextUtils.isDigits(name)) {
        field = type.findFieldByNumber(Integer.parseInt(name));
        unknown = true;
    }
    // Finally, look for extensions
    extension = extensionRegistry.findExtensionByName(name);
    if (extension != null) {
        if (extension.descriptor.getContainingType() != type) {
            throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + type.getFullName() + "\".");
        }
        field = extension.descriptor;
    }
    // Disabled throwing exception if field not found, since it could be a different version.
    if (field == null) {
        handleMissingField(tokenizer, extensionRegistry, builder);
    //throw tokenizer.parseExceptionPreviousToken("Message type \"" + type.getFullName()
    //                                            + "\" has no field named \"" + name
    //                                            + "\".");
    }
    if (field != null) {
        tokenizer.consume(":");
        boolean array = tokenizer.tryConsume("[");
        if (array) {
            while (!tokenizer.tryConsume("]")) {
                handleValue(tokenizer, extensionRegistry, builder, field, extension, unknown);
                tokenizer.tryConsume(",");
            }
        } else {
            handleValue(tokenizer, extensionRegistry, builder, field, extension, unknown);
        }
    }
    if (tokenizer.tryConsume(",")) {
        // Continue with the next field
        mergeField(tokenizer, extensionRegistry, builder);
    }
}

/**
     * Parse a single field from {@code tokenizer} and merge it into {@code builder}. If a ',' is
     * detected after the field ends, the next field will be parsed automatically
     */
private static void mergeField(Tokenizer tokenizer, ExtensionRegistry extensionRegistry, Message.Builder builder) throws ParseException {
    FieldDescriptor field;
    Descriptor type = builder.getDescriptorForType();
    ExtensionRegistry.ExtensionInfo extension = null;
    if (tokenizer.tryConsume("[")) {
        // An extension.
        StringBuilder name = new StringBuilder(tokenizer.consumeIdentifier());
        while (tokenizer.tryConsume(".")) {
            name.append(".");
            name.append(tokenizer.consumeIdentifier());
        }
        extension = extensionRegistry.findExtensionByName(name.toString());
        if (extension == null) {
            throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" not found in the ExtensionRegistry.");
        } else if (extension.descriptor.getContainingType() != type) {
            throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + type.getFullName() + "\".");
        }
        tokenizer.consume("]");
        field = extension.descriptor;
    } else {
        String name = tokenizer.consumeIdentifier();
        field = type.findFieldByName(name);
        // names.
        if (field == null) {
            // Explicitly specify US locale so that this code does not break when
            // executing in Turkey.
            String lowerName = name.toLowerCase(Locale.US);
            field = type.findFieldByName(lowerName);
            // If the case-insensitive match worked but the field is NOT a group,
            if ((field != null) && (field.getType() != FieldDescriptor.Type.GROUP)) {
                field = null;
            }
        }
        // Again, special-case group names as described above.
        if ((field != null) && (field.getType() == FieldDescriptor.Type.GROUP) && !field.getMessageType().getName().equals(name)) {
            field = null;
        }
        if (field == null) {
            throw tokenizer.parseExceptionPreviousToken("Message type \"" + type.getFullName() + "\" has no field named \"" + name + "\".");
        }
    }
    tokenizer.consume(":");
    boolean array = tokenizer.tryConsume("[");
    if (array) {
        while (!tokenizer.tryConsume("]")) {
            handleValue(tokenizer, extensionRegistry, builder, field, extension);
            tokenizer.tryConsume(",");
        }
    } else {
        handleValue(tokenizer, extensionRegistry, builder, field, extension);
    }
    if (tokenizer.tryConsume(",")) {
        // Continue with the next field
        mergeField(tokenizer, extensionRegistry, builder);
    }
}

/**
   * Parse a single field from {@code tokenizer} and merge it into {@code builder}. If a ',' is
   * detected after the field ends, the next field will be parsed automatically
   */
protected void mergeField(Tokenizer tokenizer, ExtensionRegistry extensionRegistry, Message.Builder builder) throws ParseException {
    FieldDescriptor field;
    Descriptor type = builder.getDescriptorForType();
    ExtensionRegistry.ExtensionInfo extension = null;
    boolean unknown = false;
    String name = tokenizer.consumeIdentifier();
    field = type.findFieldByName(name);
    // names.
    if (field == null) {
        // Explicitly specify US locale so that this code does not break when
        // executing in Turkey.
        String lowerName = name.toLowerCase(Locale.US);
        field = type.findFieldByName(lowerName);
        // If the case-insensitive match worked but the field is NOT a group,
        if ((field != null) && (field.getType() != FieldDescriptor.Type.GROUP)) {
            field = null;
        }
    }
    // Again, special-case group names as described above.
    if ((field != null) && (field.getType() == FieldDescriptor.Type.GROUP) && !field.getMessageType().getName().equals(name)) {
        field = null;
    }
    // which indicates a possible unknown field
    if (field == null && TextUtils.isDigits(name)) {
        field = type.findFieldByNumber(Integer.parseInt(name));
        unknown = true;
    }
    // Finally, look for extensions
    extension = extensionRegistry.findExtensionByName(name);
    if (extension != null) {
        if (extension.descriptor.getContainingType() != type) {
            throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + type.getFullName() + "\".");
        }
        field = extension.descriptor;
    }
    // Disabled throwing exception if field not found, since it could be a different version.
    if (field == null) {
        handleMissingField(tokenizer, extensionRegistry, builder);
    //throw tokenizer.parseExceptionPreviousToken("Message type \"" + type.getFullName()
    //                                            + "\" has no field named \"" + name
    //                                            + "\".");
    }
    if (field != null) {
        tokenizer.consume(":");
        boolean array = tokenizer.tryConsume("[");
        if (array) {
            while (!tokenizer.tryConsume("]")) {
                handleValue(tokenizer, extensionRegistry, builder, field, extension, unknown);
                tokenizer.tryConsume(",");
            }
        } else {
            handleValue(tokenizer, extensionRegistry, builder, field, extension, unknown);
        }
    }
    if (tokenizer.tryConsume(",")) {
        // Continue with the next field
        mergeField(tokenizer, extensionRegistry, builder);
    }
}

/**
   * Parse a single field from {@code tokenizer} and merge it into {@code builder}. If a ',' is
   * detected after the field ends, the next field will be parsed automatically
   */
protected void mergeField(Tokenizer tokenizer, ExtensionRegistry extensionRegistry, Message.Builder builder) throws ParseException {
    FieldDescriptor field;
    Descriptor type = builder.getDescriptorForType();
    ExtensionRegistry.ExtensionInfo extension = null;
    boolean unknown = false;
    String name = tokenizer.consumeIdentifier();
    field = type.findFieldByName(name);
    // names.
    if (field == null) {
        // Explicitly specify US locale so that this code does not break when
        // executing in Turkey.
        String lowerName = name.toLowerCase(Locale.US);
        field = type.findFieldByName(lowerName);
        // If the case-insensitive match worked but the field is NOT a group,
        if ((field != null) && (field.getType() != FieldDescriptor.Type.GROUP)) {
            field = null;
        }
    }
    // Again, special-case group names as described above.
    if ((field != null) && (field.getType() == FieldDescriptor.Type.GROUP) && !field.getMessageType().getName().equals(name)) {
        field = null;
    }
    // which indicates a possible unknown field
    if (field == null && TextUtils.isDigits(name)) {
        field = type.findFieldByNumber(Integer.parseInt(name));
        unknown = true;
    }
    // Finally, look for extensions
    extension = extensionRegistry.findExtensionByName(name);
    if (extension != null) {
        if (extension.descriptor.getContainingType() != type) {
            throw tokenizer.parseExceptionPreviousToken("Extension \"" + name + "\" does not extend message type \"" + type.getFullName() + "\".");
        }
        field = extension.descriptor;
    }
    // Disabled throwing exception if field not found, since it could be a different version.
    if (field == null) {
        handleMissingField(tokenizer, extensionRegistry, builder);
    //throw tokenizer.parseExceptionPreviousToken("Message type \"" + type.getFullName()
    //                                            + "\" has no field named \"" + name
    //                                            + "\".");
    }
    if (field != null) {
        tokenizer.consume(":");
        boolean array = tokenizer.tryConsume("[");
        if (array) {
            while (!tokenizer.tryConsume("]")) {
                handleValue(tokenizer, extensionRegistry, builder, field, extension, unknown);
                tokenizer.tryConsume(",");
            }
        } else {
            handleValue(tokenizer, extensionRegistry, builder, field, extension, unknown);
        }
    }
    if (tokenizer.tryConsume(",")) {
        // Continue with the next field
        mergeField(tokenizer, extensionRegistry, builder);
    }
}

@Test
public void shortClassName() {
    doTest("I<Integer>", "I");
    doTest("I<Long>", "I");
    doTest("java.lang.Object", "Object");
    doTest("java.lang.String", "String");
    doTest("java.lang.Throwable", "Throwable");
    doTest("java.io.PrintStream", "PrintStream");
    doTest("java.io.PrintWriter", "PrintWriter");
    doTest("java.lang.StackTraceElement", "StackTraceElement");
    doTest("java.lang.Throwable.PrintStreamOrWriter", "PrintStreamOrWriter");
    doTest("java.io.ObjectInputStream", "ObjectInputStream");
    doTest("java.io.ObjectOutputStream", "ObjectOutputStream");
    doTest("java.lang.Integer", "Integer");
    doTest("java.lang.Long", "Long");
    doTest("java.lang.Error", "Error");
    doTest("java.lang.RuntimeException", "RuntimeException");
    doTest("@Override", "Override");
    doTest("java.lang.annotation.Target", "Target");
    doTest("java.net.MalformedURLException", "MalformedURLException");
    doTest("java.io.IOException", "IOException");
    doTest("java.net.URLConnection", "URLConnection");
    doTest("java.io.InputStream", "InputStream");
    doTest("java.lang.AutoCloseable", "AutoCloseable");
    doTest("@", "");
    doTest("@Deprecated", "Deprecated");
    doTest("java.lang.annotation.Documented", "Documented");
    doTest("java.lang.annotation.Retention", "Retention");
    doTest("CSuperFoo<X>", "CSuperFoo");
    doTest("SuperFoo<X>", "SuperFoo");
    doTest("java.lang.StringBuffer", "StringBuffer");
    doTest("java.lang.StringBuilder", "StringBuilder");
    doTest("Member<>", "Member");
    doTest("Nested<>", "Nested");
    doTest("Neg09.Nested<>", "Nested");
    doTest("UndeclaredName<>", "UndeclaredName");
    doTest("L<String>", "L");
    doTest("P1<P<K>>", "P1");
    doTest("P<P1T>", "P");
    doTest("F<X>", "F");
    doTest("Base<String>", "Base");
    doTest("Base<Integer>", "Base");
    doTest("A<V>", "A");
    doTest("ArrayList<T>", "ArrayList");
    doTest("I<>", "I");
    doTest("java.util.Collection<? extends E>", "Collection");
    doTest("java.util.Map<? extends K,? extends V>", "Map");
    doTest("java.util.HashMap.Entry", "Entry");
    doTest("java.util.Iterator<E>", "Iterator");
    doTest("java.util.ListIterator<E>", "ListIterator");
    doTest("java.util.List<E>", "List");
    doTest("@SuppressWarnings", "SuppressWarnings");
    doTest("java.lang.annotation.Annotation", "Annotation");
    doTest("@MyAnno", "MyAnno");
    doTest("java.lang.Exception", "Exception");
    doTest("@SafeVarargs", "SafeVarargs");
    doTest("List<T>", "List");
    doTest("List<String>", "List");
    doTest("List<?>", "List");
    doTest("SemKey<String>", "SemKey");
    doTest("Condition<String>", "Condition");
    doTest("SemKey<T>", "SemKey");
    doTest("java.lang.Class<?>", "Class");
    doTest("A<T>", "A");
    doTest("java.lang.invoke.MethodType", "MethodType");
    doTest("java.lang.CharSequence", "CharSequence");
    doTest("java.lang.IllegalAccessException", "IllegalAccessException");
    doTest("java.util.Locale", "Locale");
    doTest("java.util.List<java.lang.Class<?>>", "List");
    doTest("java.lang.Void", "Void");
    doTest("java.lang.invoke.MethodHandles.Lookup", "Lookup");
    doTest("java.lang.invoke.MethodHandle", "MethodHandle");
    doTest("java.lang.invoke.MethodHandle.PolymorphicSignature", "PolymorphicSignature");
    doTest("Map<String, String>", "Map");
    doTest("List<N>", "List");
    doTest("Wrapper<E, T>", "Wrapper");
    doTest("X<T>", "X");
    doTest("Node<String>.Details", "Details");
    doTest("Map<K, V>", "Map");
    doTest("Map.Entry<K, V>", "Entry");
    doTest("Matcher<Collection<? extends E>>", "Matcher");
    doTest("A<String>", "A");
    doTest("NonDefaultConstructorContainer.Inner", "Inner");
    doTest("OtherClass.InnerClass", "InnerClass");
    doTest("Foo<Number>", "Foo");
    doTest("Foo<Integer>", "Foo");
    doTest("Test<String>", "Test");
    doTest("DiamondTest<String>", "DiamondTest");
    doTest("ParallelPipeline<T, V>", "ParallelPipeline");
    doTest("ArrayList<E>", "ArrayList");
    doTest("Generic<String>", "Generic");
    doTest("Generic<Object>", "Generic");
    doTest("java.io.Serializable", "Serializable");
    doTest("java.lang.Comparable<java.lang.String>", "Comparable");
    doTest("@Target", "Target");
    doTest("@TA", "TA");
    doTest("java.lang.Enum", "Enum");
    doTest("java.io.OutputStream", "OutputStream");
    doTest("java.io.OutputStreamWriter", "OutputStreamWriter");
    doTest("java.io.File", "File");
    doTest("Foo.IBar", "IBar");
    doTest("Iterable<Path>", "Iterable");
    doTest("B<Integer>", "B");
    doTest("B<Long>", "B");
    doTest("java.lang.AbstractStringBuilder", "AbstractStringBuilder");
    doTest("@NotNull", "NotNull");
    doTest("@Nullable", "Nullable");
    doTest("java.lang.Runnable", "Runnable");
    doTest("java.io.FileDescriptor", "FileDescriptor");
    doTest("java.io.FileNotFoundException", "FileNotFoundException");
    doTest("java.sql.SQLException", "SQLException");
    doTest("java.awt.Point", "Point");
    doTest("List<A.B>", "List");
    doTest("test.A", "A");
    doTest("test.Client", "Client");
    doTest("Pair<String, Pair<Integer, Boolean>>", "Pair");
    doTest("util.Pair", "Pair");
    doTest("java.util.Calendar", "Calendar");
    doTest("java.util.ArrayList", "ArrayList");
    doTest("java.util.Arrays", "Arrays");
    doTest("java.util.List", "List");
    doTest("java.lang.Boolean", "Boolean");
    doTest("java.lang.ClassLoader", "ClassLoader");
    doTest("Demo.Pojo2", "Pojo2");
    doTest("A<E>", "A");
    doTest("java.lang.reflect.Type", "Type");
    doTest("java.security.ProtectionDomain", "ProtectionDomain");
    doTest("java.lang.reflect.Field", "Field");
    doTest("java.lang.reflect.Method", "Method");
    doTest("java.lang.reflect.Constructor", "Constructor");
    doTest("sun.reflect.annotation.AnnotationType", "AnnotationType");
    doTest("java.lang.reflect.TypeVariable<java.lang.Class<T>>", "TypeVariable");
    doTest("java.lang.reflect.TypeVariable<?>", "TypeVariable");
    doTest("java.lang.Class<T>", "Class");
    doTest("Parent<Integer>", "Parent");
    doTest("@org.jetbrains.annotations.NotNull", "NotNull");
    doTest("@org.jetbrains.annotations.Nullable", "Nullable");
    doTest("org.jetbrains.annotations.NotNull", "NotNull");
    doTest("org.jetbrains.annotations.Nullable", "Nullable");
    doTest("IX<Throwable>", "IX");
    doTest("@org.testng.annotations.BeforeMethod", "BeforeMethod");
    doTest("Function<String, ?>", "Function");
    doTest("Function<String>", "Function");
    doTest("A<Throwable>", "A");
    doTest("Generic<?>", "Generic");
    doTest("A1<T>", "A1");
    doTest("B<T>", "B");
    doTest("pack.AAClass", "AAClass");
    doTest("pack.WithInnerAClass", "WithInnerAClass");
    doTest("java.lang.CloneNotSupportedException", "CloneNotSupportedException");
    doTest("Foo<ZZZ", "Foo");
    doTest("@MyObj", "MyObj");
    doTest("@MyObjectType", "MyObjectType");
    doTest("@Retention", "Retention");
    doTest("java.io.FileInputStream", "FileInputStream");
    doTest("java.lang.Class<? extends java.lang.Object>", "Class");
    doTest("java.io.ObjectStreamField", "ObjectStreamField");
    doTest("java.util.Comparator<java.lang.String>", "Comparator");
    doTest("java.io.FilenameFilter", "FilenameFilter");
    doTest("java.lang.Class", "Class");
    doTest("foo.Foo", "Foo");
    doTest("java.util.List<? super T>", "List");
    doTest("java.awt.Component", "Component");
    doTest("java.util.Collection<?>", "Collection");
    doTest("java.awt.Rectangle", "Rectangle");
    doTest("javax.swing.JTable", "JTable");
    doTest("javax.swing.JScrollPane", "JScrollPane");
    doTest("java.awt.Container", "Container");
    doTest("java.net.FileNameMap", "FileNameMap");
    doTest("java.awt.Frame", "Frame");
    doTest("java.util.List<?>", "List");
    doTest("java.awt.event.MouseEvent", "MouseEvent");
    doTest("javax.swing.Action", "Action");
    doTest("javax.swing.KeyStroke", "KeyStroke");
    doTest("java.awt.event.KeyEvent", "KeyEvent");
    doTest("java.io.DataInput", "DataInput");
    doTest("java.net.ContentHandlerFactory", "ContentHandlerFactory");
    doTest("java.net.DatagramSocketImplFactory", "DatagramSocketImplFactory");
    doTest("java.net.SocketImplFactory", "SocketImplFactory");
    doTest("java.net.URLStreamHandlerFactory", "URLStreamHandlerFactory");
    doTest("java.util.Collection<? extends T>", "Collection");
    doTest("java.util.Collection<T>", "Collection");
    doTest("java.util.List<? extends T>", "List");
    doTest("java.util.List<T>", "List");
    doTest("java.util.Map<K,V>", "Map");
    doTest("java.util.Set<? extends T>", "Set");
    doTest("java.util.Set<T>", "Set");
    doTest("java.util.SortedMap<K,? extends V>", "SortedMap");
    doTest("java.util.SortedMap<K,V>", "SortedMap");
    doTest("java.util.SortedSet<T>", "SortedSet");
    doTest("java.lang.Float", "Float");
    doTest("java.lang.Double", "Double");
    doTest("java.lang.Short", "Short");
    doTest("java.lang.annotation.ElementType", "ElementType");
    doTest("java.lang.Byte", "Byte");
    doTest("java.util.concurrent.TimeUnit", "TimeUnit");
    doTest("java.lang.annotation.RetentionPolicy", "RetentionPolicy");
    doTest("java.lang.Character", "Character");
    doTest("java.sql.Time", "Time");
    doTest("java.sql.Date", "Date");
    doTest("java.sql.Timestamp", "Timestamp");
    doTest("java.awt.Window", "Window");
    doTest("Some<caret>", "Some");
    doTest("foo.bar.AxBxCxDxEx", "AxBxCxDxEx");
    doTest("net.n3.nanoxml.IXMLReader", "IXMLReader");
    doTest("net.n3.nanoxml.IXMLBuilder", "IXMLBuilder");
    doTest("net.n3.nanoxml.IXMLValidator", "IXMLValidator");
    doTest("net.n3.nanoxml.IXMLEntityResolver", "IXMLEntityResolver");
    doTest("java.util.Vector", "Vector");
    doTest("foo.MyClass", "MyClass");
    doTest("foo.ServiceManager", "ServiceManager");
    doTest("Bar<String>", "Bar");
    doTest("pkg.Bar", "Bar");
    doTest("java.util.Random", "Random");
    doTest("java.util.Set", "Set");
    doTest("java.util.Map", "Map");
    doTest("java.util.Comparator", "Comparator");
    doTest("java.util.Collection<E>", "Collection");
    doTest("java.util.Set<E>", "Set");
    doTest("java.util.SortedSet<E>", "SortedSet");
    doTest("java.util.Comparator<T>", "Comparator");
    doTest("java.util.Enumeration<T>", "Enumeration");
    doTest("pkg.Foo", "Foo");
    doTest("foo.Bar", "Bar");
    doTest("sun.nio.ch.Interruptible", "Interruptible");
    doTest("java.lang.ThreadGroup", "ThreadGroup");
    doTest("java.lang.Thread", "Thread");
    doTest("java.lang.Iterable", "Iterable");
    doTest("java.lang.Package", "Package");
    doTest("java.lang.reflect.Constructor<?>", "Constructor");
    doTest("java.lang.reflect.Constructor<T>", "Constructor");
    doTest("java.lang.Class<U>", "Class");
    doTest("java.lang.Class<A>", "Class");
    doTest("java.lang.Class<? extends java.lang.annotation.Annotation>", "Class");
    doTest("foo.Util", "Util");
    doTest("java.lang.SecurityManager", "SecurityManager");
    doTest("java.util.Properties", "Properties");
    doTest("java.util.Map<java.lang.String,java.lang.String>", "Map");
    doTest("java.lang.Class<W>", "Class");
    doTest("java.lang.Class<V>", "Class");
    doTest("@Foo", "Foo");
    doTest("@Anno", "Anno");
    doTest("java.awt.Font", "Font");
    doTest("java.awt.Graphics", "Graphics");
    doTest("java.awt.Color", "Color");
    doTest("java.awt.Dimension", "Dimension");
    doTest("java.awt.Event", "Event");
    doTest("java.awt.PopupMenu", "PopupMenu");
    doTest("java.awt.MenuComponent", "MenuComponent");
    doTest("java.beans.PropertyChangeListener", "PropertyChangeListener");
    doTest("java.awt.ComponentOrientation", "ComponentOrientation");
    doTest("java.awt.LayoutManager", "LayoutManager");
    doTest("javax.swing.JPopupMenu", "JPopupMenu");
    doTest("javax.swing.border.Border", "Border");
    doTest("java.awt.Insets", "Insets");
    doTest("javax.swing.InputVerifier", "InputVerifier");
    doTest("java.awt.event.ActionListener", "ActionListener");
    doTest("javax.swing.ComponentInputMap", "ComponentInputMap");
    doTest("javax.swing.ActionMap", "ActionMap");
    doTest("javax.swing.TransferHandler", "TransferHandler");
    doTest("javax.swing.event.AncestorListener", "AncestorListener");
    doTest("javax.swing.JComponent", "JComponent");
    doTest("java.awt.event.ContainerListener", "ContainerListener");
    doTest("java.awt.AWTEvent", "AWTEvent");
    doTest("java.awt.event.ContainerEvent", "ContainerEvent");
    doTest("java.awt.FocusTraversalPolicy", "FocusTraversalPolicy");
    doTest("java.awt.dnd.DropTarget", "DropTarget");
    doTest("java.awt.PointerInfo", "PointerInfo");
    doTest("java.awt.Cursor", "Cursor");
    doTest("java.awt.Image", "Image");
    doTest("java.awt.image.ImageProducer", "ImageProducer");
    doTest("java.awt.event.MouseWheelEvent", "MouseWheelEvent");
    doTest("java.awt.event.ComponentListener", "ComponentListener");
    doTest("java.awt.event.FocusListener", "FocusListener");
    doTest("java.awt.event.HierarchyListener", "HierarchyListener");
    doTest("java.awt.event.HierarchyBoundsListener", "HierarchyBoundsListener");
    doTest("java.awt.event.KeyListener", "KeyListener");
    doTest("java.awt.event.MouseListener", "MouseListener");
    doTest("java.awt.event.MouseMotionListener", "MouseMotionListener");
    doTest("java.awt.event.MouseWheelListener", "MouseWheelListener");
    doTest("java.awt.event.InputMethodListener", "InputMethodListener");
    doTest("java.awt.event.ComponentEvent", "ComponentEvent");
    doTest("java.awt.event.FocusEvent", "FocusEvent");
    doTest("java.awt.event.InputMethodEvent", "InputMethodEvent");
    doTest("java.awt.event.HierarchyEvent", "HierarchyEvent");
    doTest("java.util.EventListener", "EventListener");
    doTest("javax.accessibility.AccessibleContext", "AccessibleContext");
    doTest("java.awt.peer.ContainerPeer", "ContainerPeer");
    doTest("javax.swing.InputMap", "InputMap");
    doTest("javax.swing.JToolTip", "JToolTip");
    doTest("javax.swing.JRootPane", "JRootPane");
    doTest("java.awt.peer.ComponentPeer", "ComponentPeer");
    doTest("java.awt.GraphicsConfiguration", "GraphicsConfiguration");
    doTest("java.awt.Toolkit", "Toolkit");
    doTest("java.awt.image.ColorModel", "ColorModel");
    doTest("java.awt.FontMetrics", "FontMetrics");
    doTest("java.awt.image.VolatileImage", "VolatileImage");
    doTest("java.awt.ImageCapabilities", "ImageCapabilities");
    doTest("java.awt.image.ImageObserver", "ImageObserver");
    doTest("java.awt.im.InputMethodRequests", "InputMethodRequests");
    doTest("java.awt.im.InputContext", "InputContext");
    doTest("javax.swing.JPanel", "JPanel");
    doTest("@T", "T");
    doTest("java.util.Set<K>", "Set");
    doTest("java.util.Collection<V>", "Collection");
    doTest("java.util.Set<java.util.Map.Entry<K,V>>", "Set");
    doTest("java.util.Map.Entry<K,V>", "Entry");
    doTest("java.util.TimeZone", "TimeZone");
    doTest("java.util.Date", "Date");
    doTest("AbstractSet<T>", "AbstractSet");
    doTest("@TestFor", "TestFor");
    doTest("@MyAnnotation", "MyAnnotation");
    doTest("@My", "My");
    doTest("@Test", "Test");
    doTest("List<V>", "List");
    doTest("Function<Object, ArrayIndexOutOfBoundsException>", "Function");
    doTest("@in", "in");
    doTest("YourMapInterface<K, V>", "YourMapInterface");
    doTest("@ab", "ab");
    doTest("List<A>", "List");
    doTest("@MyAn", "MyAn");
    doTest("@java.la", "la");
    doTest("java.lang.Class<E>", "Class");
    doTest("javax.accessibility.AccessibleStateSet", "AccessibleStateSet");
    doTest("Bar.", "");
    doTest("@TestAnnotation", "TestAnnotation");
    doTest("Key<T>", "Key");
    doTest("foo.Super", "Super");
    doTest("@NN", "NN");
    doTest("java.io.InputStreamReader", "InputStreamReader");
    doTest("foo.StringValue", "StringValue");
    doTest("@B", "B");
    doTest("@Example", "Example");
    doTest("java.util.HashMap", "HashMap");
    doTest("@MagicConstant", "MagicConstant");
    doTest("List<Inner>", "List");
    doTest("List<bar.Foo.Inner>", "List");
    doTest("bar.Foo", "Foo");
    doTest("bar.Assert", "Assert");
    doTest("java.util.Collections", "Collections");
    doTest("Foo<String>", "Foo");
    doTest("Bar<Goo>", "Bar");
    doTest("java.util.Collection", "Collection");
    doTest("Collection<Foo>", "Collection");
    doTest("java.net.URL", "URL");
    doTest("java.util.Enumeration", "Enumeration");
    doTest("java.lang.ref.SoftReference", "SoftReference");
    doTest("sun.reflect.generics.repository.ClassRepository", "ClassRepository");
    doTest("sun.reflect.ReflectionFactory", "ReflectionFactory");
    doTest("java.lang.Class.EnclosingMethodInfo", "EnclosingMethodInfo");
    doTest("sun.reflect.generics.factory.GenericsFactory", "GenericsFactory");
    doTest("sun.reflect.ConstantPool", "ConstantPool");
    doTest("javax.swing.event.EventListenerList", "EventListenerList");
    doTest("javax.swing.ArrayTable", "ArrayTable");
    doTest("javax.swing.AncestorNotifier", "AncestorNotifier");
    doTest("java.awt.LightweightDispatcher", "LightweightDispatcher");
    doTest("sun.awt.DebugHelper", "DebugHelper");
    doTest("javax.accessibility.Accessible", "Accessible");
    doTest("java.util.logging.Logger", "Logger");
    doTest("sun.awt.AppContext", "AppContext");
    doTest("java.awt.image.BufferStrategy", "BufferStrategy");
    doTest("java.beans.PropertyChangeSupport", "PropertyChangeSupport");
    doTest("java.awt.Component.NativeInLightFixer", "NativeInLightFixer");
    doTest("java.util.concurrent.ConcurrentHashMap<java.lang.String,java.util.Locale>", "ConcurrentHashMap");
    doTest("sun.util.resources.OpenListResourceBundle", "OpenListResourceBundle");
    doTest("java.text.MessageFormat", "MessageFormat");
    doTest("java.security.Provider", "Provider");
    doTest("Super<String>", "Super");
    doTest("Super<Integer>", "Super");
    doTest("Super<T>", "Super");
    doTest("SubGeneric<T>", "SubGeneric");
    doTest("MyDD<String>", "MyDD");
    doTest("java.lang.Class<java.lang.Boolean>", "Class");
    doTest("MyProcessor<T>", "MyProcessor");
    doTest("Pair<A,B>", "Pair");
    doTest("foo.Foo<T>", "Foo");
    doTest("java.net.URI", "URI");
    doTest("FList<T>", "FList");
    doTest("java.util.ArrayList<T>", "ArrayList");
    doTest("XXX<X>", "XXX");
    doTest("XXX<Z>", "XXX");
    doTest("XXX<Z, Z1>", "XXX");
    doTest("XXX<ZZZ<Z>>", "XXX");
    doTest("Set<T>", "Set");
    doTest("Outer.Boo", "Boo");
    doTest("Params<", "Params");
    doTest("Key<Impl>", "Key");
    doTest("ExtensionPointName<T>", "ExtensionPointName");
    doTest("X<String>", "X");
    doTest("A<StringBuffer>", "A");
    doTest("Function<String, String>", "Function");
    doTest("java.io.FileFilter", "FileFilter");
    doTest("@Join", "Join");
    doTest("@Table", "Table");
    doTest("Computable<Boolean>", "Computable");
    doTest("Comparable<Foo>", "Comparable");
    doTest("Goo<String>", "Goo");
    doTest("Comparator<String>", "Comparator");
    doTest("@A", "A");
    doTest("java.awt.geom.Point2D.Double", "Double");
    doTest("java.awt.geom.Point2D", "Point2D");
    doTest("bar.Bar", "Bar");
    doTest("A<T[]>", "A");
    doTest("IA<String>", "IA");
    doTest("B<K>", "B");
    doTest("ArgumentA<Object>", "ArgumentA");
    doTest("ClassB<E>", "ClassB");
    doTest("ClassA<E>", "ClassA");
    doTest("BaseMatcher<String>", "BaseMatcher");
    doTest("x.A", "A");
    doTest("x.sub.B", "B");
    doTest("effectiveAccess.pp<", "pp");
    doTest("effectiveAccess.pp", "pp");
    doTest("BaseImpl.Inner", "Inner");
    doTest("x.Base", "Base");
    doTest("@java.lang.Deprecated", "Deprecated");
    doTest("I<II>", "I");
    doTest("C<Q>", "C");
    doTest("AC<CC>", "AC");
    doTest("@Deprecated Object", "Object");
    doTest("@Ann", "Ann");
    doTest("@In", "In");
    doTest("@Inner2", "Inner2");
    doTest("@java.lang", "lang");
    doTest("@Expose", "Expose");
    doTest("@Expose1", "Expose1");
    doTest("DummyList<? extends String>", "DummyList");
    doTest("C<C<U>>", "C");
    doTest("C1<C1<U>>", "C1");
    doTest("CC<T>", "CC");
    doTest("Gen<GT>", "Gen");
    doTest("A1<String>", "A1");
    doTest("I1<Integer>", "I1");
    doTest("II1<Integer>", "II1");
    doTest("II2<Integer>", "II2");
    doTest("II2<String>", "II2");
    doTest("II1<Number>", "II1");
    doTest("II2<Number>", "II2");
    doTest("AAA<T>", "AAA");
    doTest("III<T>", "III");
    doTest("Cmp<Singleton<T1>>", "Cmp");
    doTest("e<String>", "e");
    doTest("ValueChangeListener<Number>", "ValueChangeListener");
    doTest("First<S>", "First");
    doTest("Second<Integer>", "Second");
    doTest("SuperA<T, E>", "SuperA");
    doTest("SuperB<T, E>", "SuperB");
    doTest("Super<Collection>", "Super");
    doTest("TypeDispatcher<T,V>", "TypeDispatcher");
    doTest("DefaultDispatcher<Node, String>", "DefaultDispatcher");
    doTest("SmartList<Bug2>", "SmartList");
    doTest("java.util.List<Bug2>", "List");
    doTest("java.util.AbstractList<E>", "AbstractList");
    doTest("TableContextAction<Object>", "TableContextAction");
    doTest("ActionContext<TableContextAction<TCP>>", "ActionContext");
    doTest("ContextAction<TableContext<RO>>", "ContextAction");
    doTest("Listener<String>", "Listener");
    doTest("I<I>", "I");
    doTest("I<T>", "I");
    doTest("I<D>", "I");
    doTest("DT<T>", "DT");
    doTest("b<d, c>", "b");
    doTest("c<d, c<c,c>>", "c");
    doTest("d<b<c<c,c>,d>>", "d");
    doTest("c<K, c<V,V>>", "c");
    doTest("d<b<V,K>>", "d");
    doTest("Z<Integer>", "Z");
    doTest("BaseC<String>", "BaseC");
    doTest("Int<T>", "Int");
    doTest("A<A>", "A");
    doTest("Outer<String>", "Outer");
    doTest("Outer<String>.Inner", "Inner");
    doTest("AbstractClass<AI>", "AbstractClass");
    doTest("AbstractClass<BI>", "AbstractClass");
    doTest("PrivilegedExceptionAction<FileNotFoundException>", "PrivilegedExceptionAction");
    doTest("Printer<T>", "Printer");
    doTest("I1<C1,C2>", "I1");
    doTest("I2<C1,C2>", "I2");
    doTest("List<Decl>", "List");
    doTest("Reference<T>", "Reference");
    doTest("Comparable<? super ccc>", "Comparable");
    doTest("ArrayList<G1>", "ArrayList");
    doTest("WeakReference<T>", "WeakReference");
    doTest("Y<Y>", "Y");
    doTest("ArrayList<String>", "ArrayList");
    doTest("Comparable<C>", "Comparable");
    doTest("Comparable<String>", "Comparable");
    doTest("ZZZ<K>", "ZZZ");
    doTest("Callable<T>", "Callable");
    doTest("GenericTest99<E,Double>", "GenericTest99");
    doTest("Use99<GenericTest99D<?>,Double>", "Use99");
    doTest("A67675<T[]>", "A67675");
    doTest("java.util.Comparator<? super T>", "Comparator");
    doTest("I2<", "I2");
    doTest("java.util.Map<K, V>", "Map");
    doTest("AA<BB>", "AA");
    doTest("GrandParent<T>", "GrandParent");
    doTest("Base<T[]>", "Base");
    doTest("Base<T>", "Base");
    doTest("AbstractParent<E>", "AbstractParent");
    doTest("Interface<E>", "Interface");
    doTest("SuperAbstract<Owner, String>", "SuperAbstract");
    doTest("HalfGenericSuper<Owner>", "HalfGenericSuper");
    doTest("List<E>", "List");
    doTest("Comparable<A<T>>", "Comparable");
    doTest("A<", "A");
    doTest("Runnable<", "Runnable");
    doTest("HashMap<K, V>", "HashMap");
    doTest("Comparable<Object>", "Comparable");
    doTest("A<K>", "A");
    doTest("Base <String>", "Base");
    doTest("Outer<Other>", "Outer");
    doTest("Lst<?, ?>", "Lst");
    doTest("Collection<A>", "Collection");
    doTest("Matcher<? super T>", "Matcher");
    doTest("ThingUser<?>", "ThingUser");
    doTest("YO<String>", "YO");
    doTest("YO<Integer>", "YO");
    doTest("ArrayList<Integer>", "ArrayList");
    doTest("Comparable<Date>", "Comparable");
    doTest("List<Class<? extends Serializable>>", "List");
    doTest("java.lang.Cloneable", "Cloneable");
    doTest("Test1<ArrayList>", "Test1");
    doTest("Comparator<Object>", "Comparator");
    doTest("TestIF3<T>", "TestIF3");
    doTest("TestBase<Enum1>", "TestBase");
    doTest("Comparable<SortTest<R>>", "Comparable");
    doTest("TypeSafeMap<CoreMap>", "TypeSafeMap");
    doTest("TypeSafeMap.Key<CoreMap, V>", "Key");
    doTest("Map<K,V>", "Map");
    doTest("Version<V, R>", "Version");
    doTest("Ref<V, R>", "Ref");
    doTest("VersionEntity<G, GR>", "VersionEntity");
    doTest("RefEntity<G, GR>", "RefEntity");
    doTest("Node<?, ?>", "Node");
    doTest("IQ<", "IQ");
    doTest("P<TB>", "P");
    doTest("DomInvocationHandler<FixedChildDescriptionImpl>", "DomInvocationHandler");
    doTest("RunConfigurationExtension<Bo>", "RunConfigurationExtension");
    doTest("Comparator<I>", "Comparator");
    doTest("JSResolveUtil.Resolver<M>", "Resolver");
    doTest("JSResolveUtil.F", "F");
    doTest("Model<Inner>", "Model");
    doTest("Comparator<A.B>", "Comparator");
    doTest("IConverter<N>", "IConverter");
    doTest("AbstractNumberConverter<Double>", "AbstractNumberConverter");
    doTest("IConverter<C>", "IConverter");
    doTest("Class<? extends Iterator>", "Class");
    doTest("List<? extends AbstractTreeNode>", "List");
    doTest("Iterator<T>", "Iterator");
    doTest("Class<E>", "Class");
    doTest("Comparator<byte[]>", "Comparator");
    doTest("C<T,T>", "C");
    doTest("A2<T>", "A2");
    doTest("A3<T>", "A3");
    doTest("IB<", "IB");
    doTest("A<S>", "A");
    doTest("B<String>", "B");
    doTest("List<List<T>>", "List");
    doTest("I<A[]>", "I");
    doTest("I<B[]>", "I");
    doTest("A<S,T>", "A");
    doTest("F<A, P1<B>>", "F");
    doTest("Iterable<T>", "Iterable");
    doTest("A<Integer>", "A");
    doTest("Pair<A, B>", "Pair");
    doTest("Field<Object>", "Field");
    doTest("MyInterface<Object>", "MyInterface");
    doTest("Class<I>", "Class");
    doTest("Outer.Inner", "Inner");
    doTest("Comparator<K>", "Comparator");
    doTest("Comparable<SelfComparable>", "Comparable");
    doTest("Collection<T>", "Collection");
    doTest("Collection<E>", "Collection");
    doTest("Iterator<E>", "Iterator");
    doTest("UnmodifiableCollection<E>", "UnmodifiableCollection");
    doTest("Set<E>", "Set");
    doTest("SortedSet<T>", "SortedSet");
    doTest("UnmodifiableSet<E>", "UnmodifiableSet");
    doTest("SortedSet<E>", "SortedSet");
    doTest("ListIterator<E>", "ListIterator");
    doTest("UnmodifiableList<E>", "UnmodifiableList");
    doTest("UnmodifiableSet<Map.Entry<K,V>>", "UnmodifiableSet");
    doTest("Iterator<Map.Entry<K,V>>", "Iterator");
    doTest("Map.Entry<K,V>", "Entry");
    doTest("SortedMap<K,V>", "SortedMap");
    doTest("UnmodifiableMap<K,V>", "UnmodifiableMap");
    doTest("SynchronizedCollection<E>", "SynchronizedCollection");
    doTest("SynchronizedSet<E>", "SynchronizedSet");
    doTest("SynchronizedList<E>", "SynchronizedList");
    doTest("SynchronizedMap<K,V>", "SynchronizedMap");
    doTest("CheckedCollection<E>", "CheckedCollection");
    doTest("CheckedSet<E>", "CheckedSet");
    doTest("CheckedList<E>", "CheckedList");
    doTest("Set<Map.Entry<K,V>>", "Set");
    doTest("CheckedMap<K,V>", "CheckedMap");
    doTest("AbstractSet<Object>", "AbstractSet");
    doTest("Iterator<Object>", "Iterator");
    doTest("AbstractList<Object>", "AbstractList");
    doTest("AbstractMap<Object,Object>", "AbstractMap");
    doTest("AbstractSet<E>", "AbstractSet");
    doTest("AbstractList<E>", "AbstractList");
    doTest("AbstractMap<K,V>", "AbstractMap");
    doTest("Comparator<T>", "Comparator");
    doTest("Comparator<Comparable<Object>>", "Comparator");
    doTest("Enumeration<T>", "Enumeration");
    doTest("java.util.SortedMap", "SortedMap");
    doTest("java.util.AbstractList", "AbstractList");
    doTest("java.util.TreeMap", "TreeMap");
    doTest("java.util.concurrent.atomic.AtomicBoolean", "AtomicBoolean");
    doTest("x.n.X1", "X1");
    doTest("x.n.X2", "X2");
    doTest("x.n.X3", "X3");
    doTest("java.util.X", "X");
    doTest("java.io.Reader", "Reader");
    doTest("java.security.cert.Certificate", "Certificate");
    doTest("i<", "i");
    doTest("ii<", "ii");
    doTest("i2<", "i2");
    doTest("A57.X", "X");
    doTest("A.B", "B");
    doTest("A42.B", "B");
    doTest("B57.X", "X");
    doTest("c4<", "c4");
    doTest("i7<", "i7");
    doTest("c8<", "c8");
    doTest("i5<", "i5");
    doTest("ConflictWithObject<", "ConflictWithObject");
    doTest("MethodsFromObject<", "MethodsFromObject");
    doTest("java.awt.event.ActionEvent", "ActionEvent");
    doTest("a<", "a");
    doTest("A1<", "A1");
    doTest("Foo<", "Foo");
    doTest("c2<", "c2");
    doTest("c1<", "c1");
    doTest("java.awt.BufferCapabilities", "BufferCapabilities");
    doTest("java.io.ObjectOutput", "ObjectOutput");
    doTest("java.io.ObjectInput", "ObjectInput");
    doTest("java.lang.ClassNotFoundException", "ClassNotFoundException");
    doTest("IFoo.UNKNOWN", "UNKNOWN");
    doTest("Integer.MAX_VALUE", "MAX_VALUE");
    doTest("Inner1<", "Inner1");
    doTest("D.B", "B");
    doTest("D.", "");
    doTest("D.B1", "B1");
    doTest("A.B1", "B1");
    doTest("C1.B1", "B1");
    doTest("@java.lang.SuppressWarnings", "SuppressWarnings");
    doTest("BaseStream<T>", "BaseStream");
    doTest("StreamOp<E_IN, Node<E_OUT>>", "StreamOp");
    doTest("IntermediateOp<E_IN, E_OUT>", "IntermediateOp");
    doTest("StreamOp<E_IN, R>", "StreamOp");
    doTest("StatefulOp<T, T>", "StatefulOp");
    doTest("Foo1<Integer, Integer>", "Foo1");
    doTest("List<B>", "List");
    doTest("Optional<U>", "Optional");
    doTest("BiFunction<T, T, T>", "BiFunction");
    doTest("Collector<T, M1>", "Collector");
    doTest("BinaryOperator<M2>", "BinaryOperator");
    doTest("Collector<T, R>", "Collector");
    doTest("C<T, M1>", "C");
    doTest("BiOp<M2>", "BiOp");
    doTest("C<T, R>", "C");
    doTest("BiFun<T, T, T>", "BiFun");
    doTest("Map<A, B>", "Map");
    doTest("Map<K1, M1>", "Map");
    doTest("FindOp<MT, Optional<MT>>", "FindOp");
    doTest("TerminalSink<FindSinkT, FindSinkO>", "TerminalSink");
    doTest("FindSink<OfRefT, Optional<OfRefT>>", "FindSink");
    doTest("FindOp1<MT, Optional<MT>>", "FindOp1");
    doTest("FindOp2<MT, Optional<MT>>", "FindOp2");
    doTest("Optional<T>", "Optional");
    doTest("Consumer<T>", "Consumer");
    doTest("@FunctionalInterface", "FunctionalInterface");
    doTest("Sink<Integer>", "Sink");
    doTest("Sink<T>", "Sink");
    doTest("FirstParent<", "FirstParent");
    doTest("Block<T>", "Block");
    doTest("TerminalSink<T, Void>", "TerminalSink");
    doTest("VoidTerminalSink<Integer>", "VoidTerminalSink");
    doTest("Sink.OfInt", "OfInt");
    doTest("VoidTerminalSink.OfInt<", "OfInt");
    doTest("ForEachOp<T>", "ForEachOp");
    doTest("VoidTerminalSink.OfInt", "OfInt");
    doTest("Iso<R, T>", "Iso");
    doTest("I<X>", "I");
    doTest("I1<T>", "I1");
    doTest("I2<T>", "I2");
    doTest("Y<Object>", "Y");
    doTest("BinaryOperator<Integer>", "BinaryOperator");
    doTest("Combiner<T,T,T>", "Combiner");
    doTest("IntermediateOp<L, M>", "IntermediateOp");
    doTest("IntermediateOp1<T, U>", "IntermediateOp1");
    doTest("I<A,B>", "I");
    doTest("A<L>", "A");
    doTest("SameArgsI<T>", "SameArgsI");
    doTest("LambdaTest<U>", "LambdaTest");
    doTest("Option<T>", "Option");
    doTest("Function<T, Integer>", "Function");
    doTest("BaseStream<Integer>", "BaseStream");
    doTest("Comparator<Map.Entry<K, V>>", "Comparator");
    doTest("Function<T, T>", "Function");
    doTest("A<M>", "A");
    doTest("Foo<X>", "Foo");
    doTest("Iterable<U>", "Iterable");
    doTest("ASink<R, Moo>", "ASink");
    doTest("ASink<AAMoo, AAMoo>", "ASink");
    doTest("ASink<R, AAAMoo>", "ASink");
    doTest("Collector<T, C>", "Collector");
    doTest("Collector<T, List<T>>", "Collector");
    doTest("Stream<C>", "Stream");
    doTest("BiFunction<T,T,T>", "BiFunction");
    doTest("Collector<Integer, R>", "Collector");
    doTest("C.E2", "E2");
    doTest("C.E1", "E1");
    doTest("java.nio.charset.Charset", "Charset");
    doTest("java.nio.charset.CharsetDecoder", "CharsetDecoder");
    doTest("I<String>", "I");
    doTest("InOut<B>", "InOut");
    doTest("DeeBee<B>", "DeeBee");
    doTest("b<C.D>", "b");
    doTest("b<String>", "b");
    doTest("Foo.Bar", "Bar");
    doTest("@Attr", "Attr");
    doTest("javax.swing.table.TableModel", "TableModel");
    doTest("javax.swing.event.TableModelListener", "TableModelListener");
    doTest("@BeanAware", "BeanAware");
    doTest("java.awt.MenuContainer", "MenuContainer");
    doTest("java.lang.Number", "Number");
    doTest("Foo<Bug>", "Foo");
    doTest("Seq<T>", "Seq");
    doTest("Seq<V>", "Seq");
    doTest("Comparable<R>", "Comparable");
    doTest("@org.jetbrains.annotations.NonNls", "NonNls");
    doTest("org.jetbrains.annotations.NonNls", "NonNls");
    doTest("@NonNls", "NonNls");
    doTest("MatchOp<T>", "MatchOp");
    doTest("BooleanTerminalSink<T>", "BooleanTerminalSink");
    doTest("Callable<String>", "Callable");
    doTest("Callable<Integer>", "Callable");
    doTest("AsyncTask<String, Integer, Long>", "AsyncTask");
    doTest("AsyncTask<String,Integer,Integer>", "AsyncTask");
    doTest("List<AppInfo>", "List");
    doTest("ArrayList<ResolveInfo>", "ArrayList");
    doTest("CallableEx<String>", "CallableEx");
    doTest("Callable<TE>", "Callable");
    doTest("CallableEx<Integer>", "CallableEx");
    doTest("TestCase<caret>", "TestCase");
    doTest("@org.ju", "ju");
    doTest("l.InLib", "InLib");
    doTest("junit.framework.Assert", "Assert");
    doTest("junit.framework.TestCase", "TestCase");
    doTest("junit.framework.Test", "Test");
    doTest("junit.framework.TestSuite", "TestSuite");
    doTest("junit.framework.TestResult", "TestResult");
    doTest("junit.framework.TestListener", "TestListener");
    doTest("junit.framework.TestFailure", "TestFailure");
    doTest("junit.framework.ComparisonFailure", "ComparisonFailure");
    doTest("junit.framework.AssertionFailedError", "AssertionFailedError");
    doTest("x.InA", "InA");
    doTest("y.AddDependency", "AddDependency");
    doTest("y.AddLibrary", "AddLibrary");
    doTest("x.DoTest", "DoTest");
    doTest("@org.junit.Test", "Test");
    doTest("org.junit.Test", "Test");
    doTest("x.DoTest4", "DoTest4");
    doTest("Some<K, T>", "Some");
    doTest("java.util.Collection<? super T>", "Collection");
    doTest("I.FOO", "FOO");
    doTest("I.FOO1", "FOO1");
    doTest("I.FOO2", "FOO2");
    doTest("I.FOO3", "FOO3");
    doTest("I.FOO4", "FOO4");
    doTest("I.FOO5", "FOO5");
    doTest("@java.lang.SafeVarargs", "SafeVarargs");
    doTest("M<T>", "M");
    doTest("M<String>", "M");
    doTest("@javax.annotation.Generated", "Generated");
    doTest("II<String>", "II");
    doTest("AroundTemplateMethod<T>", "AroundTemplateMethod");
    doTest("SetupTimer<Integer>", "SetupTimer");
    doTest("bar.Log", "Log");
    doTest("@Bar.Foo", "Foo");
    doTest("I<Object>", "I");
    doTest("Superclass<E, Q>", "Superclass");
    doTest("@org.testng.annotations.Test", "Test");
    doTest("@org.junit.Before", "Before");
    doTest("Ref<T>", "Ref");
    doTest("M<MX, MY>", "M");
    doTest("Proc<String>", "Proc");
    doTest("Proc<Integer>", "Proc");
    doTest("java.util.Iterator", "Iterator");
    doTest("p1.Base", "Base");
    doTest("javax.swing.Icon", "Icon");
    doTest("java.awt.Dialog", "Dialog");
    doTest("javax.swing.JLabel", "JLabel");
    doTest("test.Matcher", "Matcher");
    doTest("java.util.Collections.CopiesList", "CopiesList");
    doTest("java.util.Collections.EmptyList", "EmptyList");
    doTest("java.util.Collections.EmptyMap", "EmptyMap");
    doTest("java.util.Collections.EmptySet", "EmptySet");
    doTest("java.util.Collections.ReverseComparator", "ReverseComparator");
    doTest("java.util.Collections.ReverseComparator2", "ReverseComparator2");
    doTest("java.util.Collections.SelfComparable", "SelfComparable");
    doTest("java.util.Collections.SingletonList", "SingletonList");
    doTest("java.util.Collections.SingletonMap", "SingletonMap");
    doTest("java.util.Collections.SingletonMap.ImmutableEntry", "ImmutableEntry");
    doTest("java.util.Collections.SingletonSet", "SingletonSet");
    doTest("java.util.Collections.SynchronizedCollection", "SynchronizedCollection");
    doTest("java.util.Collections.SynchronizedList", "SynchronizedList");
    doTest("java.util.Collections.SynchronizedMap", "SynchronizedMap");
    doTest("java.util.Collections.SynchronizedRandomAccessList", "SynchronizedRandomAccessList");
    doTest("java.util.Collections.SynchronizedSet", "SynchronizedSet");
    doTest("java.util.Collections.SynchronizedSortedMap", "SynchronizedSortedMap");
    doTest("java.util.Collections.SynchronizedSortedSet", "SynchronizedSortedSet");
    doTest("java.util.Collections.UnmodifiableCollection", "UnmodifiableCollection");
    doTest("java.util.Collections.UnmodifiableList", "UnmodifiableList");
    doTest("java.util.Collections.UnmodifiableMap", "UnmodifiableMap");
    doTest("java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet", "UnmodifiableEntrySet");
    doTest("java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet.UnmodifiableEntry", "UnmodifiableEntry");
    doTest("java.util.Collections.UnmodifiableRandomAccessList", "UnmodifiableRandomAccessList");
    doTest("java.util.Collections.UnmodifiableSet", "UnmodifiableSet");
    doTest("java.util.Collections.UnmodifiableSortedMap", "UnmodifiableSortedMap");
    doTest("java.util.Collections.UnmodifiableSortedSet", "UnmodifiableSortedSet");
    doTest("java.util.Map.Entry", "Entry");
    doTest("AnnotatedNonStaticInnerClassConstructor.Inner", "Inner");
    doTest("pack.Modifiers", "Modifiers");
    doTest("pkg.Deprecated", "Deprecated");
    doTest("pkg.package-info", "package-info");
    doTest("pkg.Nested", "Nested");
    doTest("pkg.Nested.Inner1", "Inner1");
    doTest("pkg.Nested.Inner1.Inner2", "Inner2");
    doTest("pkg.SimpleEnum", "SimpleEnum");
    doTest("pkg.EnumWithFields", "EnumWithFields");
    doTest("pkg.NormalClass", "NormalClass");
    doTest("pkg.NormalClass.Inner", "Inner");
    doTest("pkg.Annotations", "Annotations");
    doTest("pkg.Annotations.IndeterminateAnno", "IndeterminateAnno");
    doTest("pkg.Annotations.A4", "A4");
    doTest("pkg.Annotations.A3", "A3");
    doTest("pkg.Annotations.A2", "A2");
    doTest("pkg.Annotations.A1", "A1");
    doTest("pkg.ParameterNames", "ParameterNames");
    doTest("pkg.EmptyEnum", "EmptyEnum");
    doTest("pkg.$BuckClass", "$BuckClass");
    doTest("pkg.BuckClass$", "BuckClass$");
    doTest("pkg.ExtMethods", "ExtMethods");
    doTest("pkg.MethodReceiver", "MethodReceiver");
    doTest("pkg.MethodReceiver.A", "A");
    doTest("com.google.android.maps.OverlayItem", "OverlayItem");
    doTest("com.google.android.maps.GeoPoint", "GeoPoint");
    doTest("android.graphics.drawable.Drawable", "Drawable");
    doTest("com.TestClass", "TestClass");
    doTest("ppp.BadClass", "BadClass");
    doTest("@AnnotationType", "AnnotationType");
    doTest("@annotations.AnnotationType", "AnnotationType");
    doTest("List<Integer>", "List");
    doTest("List<List<Integer>>", "List");
    doTest("pack.MyClass", "MyClass");
    doTest("p2.A", "A");
    doTest("p1.A", "A");
    doTest("Parent.Child", "Child");
    doTest("net.n3.nanoxml.XMLUtil", "XMLUtil");
    doTest("net.n3.nanoxml.PIReader", "PIReader");
    doTest("net.n3.nanoxml.XMLWriter", "XMLWriter");
    doTest("net.n3.nanoxml.IXMLParser", "IXMLParser");
    doTest("net.n3.nanoxml.XMLElement", "XMLElement");
    doTest("net.n3.nanoxml.CDATAReader", "CDATAReader");
    doTest("net.n3.nanoxml.IXMLElement", "IXMLElement");
    doTest("net.n3.nanoxml.NonValidator", "NonValidator");
    doTest("net.n3.nanoxml.StdXMLParser", "StdXMLParser");
    doTest("net.n3.nanoxml.StdXMLReader", "StdXMLReader");
    doTest("net.n3.nanoxml.XMLAttribute", "XMLAttribute");
    doTest("net.n3.nanoxml.StdXMLReader.StackedReader", "StackedReader");
    doTest("net.n3.nanoxml.XMLException", "XMLException");
    doTest("net.n3.nanoxml.ContentReader", "ContentReader");
    doTest("net.n3.nanoxml.StdXMLBuilder", "StdXMLBuilder");
    doTest("net.n3.nanoxml.ValidatorPlugin", "ValidatorPlugin");
    doTest("net.n3.nanoxml.XMLParserFactory", "XMLParserFactory");
    doTest("net.n3.nanoxml.XMLEntityResolver", "XMLEntityResolver");
    doTest("net.n3.nanoxml.XMLParseException", "XMLParseException");
    doTest("net.n3.nanoxml.XMLValidationException", "XMLValidationException");
    doTest("com.google.protobuf.Message", "Message");
    doTest("com.google.protobuf.RpcUtil", "RpcUtil");
    doTest("com.google.protobuf.Service", "Service");
    doTest("com.google.protobuf.Message.Builder", "Builder");
    doTest("com.google.protobuf.FieldSet", "FieldSet");
    doTest("com.google.protobuf.FieldSet.FieldDescriptorLite", "FieldDescriptorLite");
    doTest("com.google.protobuf.Internal", "Internal");
    doTest("com.google.protobuf.RpcUtil.AlreadyCalledException", "AlreadyCalledException");
    doTest("com.google.protobuf.Internal.EnumLiteMap", "EnumLiteMap");
    doTest("com.google.protobuf.RpcCallback<Type>", "RpcCallback");
    doTest("com.google.protobuf.Internal.EnumLite", "EnumLite");
    doTest("com.google.protobuf.MessageLite", "MessageLite");
    doTest("com.google.protobuf.MessageOrBuilder", "MessageOrBuilder");
    doTest("com.google.protobuf.MessageLite.Builder", "Builder");
    doTest("com.google.protobuf.RpcCallback<com.google.protobuf.Message>", "RpcCallback");
    doTest("com.google.protobuf.ByteString", "ByteString");
    doTest("com.google.protobuf.RpcCallback<ParameterType>", "RpcCallback");
    doTest("com.google.protobuf.RpcChannel", "RpcChannel");
    doTest("com.google.protobuf.ByteString.CodedBuilder", "CodedBuilder");
    doTest("com.google.protobuf.TextFormat", "TextFormat");
    doTest("com.google.protobuf.WireFormat", "WireFormat");
    doTest("com.google.protobuf.TextFormat.InvalidEscapeSequenceException", "InvalidEscapeSequenceException");
    doTest("com.google.protobuf.WireFormat.FieldType", "FieldType");
    doTest("com.google.protobuf.ByteString.Output", "Output");
    doTest("com.google.protobuf.TextFormat.ParseException", "ParseException");
    doTest("com.google.protobuf.TextFormat.Tokenizer", "Tokenizer");
    doTest("com.google.protobuf.WireFormat.JavaType", "JavaType");
    doTest("java.io.FilterOutputStream", "FilterOutputStream");
    doTest("java.lang.Comparable<T>", "Comparable");
    doTest("com.google.protobuf.FieldSet<T>", "FieldSet");
    doTest("com.google.protobuf.Descriptors", "Descriptors");
    doTest("com.google.protobuf.RpcCallback", "RpcCallback");
    doTest("com.google.protobuf.Descriptors.DescriptorPool", "DescriptorPool");
    doTest("com.google.protobuf.RpcController", "RpcController");
    doTest("com.google.protobuf.DynamicMessage", "DynamicMessage");
    doTest("com.google.protobuf.Descriptors.DescriptorPool.DescriptorIntPair", "DescriptorIntPair");
    doTest("com.google.protobuf.DynamicMessage.Builder", "Builder");
    doTest("com.google.protobuf.TextFormat.TextGenerator", "TextGenerator");
    doTest("com.google.protobuf.Descriptors.DescriptorPool.PackageDescriptor", "PackageDescriptor");
    doTest("com.google.protobuf.MessageLiteOrBuilder", "MessageLiteOrBuilder");
    doTest("com.google.protobuf.TextFormat.Printer", "Printer");
    doTest("com.google.protobuf.LazyStringList", "LazyStringList");
    doTest("java.util.List<java.lang.String>", "List");
    doTest("com.google.protobuf.SmallSortedMap", "SmallSortedMap");
    doTest("com.google.protobuf.SmallSortedMap.EmptySet", "EmptySet");
    doTest("com.google.protobuf.SmallSortedMap.EntryIterator", "EntryIterator");
    doTest("com.google.protobuf.SmallSortedMap.EntrySet", "EntrySet");
    doTest("com.google.protobuf.SmallSortedMap.Entry", "Entry");
    doTest("java.util.AbstractMap<K,V>", "AbstractMap");
    doTest("java.lang.Iterable<T>", "Iterable");
    doTest("java.util.Iterator<java.util.Map.Entry<K,V>>", "Iterator");
    doTest("java.util.AbstractSet<java.util.Map.Entry<K,V>>", "AbstractSet");
    doTest("java.lang.Comparable<com.google.protobuf.SmallSortedMap<K,V>.Entry>", "Comparable");
    doTest("com.google.protobuf.SmallSortedMap<FieldDescriptorType,java.lang.Object>", "SmallSortedMap");
    doTest("com.google.protobuf.SmallSortedMap<K,V>", "SmallSortedMap");
    doTest("com.google.protobuf.AbstractMessage", "AbstractMessage");
    doTest("com.google.protobuf.AbstractMessage.Builder<com.google.protobuf.DynamicMessage.Builder>", "Builder");
    doTest("com.google.protobuf.Descriptors.DescriptorValidationException", "DescriptorValidationException");
    doTest("com.google.protobuf.BlockingService", "BlockingService");
    doTest("com.google.protobuf.AbstractMessage.Builder", "Builder");
    doTest("com.google.protobuf.Descriptors.GenericDescriptor", "GenericDescriptor");
    doTest("com.google.protobuf.UnknownFieldSet", "UnknownFieldSet");
    doTest("com.google.protobuf.UnknownFieldSet.Field", "Field");
    doTest("com.google.protobuf.Descriptors.MethodDescriptor", "MethodDescriptor");
    doTest("com.google.protobuf.UnknownFieldSet.Field.Builder", "Builder");
    doTest("com.google.protobuf.CodedInputStream", "CodedInputStream");
    doTest("com.google.protobuf.UnknownFieldSet.Builder", "Builder");
    doTest("com.google.protobuf.Descriptors.ServiceDescriptor", "ServiceDescriptor");
    doTest("com.google.protobuf.AbstractMessageLite", "AbstractMessageLite");
    doTest("com.google.protobuf.AbstractMessageLite.Builder<BuilderType>", "Builder");
    doTest("com.google.protobuf.UninitializedMessageException", "UninitializedMessageException");
    doTest("com.google.protobuf.GeneratedMessage", "GeneratedMessage");
    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable", "FieldAccessorTable");
    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.RepeatedMessageFieldAccessor", "RepeatedMessageFieldAccessor");
    doTest("com.google.protobuf.Descriptors.EnumValueDescriptor", "EnumValueDescriptor");
    doTest("com.google.protobuf.ServiceException", "ServiceException");
    doTest("com.google.protobuf.Descriptors.EnumDescriptor", "EnumDescriptor");
    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.SingularMessageFieldAccessor", "SingularMessageFieldAccessor");
    doTest("com.google.protobuf.CodedOutputStream", "CodedOutputStream");
    doTest("com.google.protobuf.CodedOutputStream.OutOfSpaceException", "OutOfSpaceException");
    doTest("com.google.protobuf.Descriptors.FieldDescriptor", "FieldDescriptor");
    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.RepeatedEnumFieldAccessor", "RepeatedEnumFieldAccessor");
    doTest("com.google.protobuf.Descriptors.FieldDescriptor.JavaType", "JavaType");
    doTest("com.google.protobuf.ExtensionRegistry", "ExtensionRegistry");
    doTest("com.google.protobuf.ExtensionRegistry.DescriptorIntPair", "DescriptorIntPair");
    doTest("com.google.protobuf.ExtensionRegistry.ExtensionInfo", "ExtensionInfo");
    doTest("com.google.protobuf.Descriptors.FieldDescriptor.Type", "Type");
    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.SingularEnumFieldAccessor", "SingularEnumFieldAccessor");
    doTest("com.google.protobuf.ExtensionRegistryLite", "ExtensionRegistryLite");
    doTest("com.google.protobuf.BlockingRpcChannel", "BlockingRpcChannel");
    doTest("com.google.protobuf.SingleFieldBuilder", "SingleFieldBuilder");
    doTest("com.google.protobuf.GeneratedMessage.BuilderParent", "BuilderParent");
    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.RepeatedFieldAccessor", "RepeatedFieldAccessor");
    doTest("com.google.protobuf.AbstractMessageLite.Builder", "Builder");
    doTest("com.google.protobuf.AbstractMessageLite.Builder.LimitedInputStream", "LimitedInputStream");
    doTest("java.io.FilterInputStream", "FilterInputStream");
    doTest("com.google.protobuf.LazyStringArrayList", "LazyStringArrayList");
    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.SingularFieldAccessor", "SingularFieldAccessor");
    doTest("java.util.AbstractList<java.lang.String>", "AbstractList");
    doTest("java.util.RandomAccess", "RandomAccess");
    doTest("com.google.protobuf.ProtocolMessageEnum", "ProtocolMessageEnum");
    doTest("com.google.protobuf.GeneratedMessageLite", "GeneratedMessageLite");
    doTest("com.google.protobuf.GeneratedMessageLite.SerializedForm", "SerializedForm");
    doTest("com.google.protobuf.GeneratedMessageLite.GeneratedExtension", "GeneratedExtension");
    doTest("com.google.protobuf.GeneratedMessage.FieldAccessorTable.FieldAccessor", "FieldAccessor");
    doTest("com.google.protobuf.Descriptors.Descriptor", "Descriptor");
    doTest("com.google.protobuf.GeneratedMessageLite.ExtensionDescriptor", "ExtensionDescriptor");
    doTest("com.google.protobuf.GeneratedMessage.GeneratedExtension", "GeneratedExtension");
    doTest("com.google.protobuf.GeneratedMessageLite.Builder", "Builder");
    doTest("com.google.protobuf.GeneratedMessage.ExtensionDescriptorRetriever", "ExtensionDescriptorRetriever");
    doTest("com.google.protobuf.FieldSet.FieldDescriptorLite<com.google.protobuf.GeneratedMessageLite.ExtensionDescriptor>", "FieldDescriptorLite");
    doTest("com.google.protobuf.GeneratedMessageLite.Builder<MessageType,BuilderType>", "Builder");
    doTest("com.google.protobuf.GeneratedMessageLite.GeneratedExtension<ContainingType,Type>", "GeneratedExtension");
    doTest("com.google.protobuf.Descriptors.FileDescriptor", "FileDescriptor");
    doTest("com.google.protobuf.RepeatedFieldBuilder", "RepeatedFieldBuilder");
    doTest("com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner", "InternalDescriptorAssigner");
    doTest("com.google.protobuf.RepeatedFieldBuilder.MessageOrBuilderExternalList", "MessageOrBuilderExternalList");
    doTest("com.google.protobuf.RepeatedFieldBuilder.BuilderExternalList", "BuilderExternalList");
    doTest("com.google.protobuf.RepeatedFieldBuilder.MessageExternalList", "MessageExternalList");
    doTest("java.util.AbstractList<IType>", "AbstractList");
    doTest("java.util.List<IType>", "List");
    doTest("java.util.AbstractList<BType>", "AbstractList");
    doTest("java.util.List<BType>", "List");
    doTest("java.util.AbstractList<MType>", "AbstractList");
    doTest("java.util.List<MType>", "List");
    doTest("com.google.protobuf.ExtensionRegistryLite.ObjectIntPair", "ObjectIntPair");
    doTest("com.google.protobuf.GeneratedMessage.Builder", "Builder");
    doTest("com.google.protobuf.Internal.EnumLiteMap<com.google.protobuf.Descriptors.EnumValueDescriptor>", "EnumLiteMap");
    doTest("java.lang.Comparable<com.google.protobuf.Descriptors.FieldDescriptor>", "Comparable");
    doTest("com.google.protobuf.FieldSet.FieldDescriptorLite<com.google.protobuf.Descriptors.FieldDescriptor>", "FieldDescriptorLite");
    doTest("com.google.protobuf.GeneratedMessage.Builder.BuilderParentImpl", "BuilderParentImpl");
    doTest("com.google.protobuf.UnmodifiableLazyStringList", "UnmodifiableLazyStringList");
    doTest("Map<Integer, Integer>", "Map");
    doTest("java.lang.Comparable<T.NameRef>", "Comparable");
    doTest("List<T[]>", "List");
    doTest("Condition<T>", "Condition");
    doTest("Class<Foo>", "Class");
    doTest("Class<Runnable>", "Class");
    doTest("Foo<BarImpl>", "Foo");
    doTest("Y<T>", "Y");
    doTest("GenericClass<String>", "GenericClass");
    doTest("A.I", "I");
    doTest("Test<T>", "Test");
    doTest("Comparable<Integer>", "Comparable");
    doTest("Iterator<Map.Entry<K, V>>", "Iterator");
    doTest("Predicate<T>", "Predicate");
    doTest("Foo.Predicate<T>", "Predicate");
    doTest("Callable<Object>", "Callable");
    doTest("C<String>", "C");
    doTest("p1.S2", "S2");
    doTest("p2.S1", "S1");
    doTest("p1.S1", "S1");
    doTest("p2.S2", "S2");
    doTest("p2.p1.S1", "S1");
    doTest("p2.p1.S2", "S2");
    doTest("@javax.xml.bind.annotation.XmlSchema", "XmlSchema");
    doTest("A <R>", "A");
    doTest("Extracted.Inner", "Inner");
    doTest("java.util.List<String>", "List");
    doTest("@java.lang.Override", "Override");
    doTest("a.Test", "Test");
    doTest("b.TestSubclass", "TestSubclass");
    doTest("java.util.ListIterator", "ListIterator");
    doTest("p1.AA", "AA");
    doTest("p2.C", "C");
    doTest("java.math.BigDecimal", "BigDecimal");
    doTest("java.sql.SQLWarning", "SQLWarning");
    doTest("java.sql.ResultSetMetaData", "ResultSetMetaData");
    doTest("java.sql.Statement", "Statement");
    doTest("java.sql.Ref", "Ref");
    doTest("java.sql.Blob", "Blob");
    doTest("java.sql.Clob", "Clob");
    doTest("java.sql.Array", "Array");
    doTest("java.sql.ResultSet", "ResultSet");
    doTest("p.Test", "Test");
    doTest("p1.Usage", "Usage");
    doTest("Super<R>", "Super");
    doTest("java.lang.Comparable<java.lang.Long>", "Comparable");
    doTest("R<String, Object>", "R");
    doTest("Res.R<java.lang.String,java.lang.Object>", "R");
    doTest("Res.R<String,java.lang.Object>", "R");
    doTest("Res.R<String,Object>", "R");
    doTest("Res.R<String, Object>", "R");
    doTest("@Before", "Before");
    doTest("org.junit.Before", "Before");
    doTest("Test<G, T>", "Test");
    doTest("p.Param", "Param");
    doTest("p2.Test", "Test");
    doTest("pack1.Class2", "Class2");
    doTest("pack2.Class1", "Class1");
    doTest("pack1.X", "X");
    doTest("pack2.X", "X");
    doTest("pack2.A", "A");
    doTest("pack1.Class1", "Class1");
    doTest("packUser.Class2", "Class2");
    doTest("pack0.Class0", "Class0");
    doTest("pack2.A.Class1", "Class1");
    doTest("A.Class1", "Class1");
    doTest("pack1.Usage", "Usage");
    doTest("pack1.StaticInner", "StaticInner");
    doTest("pack1.Client", "Client");
    doTest("xxx.Outer", "Outer");
    doTest("p.A.B", "B");
    doTest("p.A", "A");
    doTest("p.B", "B");
    doTest("package2.InnerClass", "InnerClass");
    doTest("package1.OuterClass", "OuterClass");
    doTest("pack1.DImpl", "DImpl");
    doTest("pack1.A", "A");
    doTest("pack1.B", "B");
    doTest("pack2.B", "B");
    doTest("pack1.Outer", "Outer");
    doTest("POne<Hooray<A>>", "POne");
    doTest("Eff<POne<A>, A>", "Eff");
    doTest("@SomeAnnotation", "SomeAnnotation");
    doTest("pack2.OtherClass", "OtherClass");
    doTest("pack1.ClassWithStaticMethod", "ClassWithStaticMethod");
    doTest("bar.A", "A");
    doTest("A.Inner", "Inner");
    doTest("B.Inner", "Inner");
    doTest("target.pack1.S1", "S1");
    doTest("pack2.UsagesFromBoth", "UsagesFromBoth");
    doTest("pack2.UsagesFromBoth2", "UsagesFromBoth2");
    doTest("Parent<T>", "Parent");
    doTest("Parent<String>", "Parent");
    doTest("I<S>", "I");
    doTest("Base<U>", "Base");
    doTest("javax.swing.JTextField", "JTextField");
    doTest("Test<Throwable>", "Test");
    doTest("BaseTask<T, ForEachTask<T>>", "BaseTask");
    doTest("pack1.List", "List");
    doTest("pack2.Usage2", "Usage2");
    doTest("pack2.Usage", "Usage");
    doTest("pack1.ParentXXX", "ParentXXX");
    doTest("pack1.Derived", "Derived");
    doTest("pack1.Object", "Object");
    doTest("renameCollisions.String", "String");
    doTest("javax.swing.SwingConstants", "SwingConstants");
    doTest("Holder<X>", "Holder");
    doTest("MyEventListener<Object>", "MyEventListener");
    doTest("foo.Builder", "Builder");
    doTest("Test<A, B, C>", "Test");
    doTest("B<TC>", "B");
    doTest("A<TB>", "A");
    doTest("A<TC>", "A");
    doTest("pack1.AnInterface", "AnInterface");
    doTest("pack1.AClass", "AClass");
    doTest("pack2.Client", "Client");
    doTest("Int<Xyz>", "Int");
    doTest("Int<XInt>", "Int");
    doTest("Factory<IntF>", "Factory");
    doTest("Factory<Clazz>", "Factory");
    doTest("LinkedList<Integer>", "LinkedList");
    doTest("LinkedList<E, T>", "LinkedList");
    doTest("LinkedList<E, Integer>", "LinkedList");
    doTest("Map<Integer, Y>", "Map");
    doTest("List<X>", "List");
    doTest("Collection<X>", "Collection");
    doTest("List<P>", "List");
    doTest("C<String,Integer>", "C");
    doTest("C<Integer, String,Integer>", "C");
    doTest("C<Integer, String >", "C");
    doTest("C<String, L<String>>", "C");
    doTest("Subject<String>", "Subject");
    doTest("Subject<SubjectFace, Set<Object>>", "Subject");
    doTest("Subject<SubjectFace, java.util.Set<Object>>", "Subject");
    doTest("X<U>", "X");
    doTest("java.util.TreeMap.Entry", "Entry");
    doTest("java.util.TreeMap.Entry<K,?>", "Entry");
    doTest("java.util.TreeMap.Entry<K,V>", "Entry");
    doTest("java.util.Comparator<? super K>", "Comparator");
    doTest("WeighingComparable<T, Loc>", "WeighingComparable");
    doTest("Key<ProximityWeigher>", "Key");
    doTest("Weigher<String, ProximityLocation>", "Weigher");
    doTest("Comparable<WeighingComparable<T, Loc>>", "Comparable");
    doTest("p1.ParentWithProtected", "ParentWithProtected");
    doTest("p1.SubjectWithSuper", "SubjectWithSuper");
    doTest("p2.Usage", "Usage");
    doTest("p1.ParentUniqueName", "ParentUniqueName");
    doTest("p1.ChildCtor", "ChildCtor");
    doTest("java.util.Comparator<String>", "Comparator");
    doTest("Demo.MyParent", "MyParent");
    doTest("A.MyActionListener", "MyActionListener");
    doTest("Comparable<T>", "Comparable");
    doTest("qqq.aaa.Yahoo", "Yahoo");
    doTest("p1.C1", "C1");
    doTest("zzz.bbb.QQQ", "QQQ");
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return com.google.appengine.base.ApiBase.internal_static_com_google_appengine_base_StringProto_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.apache.hadoop.hbase.protobuf.generated.MultiRowMutationProcessorProtos.internal_static_MultiRowMutationProcessorRequest_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.apache.hadoop.hbase.protobuf.generated.MultiRowMutationProcessorProtos.internal_static_MultiRowMutationProcessorRequest_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return protocol.Msg.LogoutMsg.internal_static_protocol_LogoutReq_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return code.google.nfs.rpc.benchmark.PB.internal_static_com_bluedavy_RequestObject_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return com.streamsets.pipeline.lib.util.ExtensionsProto.internal_static_util_PersonExtension_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return BE.BEConnectRequest.internal_static_BE_ConnectRequest_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return com.opera.core.systems.scope.protos.DesktopUtilsProtos.internal_static_scope_DesktopStringID_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return com.sensei.search.req.protobuf.SenseiRequestBPO.internal_static_com_sensei_search_req_protobuf_Request_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return sizzle.types.P4Stat.internal_static_sizzle_types_P4ChangelistStats_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.terasology.protobuf.NetData.internal_static_ServerMessage_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return DWProto.internal_static_DataWrapperMsg_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.devtcg.five.meta.data.Protos.internal_static_Artist_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return alluxio.proto.journal.KeyValue.internal_static_alluxio_proto_journal_CompletePartitionEntry_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.waveprotocol.wave.examples.fedone.rpc.Rpc.internal_static_rpc_CancelRpc_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return filterd.protocol.Control.internal_static_filterd_protocol_Result_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return alluxio.proto.journal.KeyValue.internal_static_alluxio_proto_journal_CompletePartitionEntry_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return com.yoursway.autoupdater.core.protos.InstallationProtos.internal_static_PackMemento_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return unit.test.proto.Commands.internal_static_unit_test_proto_WorkerCommand_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return meetup.beeno.HDataTypes.internal_static_hbase_DateTime_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return corner.cache.services.impl.CacheableDefine.internal_static_lichen_common_services_impl_Definition_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return ww10.WW10Protocol.internal_static_ww10_PrologBotDescription_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return ww10.WW10Protocol.internal_static_ww10_PrologBotDescription_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.whispersystems.textsecure.crypto.protocol.WhisperProtos.internal_static_textsecure_WhisperMessage_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.springframework.protobuf.OuterSample.internal_static_SecondMsg_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return com.aliyun.odps.tunnel.io.proto.XstreamPack.internal_static_com_aliyun_odps_tunnel_io_proto_XStreamPack_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.robotninjas.barge.proto.RaftEntry.internal_static_Entry_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return ProtoBuffSpecification.internal_static_PieceUploadRequest_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return io.dropwizard.jersey.protobuf.protos.DropwizardProtosTest.internal_static_dropwizard_Example_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return filters.generated.FilterProtos.internal_static_CustomFilter_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.apache.hadoop.hbase.rest.protobuf.generated.TableListMessage.internal_static_org_apache_hadoop_hbase_rest_protobuf_generated_TableList_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.apache.hadoop.hbase.rest.protobuf.generated.TableListMessage.internal_static_org_apache_hadoop_hbase_rest_protobuf_generated_TableList_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return com.baidu.jprotobuf.pbrpc.proto.EchoInfoClass.internal_static_pkg_EchoInfo_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return de.javakaffee.kryoserializers.protobuf.SampleProtoAOuterClass.internal_static_ProtocolBuffers_SampleProtoA_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return com.snowcattle.game.message.auto.udp.online.OnlineUDPProBuf.internal_static_OnlineHeartUDPProBuf_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.apache.hadoop.hbase.protobuf.generated.LoadBalancerProtos.internal_static_LoadBalancerState_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return rina.object.gpb.EnrollmentInformation_t.internal_static_rina_messages_enrollmentInformation_t_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return retrofit.converter.PhoneProtos.internal_static_retrofit_Phone_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.apache.hadoop.hbase.rest.protobuf.generated.TableListMessage.internal_static_org_apache_hadoop_hbase_rest_protobuf_generated_TableList_descriptor;
}

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() {
    return org.thoughtcrime.securesms.webrtc.WebRtcDataProtos.internal_static_signal_Connected_descriptor;
}