void testFileTypeChecks() throws CIFSException {
            // Given
            when(mockResource.isFile()).thenReturn(true);
            when(mockResource.isDirectory()).thenReturn(false);
            when(mockResource.isHidden()).thenReturn(false);

            // When
            boolean isFile = mockResource.isFile();
            boolean isDirectory = mockResource.isDirectory();

    }

    gradlebuild.docs.dsl.docbook.model.ClassDoc findClassDoc(String className) {
        gradlebuild.docs.dsl.docbook.model.ClassDoc classDoc = classes[className]
        if (classDoc == null && getFileForClass(className).isFile()) {
            return getClassDoc(className)
        }
        return classDoc
    }

    gradlebuild.docs.dsl.docbook.model.ClassDoc getClassDoc(String className) {

		logger.Fatal(err, "Failed to connect to KMS")
	}
	GlobalKMS = KMS
}

func getTLSConfig() (x509Certs []*x509.Certificate, manager *certs.Manager, secureConn bool, err error) {
	if !isFile(getPublicCertFile()) || !isFile(getPrivateKeyFile()) {
		return nil, nil, false, nil
	}

	if x509Certs, err = config.ParsePublicCertFile(getPublicCertFile()); err != nil {
		return nil, nil, false, err
	}

                            file("test-api-changes.json"),
                            rootProject.layout.projectDirectory,
                            newUpgradedPropertiesFile.get().asFile,
                            oldUpgradedPropertiesFile.get().asFile,
                            object : Action<me.champeau.gradle.japicmp.report.RichReport> {

    return FilePredicate.IS_DIRECTORY;
  }

  /**
   * Returns a predicate that returns the result of {@link File#isFile} on input files.
   *
   * @since 15.0
   */
  public static Predicate<File> isFile() {
    return FilePredicate.IS_FILE;
  }

  private enum FilePredicate implements Predicate<File> {
    IS_DIRECTORY {
      @Override
      public boolean apply(File file) {

        }

        @Test
        void testIsFile() throws SmbException {
            // Arrange
            doReturn(true).when(smbFile).isFile();

            // Act & Assert
            assertTrue(smbFile.isFile());
        }

        @Test
        void testCanRead() throws SmbException {
            // Arrange
            doReturn(false).when(smbFile).isDirectory();

                    logger.debug("generator path: {}", s);
                }
                return s;
            }).allMatch(s -> {
                final boolean found = new File(s).isFile();
                if (found && logger.isDebugEnabled()) {
                    logger.debug("Generator command found: {}", s);
                }
                return found;
            });
        } else {

		// Upon error just return Go-syntax representation of the value
		return fmt.Sprintf("%#v", req)
	}

	// Formatted string.
	return strings.TrimSpace(buffer.String())
}

// isFile - returns whether given path is a file or not.
func isFile(path string) bool {
	if fi, err := os.Stat(path); err == nil {
		return fi.Mode().IsRegular()
	}

	return false
}

// UTCNow - returns current UTC time.

        return artifacts.map(RepositoryUtils::toArtifact);
    }

    private boolean isRegularFile(Artifact artifact) {
        return artifact.getFile() != null && artifact.getFile().isFile();
    }

    private void installIntoProjectLocalRepository(Artifact artifact) {
        String extension = artifact.getExtension();
        String classifier = artifact.getClassifier();

     *
     * @return <code>true</code> if this <code>SmbResource</code> is not a directory
     * @throws CIFSException if an error occurs accessing the resource
     */
    boolean isFile() throws CIFSException;

    /**
     * Tests to see if the file this <code>SmbResource</code> represents is a directory.
     *
     * @return <code>true</code> if this <code>SmbResource</code> is a directory