}

                    ModelProperty<?> property = schema.getProperty(name);

                    Object value = doGet(property, name);
                    propertyViews.put(name, value);
                    return value;
                }

                private <T> T doGet(ModelProperty<T> property, String propertyName) {
                    ModelType<T> propertyType = property.getType();

    }

    private static boolean doGet(Properties userProperties, String key, boolean def) {
        return doGet(userProperties != null ? userProperties.get(key) : null, def);
    }

    private static boolean doGet(Map<String, ?> userProperties, String key, boolean def) {
        return doGet(userProperties != null ? userProperties.get(key) : null, def);
    }

    private static boolean doGet(Object val, boolean def) {

        try (final ResponseData responseData = storageClient.doGet("storage://fess/none")) {
            fail();
        } catch (ChildUrlsException e) {
            String[] values = e.getChildUrlList().stream().map(d -> d.getUrl()).sorted().toArray(n -> new String[n]);
            assertEquals(0, values.length);
        }
        try (final ResponseData responseData = storageClient.doGet("")) {
            fail();

    @Override
    public V get(K key, Function<? super K, ? extends V> factory) {
        V value = doGet(key);
        if (value == null) {
            value = factory.apply(key);
            doCache(key, value);
        }

        return value;
    }

    @Override
    public V getIfPresent(K key) {
        return doGet(key);
    }

    @Override
    public void put(K key, V value) {
        doCache(key, value);

        this.client = client;
    }

    // public methods belongs to your API
    public byte[] doRawGet(String url) {
        GetMethod method = new GetMethod(url);
        try {
            int statusCode = doGet(method);
            return method.getResponseBody();

        } catch (Exception e) {
            ExceptionUtils.rethrow(e); // this dependency is internal only
        } finally {
            method.releaseConnection();

        this.client = client;
    }

    // public methods belongs to your API
    public byte[] doRawGet(String url) {
        GetMethod method = new GetMethod(url);
        try {
            int statusCode = doGet(method);
            return method.getResponseBody();

        } catch (Exception e) {
            ExceptionUtils.rethrow(e); // this dependency is internal only
        } finally {
            method.releaseConnection();

}

type getter[T any] interface {
	get() T
}

//go:noinline
func doGet[T any](i getter[T]) T {
	return i.get()
}

//go:noline
func doGet2[T any](i interface{}) T {
	i2 := i.(getter[T])
	return i2.get()
}

func main() {
	a := A[int]{B: B[int]{3}}
	var i getter[int] = &a

	if got, want := doGet(i), 3; got != want {
		panic(fmt.Sprintf("got %v, want %v", got, want))
	}

        this.client = client;
    }

    // public methods belongs to your API
    public byte[] doRawGet(String url) {
        HttpGet request = new HttpGet(url);
        try {
            HttpEntity entity = doGet(request);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            entity.writeTo(baos);
            return baos.toByteArray();
        } catch (Exception e) {

        this.client = client;
    }

    // public methods belongs to your API
    public byte[] doRawGet(String url) {
        HttpGet request = new HttpGet(url);
        try {
            HttpEntity entity = doGet(request);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            entity.writeTo(baos);
            return baos.toByteArray();
        } catch (Exception e) {

     *
     * <p>The returned {@link BuildableExpectedRequest} can be used to modify the behaviour or expectations.
     */
    public BuildableExpectedRequest get(String path) {
        return doGet(path);
    }

    private ExpectMethod doGet(String path) {
        return new ExpectMethod("GET", normalizePath(path), timeout, lock);
    }

    /**
     * Expect a PUT request to the given path, discard the request body
     */