additionalValues.put(attributeDoc.getKey(), attributeDoc);
            }
            PropertyDoc propertyDoc = new PropertyDoc(property, javadocConverter.parse(property, listener).getDocbook(), new ArrayList<ExtraAttributeDoc>(additionalValues.values()));
            if (propertyDoc.getDescription() == null) {

import okio.Buffer
import okio.BufferedSink
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

@Tag("Slowish")
class MultipartReaderTest {
  @Test fun `parse multipart`() {
    val multipart =
      """
      |--simple boundary
      |Content-Type: text/plain; charset=utf-8
      |Content-ID: abc
      |
      |abcd
      |efgh
      |--simple boundary

pkg text/template/parse, type DotNode struct, embedded NodeType
pkg text/template/parse, type NilNode struct, embedded NodeType
pkg text/template/parse, method (*BranchNode) Copy() Node
pkg text/template/parse, method (*IdentifierNode) SetTree(*Tree) *IdentifierNode
pkg html/template, type Error struct, Node parse.Node

     * argument will be returned.
     *
     * @param key the property key to look up
     * @param def the default value to return if the property is not found or cannot be parsed
     * @return the property value as an int, or the default value
     */

    public static int getInt(final String key, int def) {
        final String s = prp.getProperty(key);
        if (s != null) {

    @classmethod
    def fromstring(cls, root_name, data):
        """Initialize STSElement from name and XML string data.

        :param name: Name for XML data. Used in XML errors.
        :param data: string data to be parsed.
        :return: Returns an STSElement.
        """
        try:
            return cls(root_name, cElementTree.fromstring(data))
        except _ETREE_EXCEPTIONS as error:
            raise InvalidXMLError(

 * the License.
 */

package com.google.common.primitives;

import com.google.common.annotations.GwtCompatible;

/** A string to be parsed as a number and the radix to interpret it in. */
@GwtCompatible
final class ParseRequest {
  final String rawValue;
  final int radix;

  private ParseRequest(String rawValue, int radix) {

	if err := json.Unmarshal(data, &s); err != nil {
		return err
	}

	targetID, err := parseTargetID(s)
	if err != nil {
		return err
	}

	*tid = *targetID
	return nil
}

// parseTargetID - parses string to TargetID.
func parseTargetID(s string) (*TargetID, error) {
	tokens := strings.Split(s, ":")
	if len(tokens) != 2 {
		return nil, fmt.Errorf("invalid TargetID format '%v'", s)
	}

	return &TargetID{

      for (i in 0 until headerBlock.size) {
        val name = headerBlock.name(i)
        val value = headerBlock.value(i)
        if (name == RESPONSE_STATUS_UTF8) {
          statusLine = StatusLine.parse("HTTP/1.1 $value")
        } else if (name !in HTTP_2_SKIPPED_RESPONSE_HEADERS) {
          headersBuilder.addLenient(name, value)
        }
      }

    checkFromStringCase("google.com:25\t", 1, null, 99, false);
    checkFromStringCase("google.com:0x25 ", 1, null, 99, false);
  }

  public void testFromStringUnparseableNonsense() {
    // Some nonsense that causes parse failures.
    checkFromStringCase("[goo.gl]", 1, null, 99, false);
    checkFromStringCase("[goo.gl]:80", 1, null, 99, false);
    checkFromStringCase("[", 1, null, 99, false);
    checkFromStringCase("[]:", 1, null, 99, false);

		}
		if !bytes.Equal(tmp[:], []byte{'\n', '\r', '\n'}) {
			if cr.debug {
				fmt.Printf("got %q, want %q\n", string(tmp[:]), "\n\r\n")
			}
			return errMalformedEncoding
		}
		break
	}

	// Parse trailers.
	wantTrailers := make(map[string]struct{}, len(cr.trailers))
	for k := range cr.trailers {
		wantTrailers[strings.ToLower(k)] = struct{}{}
	}
	input := bufio.NewScanner(bytes.NewReader(valueBuffer.Bytes()))