client := &mockRecyclerClient{
			events: test.eventSequence,
			pod:    test.existingPod,
		}
		err := internalRecycleVolumeByWatchingPodUntilCompletion(test.createPod.Name, test.createPod, client)
		receivedError := ""
		if err != nil {
			receivedError = err.Error()
		}
		if receivedError != test.expectedError {
			t.Errorf("Test %q failed, expected error %q, got %q", test.name, test.expectedError, receivedError)

    }

    def "can pack directory"() {
        def sourceOutputDir = temporaryFolder.file("source").createDir()
        def sourceSubDir = sourceOutputDir.file("subdir").createDir()
        def sourceDataFile = sourceSubDir.file("data.txt")
        sourceDataFile << "output"
        def targetOutputDir = temporaryFolder.file("target").createDir()
        def targetSubDir = targetOutputDir.file("subdir")

  status = env_->CreateDir(filepath);
  EXPECT_PRED2(UnimplementedOrReturnsCode, status, Code::ALREADY_EXISTS);
}

TEST_P(ModularFileSystemTest, TestCreateDirTwice) {
  const std::string dirpath = GetURIForPath("a_dir");
  Status status = env_->CreateDir(dirpath);
  if (!status.ok()) GTEST_SKIP() << "CreateDir() not supported: " << status;

  status = env_->CreateDir(dirpath);

    fun add(diagnostic: KtDiagnosticFactory0, creator: KaFirDiagnostic0Creator) {
        conversions[diagnostic] = creator
    }

    fun <A> add(diagnostic: KtDiagnosticFactory1<A>, creator: KaFirDiagnostic1Creator<A>) {
        conversions[diagnostic] = creator
    }

    fun <A, B> add(diagnostic: KtDiagnosticFactory2<A, B>, creator: KaFirDiagnostic2Creator<A, B>) {
        conversions[diagnostic] = creator

            new ClasspathWalker(TestFiles.fileSystem()),
            new DefaultClasspathBuilder(TestFiles.tmpDirTemporaryFileProvider(tmpDir.createDir("tmp")))
        )
    }

    def "creates JAR file for input directory"() {
        given:
        def inputFilesDir = tmpDir.createDir('inputFiles')
        writeClass(inputFilesDir, "org/gradle/MyClass")

        when:
        relocatedJarCreator.create(outputJar, [inputFilesDir])

}

func TestHasInitialEventsEndBookmarkAnnotation(t *testing.T) {
	createPod := func(name string) *example.Pod {
		return &example.Pod{ObjectMeta: metav1.ObjectMeta{Name: name}}
	}
	createAnnotatedPod := func(name, value string) *example.Pod {
		p := createPod(name)
		p.Annotations = map[string]string{}
		p.Annotations[metav1.InitialEventsAnnotationKey] = value
		return p
	}

		})
		ads.ExpectEmptyResponse()

		// Create pod, due to wildcard subscribe we should receive it
		createPod(s, "pod", "sa", "127.0.0.1", "not-node")
		expect(ads.ExpectResponse(), "Kubernetes//Pod/default/pod")

		// A new pod should push only that one
		createPod(s, "pod2", "sa", "127.0.0.2", "node")
		expect(ads.ExpectResponse(), "Kubernetes//Pod/default/pod2")

    }

    private void init() {
        if (!initialized) {
            userHomeDir = temporaryFolder.testDirectory.createDir("maven_home")
            userM2Directory = userHomeDir.createDir(".m2")
            userSettingsFile = userM2Directory.file("settings.xml")
            globalMavenDirectory = userHomeDir.createDir("m2_home")
            globalSettingsFile = globalMavenDirectory.file("conf/settings.xml")

        given:
        settingsFile << """
            include 'a', 'b'
        """
        buildScript """
            task ok
        """
        def a = createDir('a')
        def b = createDir('b')
        def configurationCache = newConfigurationCacheFixture()

        when:
        inDirectory a
        configurationCacheRun ':ok'

        then:

        deletedFiles == [cacheEntry.parentFile]
    }

    def "deletes empty parent directories"() {
        given:
        def grandparent = cacheDir.createDir("a")
        def parent = grandparent.createDir("b")
        def file = parent.createFile("somefile")

        when:
        cleanupAction(finder([file]), { true })
            .clean(cleanableStore, progressMonitor)

        then: