assert.Equal(t, exp, got)

	got = kubelet.getPodPluginDir("abc123", "foobar")
	exp = filepath.Join(root, "pods/abc123/plugins/foobar")
	assert.Equal(t, exp, got)

	got = kubelet.getVolumeDevicePluginsDir()
	exp = filepath.Join(root, "plugins")
	assert.Equal(t, exp, got)

	got = kubelet.getVolumeDevicePluginDir("foobar")
	exp = filepath.Join(root, "plugins", "foobar", "volumeDevices")
	assert.Equal(t, exp, got)

        path(':foo:bar').takeFirstSegments(1) == path(':foo')
        path(':foo:bar').takeFirstSegments(2) == path(':foo:bar')
        path(':foo:bar:baz').takeFirstSegments(2) == path(':foo:bar')
    }

    def "can take first n segments without incurring unnecessary copies"() {
        given:
        def path = path(':foo:bar')

        expect:

                }

                @TaskAction
                void useIt() {
                    assert foo.get() == "foobar"
                }
            }
            tasks.register("mytask", MyTask) {
                conventionMapping.map("foo", { providerFactory.provider { "foobar" } })
                other.convention("other")
            }
        """

        expect:
        runAndFail 'mytask'

    def assertCleanTasksRunBeforeGenerationTasks() {
        [":", ":foo", ":foo:bar"].each { projectPath ->
            getGenerationTaskNames(projectPath).each { taskName ->
                result.assertTaskOrder(getCleanTaskName(taskName), taskName)
            }
        }
    }

    def assertGenerationTasksRunBeforeCleanTasks() {
        [":", ":foo", ":foo:bar"].each { projectPath ->

        given:
        boolean expectedTransitive = false;
        final Map<String, Object> mapNotation = GUtil.map("path", ":foo:bar", "configuration", "compile", "transitive", expectedTransitive);

        and:
        projectFinder.getProject(':foo:bar') >> projectDummy

        when:
        def projectDependency = factory.createFromMap(projectFinder, mapNotation);

        then:

				{Kind: rbacv1.UserKind, Name: "foobar"},
			},
			user:      &user.DefaultInfo{Name: "foobar"},
			appliesTo: true,
			index:     0,
			testCase:  "single subject that matches username",
		},
		{
			subjects: []rbacv1.Subject{
				{Kind: rbacv1.UserKind, Name: "barfoo"},
				{Kind: rbacv1.UserKind, Name: "foobar"},
			},
			user:      &user.DefaultInfo{Name: "foobar"},
			appliesTo: true,
			index:     1,

// RUN: tf-opt -tfl-trim-funcs-tf="trim-funcs-allowlist=bar,foobar" %s | FileCheck %s

func.func @foo(%arg0: tensor<1x4xf32>, %arg1: tensor<1x4xf32>) -> tensor<1x4xf32> {
  func.return %arg0 : tensor<1x4xf32>
}

func.func @bar(%arg0: tensor<2x4xf32>, %arg1: tensor<2x4xf32>) -> tensor<2x4xf32> {
  func.return %arg0 : tensor<2x4xf32>
}

func.func @foobar(%arg0: tensor<1x4xf32>, %arg1: tensor<1x4xf32>) -> tensor<1x4xf32> {

        where:
        notation << [
                "foo:bar",
                "foo:bar:",
                "foo::1.0",
                ":bar:1.0"
        ]
    }

    def "invalid string notation #notation is reported for lenient parser"() {
        when:

    }

    def "suggests model paths with Levenshtein distance lower than 4"() {
        when:
        availablePaths = ["task.afoobar", "tasks.boofar", "tasks.foobar", "tasks.f", "fooba"]

        then:
        suggestionsFor("tasks.fooba") == ["tasks.foobar", "task.afoobar", "tasks.boofar"]
    }

    def "suggests model paths with Levenshtein distance lower than half it's length for strings shorter than 6 characters"() {

  }
}

// -----

// CHECK-LABEL: @export_as_self
module @export_as_self attributes {tf_saved_model.semantics} {
  // CHECK: func @foobar
  // CHECK: func @baz
  // CHECK: func private @foobar_internal
  func.func @foobar()
    attributes {tf_saved_model.exported_names = ["foobar", "baz"]}
  {
    func.return
  }