if err != nil {
		return m, err
	}
	noOfEntries := qty % maxNoEntries
	if noOfEntries == 0 {
		return m, errors.New("a map of zero-length was created")
	}
	for i := 0; i < noOfEntries; i++ {
		k, err := f.GetString()
		if err != nil {
			return m, err
		}
		v, err := f.GetBytes()
		if err != nil {
			return m, err
		}
		m[k] = v
	}
	return m, nil
}

func FuzzCompareDiff(data []byte) int {

// It stops once it finds 0 or reaches end of b.
func cstring(b []byte) string {
	var i int
	for i = 0; i < len(b) && b[i] != 0; i++ {
	}
	return string(b[:i])
}

// getString extracts a string from an XCOFF string table.
func getString(st []byte, offset uint32) (string, bool) {
	if offset < 4 || int(offset) >= len(st) {
		return "", false
	}
	return cstring(st[offset:]), true
}

        when:
        def obj = create(BeanWithParameterizedTypeService, services)

        then:
        obj.things == [12]
        obj.getThings() == [12]
        obj.getProperty("things") == [12]

        def returnType = obj.getClass().getDeclaredMethod("getThings").genericReturnType
        assert returnType instanceof ParameterizedType
        assert returnType.rawType == List.class

     * @throws IllegalAccessRuntimeException
     *             {@link IllegalAccessException}が発生した場合
     * @see #getString(Field, Object)
     */
    public static String getString(final Field field) throws IllegalAccessRuntimeException {
        assertArgumentNotNull("field", field);

        return getString(field, null);
    }

    /**
     * {@link Field}の値を {@link String}として取得します。
     *
     * @param field

import org.gradle.tooling.provider.model.ToolingModelBuilder
import javax.inject.Inject

apply plugin: CustomPlugin

class CustomModel implements Serializable {
    String getValue() { 'greetings' }
    Set<CustomThing> getThings() { return [new CustomThing()] }
    Map<String, CustomThing> getThingsByName() { return [thing: new CustomThing()] }
}
class CustomThing implements Serializable {
}
class CustomBuilder implements ToolingModelBuilder {

}

class CustomModel implements Serializable {
    static final INSTANCE = new CustomThing()
    String getValue() { 'greetings' }
    CustomThing getThing() { return INSTANCE }
    Set<CustomThing> getThings() { return [INSTANCE] }
    Map<String, CustomThing> getThingsByName() { return [child: INSTANCE] }
    CustomThing findThing(String name) { return INSTANCE }
}

class CustomThing implements Serializable {
}

  private final TestByteSink byteSink;

  public TestCharSink(TestOption... options) {
    this.byteSink = new TestByteSink(options);
  }

  public String getString() {
    return new String(byteSink.getBytes(), UTF_8);
  }

  @Override
  public boolean wasStreamOpened() {
    return byteSink.wasStreamOpened();
  }

  @Override
  public boolean wasStreamClosed() {

        fun fromJson(jsonObject: JSONObject): ParallelizationMethod {
            val methodJsonObject = jsonObject.getJSONObject("parallelizationMethod") ?: return None
            return when (methodJsonObject.getString("name")) {
                null -> None
                TestDistribution::class.simpleName -> TestDistribution

    public static class TestClass4 {
        @Option(option = 'stringValue', description = "string value")
        public void setStrings(String value1, String value2) {
        }
    }

    public static class TestClass5 {
        @Option(option = 'fileValue', description = "file value")
        public void setStrings(File file) {
        }
    }

    public static class TestClassWithOptionNameClashing {

                            // item is not form field.
                        } else {
                            String name = item.getFieldName();
                            String value = item.getString();
                            response.getWriter().write(name + "," + value);
                        }
                    }
                } catch (FileUploadException e) {
                    e.printStackTrace();