// Clone returns a copy of PodResourceAllocation
func (pr PodResourceAllocation) Clone() PodResourceAllocation {
	prCopy := make(PodResourceAllocation)
	for pod := range pr {
		prCopy[pod] = make(map[string]v1.ResourceList)
		for container, alloc := range pr[pod] {
			prCopy[pod][container] = alloc.DeepCopy()
		}
	}
	return prCopy
}

// Reader interface used to read current pod resource allocation state
type Reader interface {

        sysProps["prop1"] = "true"
        sysProps["prop2"] = ""
        sysProps["prop3"] = "false"
        sysProps["prop4"] = "not anything much"

        expect:
        def value1 = options.getOption(new InternalFlag("prop1", false))
        value1.get()
        value1.explicit

        def value2 = options.getOption(new InternalFlag("prop2", false))
        value2.get()
        value2.explicit

def getProp1() {
    return "abc"
}

@groovy.transform.Field
String prop2

@groovy.transform.Field
String prop3 = "abc"

int prop4 = 12

prop2 = prop1

assert prop1 == "abc"
assert prop2 == "abc"
assert prop3 == "abc"
assert prop4 == 12
"""
        file("child1/build.gradle") << """
try {
    prop1
    assert false
} catch(MissingPropertyException e) {

        Properties prop1 = new Properties();
        prop1.setProperty("jcifs.smb.client.minVersion", "SMB302");
        PropertyConfiguration p1 = new PropertyConfiguration(prop1);
        assertEquals(DialectVersion.SMB302, p1.getMinimumVersion());
        assertEquals(DialectVersion.SMB302, p1.getMaximumVersion());

        Properties prop2 = new Properties();

	handler := proxy.NewUpgradeAwareHandler(location, transport, wrapTransport, upgradeRequired, proxy.NewErrorResponder(responder))
	handler.MaxBytesPerSec = capabilities.Get().PerConnectionBandwidthLimitBytesPerSec
	return handler

     * Get the proxy port.
     *
     * @return proxy server port
     */
    public int getPort() {
        return port;
    }

    /**
     * Set the proxy port.
     *
     * @param port proxy server port
     */
    public void setPort(int port) {
        this.port = port;
    }

    /**
     * Get the proxy username.
     *
     * @return username for the proxy server
     */

func (cfg *config) proxyForURL(reqURL *url.URL) (*url.URL, error) {
	var proxy *url.URL
	if reqURL.Scheme == "https" {
		proxy = cfg.httpsProxy
	} else if reqURL.Scheme == "http" {
		proxy = cfg.httpProxy
		if proxy != nil && cfg.CGI {
			return nil, errors.New("refusing to use HTTP_PROXY value in CGI environment; see golang.org/s/cgihttpproxy")
		}
	}
	if proxy == nil {
		return nil, nil
	}

	list []proxySpec
	err  error
}

type proxySpec struct {
	// url is the proxy URL or one of "off", "direct", "noproxy".
	url string

	// fallBackOnError is true if a request should be attempted on the next proxy
	// in the list after any error from this proxy. If fallBackOnError is false,
	// the request will only be attempted on the next proxy if the error is
	// equivalent to os.ErrNotFound, which is true for 404 and 410 responses.

	handler := proxy.NewUpgradeAwareHandler(location, transport, wrapTransport, upgradeRequired, proxy.NewErrorResponder(responder))
	handler.MaxBytesPerSec = capabilities.Get().PerConnectionBandwidthLimitBytesPerSec
	return handler

            class Thing {
                def prop1 = { it }
            }
            convention.plugins.thing = new Thing()
            ext.prop2 = { it / 2 }

            assert prop1(12) == 12
            assert prop2(12) == 6
        """
        file("child1/build.gradle") << """
            ext.prop3 = { it * 2 }
            assert prop1(12) == 12
            assert prop2(12) == 6
            assert prop3(12) == 24