then:
        file("build/repo/org/gradle/test/1.0/test-1.0.jar").exists()
        file("build/repo/org/gradle/test/1.0/test-1.0.jar.md5").exists()
        file("build/repo/org/gradle/test/1.0/test-1.0.jar.sha1").exists()
        file("build/repo/org/gradle/test/1.0/test-1.0.jar.sha256").exists()
        file("build/repo/org/gradle/test/1.0/test-1.0.jar.sha512").exists()

        when:
        fails "publish", "-PjarEnabled=false"

            inputFile.text = "input"
        }

        void outputsHaveBeenRemoved() {
            assert !outputFile.exists()
            assert !file(outputDir).exists()
        }

        void onlyOutputFileHasBeenRemoved() {
            assert !outputFile.exists()
            assert file(outputDir).exists()
        }
    }

    @ToBeImplemented("We don't currently clean up local state")

    // Exists to test that our framework doesn't run it:
    @SuppressWarnings("unused")
    @ExampleDerivedFeature.Require({
      ExampleDerivedFeature.DERIVED_FEATURE_1,
      ExampleDerivedFeature.DERIVED_FEATURE_2
    })
    public void testRequiringTwoExplicitDerivedFeatures() throws Exception {
      doNotActuallyRunThis();
    }

    // Exists to test that our framework doesn't run it:

		return err
	}

	// The kubeconfig already exists, let's check if it has got the same CA and server URL
	currentConfig, err := clientcmd.LoadFromFile(kubeConfigFilePath)
	if err != nil {
		return errors.Wrapf(err, "failed to load kubeconfig file %s that already exists on disk", kubeConfigFilePath)
	}

	expectedCtx, exists := config.Contexts[config.CurrentContext]
	if !exists {

  }

  public void testTouch() throws IOException {
    File temp = createTempFile();
    assertTrue(temp.exists());
    assertTrue(temp.delete());
    assertFalse(temp.exists());
    Files.touch(temp);
    assertTrue(temp.exists());
    Files.touch(temp);
    assertTrue(temp.exists());

    assertThrows(
        IOException.class,
        () ->
            Files.touch(

			ready = true
		} else {
			// The check whether there is a probe which hasn't run yet.
			w, exists := m.getWorker(pod.UID, c.Name, readiness)
			ready = !exists // no readinessProbe -> always ready
			if exists {
				// Trigger an immediate run of the readinessProbe to update ready state
				select {
				case w.manualTriggerCh <- struct{}{}:
				default: // Non-blocking.

							ResourceName:  resourceName,
							RestartPolicy: v1.NotRequired,
						})
				}
			}
			if _, exists := obj.Spec.Containers[i].Resources.Requests[v1.ResourceCPU]; exists {
				setDefaultResizePolicy(v1.ResourceCPU)
			}
			if _, exists := obj.Spec.Containers[i].Resources.Requests[v1.ResourceMemory]; exists {
				setDefaultResizePolicy(v1.ResourceMemory)
			}
		}
	}
	for i := range obj.Spec.InitContainers {

            checkConnection(f);
            f.resolve("test").exists();
        }
    }


    @Test
    public void transportReconnects () throws IOException {
        try ( SmbFile f = getDefaultShareRoot() ) {
            // transport disconnects can happen pretty much any time
            assertNotNull(f);
            f.connect();
            f.exists();
            assertNotNull(f);

		expectedCa    *x509.Certificate
	}{
		{ // ca cert does not exists > ca written
			expectedCa: caCert,
		},
		{ // ca cert exists, is ca > existing ca used
			setupFunc: func(pkiDir string) error {
				return writeCertificateAuthorityFilesIfNotExist(pkiDir, "dummy", setupCert, setupKey)
			},
			expectedCa: setupCert,
		},
		{ // some file exists, but it is not a valid ca cert > err
			setupFunc: func(pkiDir string) error {

                }
            }
            """
        when:
        run('assemble')
        then:
        file('build/distributions/myDistribution.zip').exists()
        file('build/distributions/myDistribution.tar').exists()
    }

    def createDistributionWithVersion() {
        given:
        createDir('src/main/dist') {
            file 'file1.txt'
            dir2 {