Path temp = createTempFile();
    assertTrue(Files.exists(temp));
    Files.delete(temp);
    assertFalse(Files.exists(temp));

    MoreFiles.touch(temp);
    assertTrue(Files.exists(temp));
    MoreFiles.touch(temp);
    assertTrue(Files.exists(temp));
  }

  public void testTouchTime() throws IOException {
    Path temp = createTempFile();
    assertTrue(Files.exists(temp));

  }

  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(

            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);

              SmbFile f = new SmbFile(r, "enum-test/a/b/c/") ) {
            f.exists();
        }

    }


    @Test
    public void testEnumDeepVirgin () throws IOException {

        try ( SmbFile r = getDefaultShareRoot();
              SmbFile f = new SmbFile(r, "x-test/") ) {
            if ( !f.exists() ) {
                f.mkdirs();
            }
        }

    // 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:

        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setCreatedTime_Exists() {
        setCreatedTime_Exists(null);
    }

    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
        ExistsQueryBuilder builder = regExistsQ("createdTime");
        if (opLambda != null) {

        "There are currently no logon servers available to service the logon request.", "The specified user already exists.",
        "The specified user does not exist.", "The specified network password is not correct.", "Logon failure: unknown user name or bad password.",
        "Logon failure: user account restriction.", "Logon failure: account logon time restriction violation.",

        // No project, but most certainly a dependency which has been built previously
        File packagedArtifactFile = findInProjectLocalRepository(artifact);
        if (packagedArtifactFile != null && packagedArtifactFile.exists()) {
            return packagedArtifactFile;
        }

        return null;
    }

    public List<String> findVersions(Artifact artifact) {
        List<String> versions = getProjects()

                        getLogger().debug(metadata + " could not be found on repository: " + repository.getId());

                        // delete the local copy so the old details aren't used.
                        if (file.exists()) {
                            if (!file.delete()) {
                                // sleep for 10ms just in case this is windows holding a file lock
                                try {

            try {
                f.renameTo(f2);
                try {
                    assertTrue(f2.exists());
                    renamed = true;
                }
                finally {
                    f2.delete();
                }
            }
            finally {
                if ( !renamed && f.exists() ) {
                    f.delete();
                }
            }
        }
    }