private boolean isNotEmptyDirectory( File file ) { if ( fileSystem.isDirectory( file ) ) { File[] files = fileSystem.listFiles( file ); return files != null && files.length > 0; } return false; }
@Override public boolean isDirectory( File file ) { return fs.isDirectory( file ); }
@Override public boolean isDirectory( File file ) { return delegate.isDirectory( file ); }
private List<File> listFolders( File rootFolder ) { File[] files = fileSystem.listFiles( rootFolder ); return files == null ? Collections.emptyList() : Stream.of( files ) .filter( f -> fileSystem.isDirectory( f ) && StringUtils.isNumeric( f.getName() ) ) .sorted( FILE_COMPARATOR ) .collect( toList() ); }
private static boolean isEmptyDirectory( FileSystemAbstraction fileSystem, File sourceToCompress ) { if ( fileSystem.isDirectory( sourceToCompress ) ) { File[] files = fileSystem.listFiles( sourceToCompress ); return files == null || files.length == 0; } return false; } }
private void listContentOfDirectory( File directory, String prefix, StringBuilder sb ) { if ( !fs.isDirectory( directory ) ) { return; } File[] files = fs.listFiles( directory ); for ( File file : files ) { if ( fs.isDirectory( file ) ) { listContentOfDirectory( file, prefix + File.separator + file.getName(), sb ); } else { sb.append( prefix ).append( file.getName() ).append( System.lineSeparator() ); } } }
private FilenameFilter getNativeIndexFileFilter( File storeDir, boolean inverse ) { FileFilter nativeIndexFilter = new NativeIndexFileFilter( storeDir ); return ( dir, name ) -> { File file = new File( dir, name ); if ( outsideWorld.fileSystem().isDirectory( file ) ) { // Always go down directories return true; } if ( name.equals( FailureStorage.DEFAULT_FAILURE_FILE_NAME ) ) { // Never include failure-storage files return false; } return inverse != nativeIndexFilter.accept( file ); }; }
private static Stream<File> streamFilesRecursiveInner( File directory, FileSystemAbstraction fs ) { File[] files = fs.listFiles( directory ); if ( files == null ) { if ( !fs.fileExists( directory ) ) { return Stream.empty(); } return Stream.of( directory ); } else { return Stream.of( files ) .flatMap( f -> fs.isDirectory( f ) ? streamFilesRecursiveInner( f, fs ) : Stream.of( f ) ); } } }
@Override public boolean isDirectory( File file ) { adversary.injectFailure( SecurityException.class ); return delegate.isDirectory( file ); }
@Override public boolean isDirectory( File file ) { return chooseFileSystem( file ).isDirectory( file ); }
@Before public void setUp() { when( originalIndexStore.getParentFile() ).thenReturn( storeLayout.databaseDirectory() ); when( fs.isDirectory( originalIndexStore ) ).thenReturn( true ); when( fs.listFiles( originalIndexStore ) ).thenReturn( new File[]{mock( File.class )} ); }
private static void move( FileSystemAbstraction fs, File fromDirectory, File toDirectory ) throws IOException { assertTrue( fs.isDirectory( fromDirectory ) ); assertTrue( fs.isDirectory( toDirectory ) ); LogFiles transactionLogFiles = LogFilesBuilder.logFilesBasedOnlyBuilder( fromDirectory, fs ).build(); File[] logFiles = transactionLogFiles.logFiles(); for ( File logFile : logFiles ) { FileOperation.MOVE.perform( fs, logFile.getName(), fromDirectory, false, toDirectory, ExistingTargetStrategy.FAIL ); } }
@Test void streamFilesRecursiveMustCreateMissingPathDirectoriesImpliedByFileRename() throws Exception { File a = existingFile( "a" ); File sub = new File( path, "sub" ); // does not exists File target = new File( sub, "b" ); FileHandle handle = fsa.streamFilesRecursive( a ).findAny().get(); handle.rename( target ); assertTrue( fsa.isDirectory( sub ) ); assertTrue( fsa.fileExists( target ) ); }
private void copyRecursivelyFromOtherFs( File from, FileSystemAbstraction fromFs, File to, ByteBuffer buffer ) throws IOException { this.mkdirs( to ); for ( File fromFile : fromFs.listFiles( from ) ) { File toFile = new File( to, fromFile.getName() ); if ( fromFs.isDirectory( fromFile ) ) { copyRecursivelyFromOtherFs( fromFile, fromFs, toFile ); } else { copyFile( fromFile, fromFs, toFile, buffer ); } } }
@Test void streamFilesRecursiveMustDeleteMultipleLayersOfSubDirectoriesIfTheyBecomeEmptyByDelete() throws Exception { File sub = existingDirectory( "sub" ); File subsub = new File( sub, "subsub" ); ensureDirectoryExists( subsub ); File x = new File( subsub, "x" ); ensureExists( x ); fsa.streamFilesRecursive( sub ).forEach( HANDLE_DELETE ); assertFalse( fsa.isDirectory( subsub ) ); assertFalse( fsa.fileExists( subsub ) ); assertFalse( fsa.isDirectory( sub ) ); assertFalse( fsa.fileExists( sub ) ); }
@Test void streamFilesRecursiveMustDeleteSubDirectoriesEmptiedByFileDelete() throws Exception { File sub = existingDirectory( "sub" ); File x = new File( sub, "x" ); ensureExists( x ); fsa.streamFilesRecursive( sub ).forEach( HANDLE_DELETE ); assertFalse( fsa.isDirectory( sub ) ); assertFalse( fsa.fileExists( sub ) ); }
@Test void streamFilesRecursiveMustNotDeleteDirectoriesAboveBaseDirectoryIfTheyBecomeEmptyByDelete() throws Exception { File sub = existingDirectory( "sub" ); File subsub = new File( sub, "subsub" ); File subsubsub = new File( subsub, "subsubsub" ); ensureDirectoryExists( subsub ); ensureDirectoryExists( subsubsub ); File x = new File( subsubsub, "x" ); ensureExists( x ); fsa.streamFilesRecursive( subsub ).forEach( HANDLE_DELETE ); assertFalse( fsa.fileExists( subsubsub ) ); assertFalse( fsa.isDirectory( subsubsub ) ); assertFalse( fsa.fileExists( subsub ) ); assertFalse( fsa.isDirectory( subsub ) ); assertTrue( fsa.fileExists( sub ) ); assertTrue( fsa.isDirectory( sub ) ); }
@Test void streamFilesRecursiveMustDeleteMultipleLayersOfSubDirectoriesIfTheyBecomeEmptyByRename() throws Exception { File sub = existingDirectory( "sub" ); File subsub = new File( sub, "subsub" ); ensureDirectoryExists( subsub ); File x = new File( subsub, "x" ); ensureExists( x ); File target = nonExistingFile( "target" ); fsa.streamFilesRecursive( sub ).forEach( handleRename( target ) ); assertFalse( fsa.isDirectory( subsub ) ); assertFalse( fsa.fileExists( subsub ) ); assertFalse( fsa.isDirectory( sub ) ); assertFalse( fsa.fileExists( sub ) ); }
@Test void streamFilesRecursiveMustDeleteSubDirectoriesEmptiedByFileRename() throws Exception { File sub = existingDirectory( "sub" ); File x = new File( sub, "x" ); ensureExists( x ); File target = nonExistingFile( "target" ); fsa.streamFilesRecursive( sub ).forEach( handleRename( target ) ); assertFalse( fsa.isDirectory( sub ) ); assertFalse( fsa.fileExists( sub ) ); }
@Test void streamFilesRecursiveMustNotDeleteDirectoriesAboveBaseDirectoryIfTheyBecomeEmptyByRename() throws Exception { File sub = existingDirectory( "sub" ); File subsub = new File( sub, "subsub" ); File subsubsub = new File( subsub, "subsubsub" ); ensureDirectoryExists( subsub ); ensureDirectoryExists( subsubsub ); File x = new File( subsubsub, "x" ); ensureExists( x ); File target = nonExistingFile( "target" ); fsa.streamFilesRecursive( subsub ).forEach( handleRename( target ) ); assertFalse( fsa.fileExists( subsubsub ) ); assertFalse( fsa.isDirectory( subsubsub ) ); assertFalse( fsa.fileExists( subsub ) ); assertFalse( fsa.isDirectory( subsub ) ); assertTrue( fsa.fileExists( sub ) ); assertTrue( fsa.isDirectory( sub ) ); }