return hierarchy.getNodesAccessing(location.absolutePath)
    }

    static Spec<FileTreeElement> includes(String include) {
        return new PatternSet().include(include).asSpec
    }

    static Spec<FileTreeElement> excludes(String exclude) {
        return new PatternSet().exclude(exclude).asSpec
    }

    void assertNodesAccessing(String location, Node... expectedNodeList) {

        included file('.git', 'abc')
        excluded file('foo', '.DS_Store')
    }

    boolean included(FileTreeElement file) {
        patternSet.asSpec.isSatisfiedBy(file)
    }

    boolean excluded(FileTreeElement file) {
        !patternSet.asSpec.isSatisfiedBy(file)
    }

    private static FileTreeElement element(boolean isFile, String... elements) {
        [

		return nil, err
	}
	gwSpec := componentSpec.(*v1alpha1.GatewaySpec)
	k8s := gwSpec.K8S
	switch componentName {
	case name.IngressComponentName:
		setYAMLNodeByMapPath(iopt, util.PathFromString("gateways.istio-ingressgateway.name"), gwSpec.Name)
		if len(gwSpec.Label) != 0 {
			setYAMLNodeByMapPath(iopt, util.PathFromString("gateways.istio-ingressgateway.labels"), gwSpec.Label)
		}

        }
        byte[] ivec = new byte[8];
        IvParameterSpec params = new IvParameterSpec(ivec);

        SecretKeySpec skSpec = new SecretKeySpec(key.getEncoded(), "DES");
        SecretKey sk = skSpec;

        cipher.init(Cipher.DECRYPT_MODE, sk, params);

        byte[] result;
        result = cipher.doFinal(data);

        decrypt = new byte[result.length];

        this.lowestTestedVersion = GradleVersion.version(lowestTestedVersion);
    }

    public Spec<GradleVersion> toSpec(String constraint) {
        String trimmed = constraint.trim();
        if (trimmed.equals("current")) {
            return new Spec<GradleVersion>() {
                @Override
                public boolean isSatisfiedBy(GradleVersion element) {

#include "tensorflow/c/experimental/ops/gen/cpp/views/op_argument_view.h"
#include "tensorflow/c/experimental/ops/gen/model/op_spec.h"
#include "tensorflow/core/lib/strings/str_util.h"
#include "tensorflow/core/platform/logging.h"

namespace tensorflow {
namespace generator {
namespace cpp {

OpView::OpView(OpSpec op)
    : op_(op),
      input_args_(op_.Inputs().begin(), op_.Inputs().end()),

// license that can be found in the LICENSE file.

// Test for issue 778: Map key values that are assignment
// compatible with the map key type must be accepted according
// to the spec: https://golang.org/doc/go_spec.html#Indexes .

package main

type T2 struct {
	x int
}

func (t *T2) f() int { return t.x }

func main() {
	type B bool
	b := B(false)
	mb := make(map[B]int)

    }

    private static <T> Spec<T> doUnion(Collection<? extends Spec<? super T>> specs) {
        List<Spec<? super T>> filtered = new ArrayList<Spec<? super T>>(specs.size());
        for (Spec<? super T> spec : specs) {
            if (spec == SATISFIES_ALL) {
                return satisfyAll();
            }
            if (spec != SATISFIES_NONE) {
                filtered.add(spec);
            }
        }

# limitations under the License.

# Script to fetch latest openapi spec.
# Puts the updated spec at api/openapi-spec/

set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/..
DISCOVERY_ROOT_DIR="${KUBE_ROOT}/api/discovery"
OPENAPI_ROOT_DIR="${KUBE_ROOT}/api/openapi-spec"
source "${KUBE_ROOT}/hack/lib/init.sh"

kube::util::require-jq
kube::golang::setup_env

# We should run `hack/update-openapi-spec.sh` if OpenAPI specification is out of
# date.
# Usage: `hack/verify-openapi-spec.sh`.

set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/..

source "${KUBE_ROOT}/hack/lib/verify-generated.sh"