| package org.eclipse.aether.internal.test.util; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import java.io.BufferedOutputStream; |
| import java.io.File; |
| import java.io.FileInputStream; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.io.OutputStream; |
| import java.io.RandomAccessFile; |
| import java.nio.charset.StandardCharsets; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Properties; |
| import java.util.UUID; |
| |
| /** |
| * Provides utility methods to read and write (temporary) files. |
| */ |
| public class TestFileUtils |
| { |
| |
| private static final File TMP = new File( System.getProperty( "java.io.tmpdir" ), "aether-" |
| + UUID.randomUUID().toString().substring( 0, 8 ) ); |
| |
| static |
| { |
| Runtime.getRuntime().addShutdownHook( new Thread() |
| { |
| @Override |
| public void run() |
| { |
| try |
| { |
| deleteFile( TMP ); |
| } |
| catch ( IOException e ) |
| { |
| e.printStackTrace(); |
| } |
| } |
| } ); |
| } |
| |
| private TestFileUtils() |
| { |
| // hide constructor |
| } |
| |
| public static void deleteTempFiles() |
| throws IOException |
| { |
| deleteFile( TMP ); |
| } |
| |
| public static void deleteFile( File file ) |
| throws IOException |
| { |
| if ( file == null ) |
| { |
| return; |
| } |
| |
| Collection<File> undeletables = new ArrayList<File>(); |
| |
| delete( file, undeletables ); |
| |
| if ( !undeletables.isEmpty() ) |
| { |
| throw new IOException( "Failed to delete " + undeletables ); |
| } |
| } |
| |
| private static void delete( File file, Collection<File> undeletables ) |
| { |
| String[] children = file.list(); |
| if ( children != null ) |
| { |
| for ( String child : children ) |
| { |
| delete( new File( file, child ), undeletables ); |
| } |
| } |
| |
| if ( !del( file ) ) |
| { |
| undeletables.add( file.getAbsoluteFile() ); |
| } |
| } |
| |
| private static boolean del( File file ) |
| { |
| for ( int i = 0; i < 10; i++ ) |
| { |
| if ( file.delete() || !file.exists() ) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| public static boolean mkdirs( File directory ) |
| { |
| if ( directory == null ) |
| { |
| return false; |
| } |
| |
| if ( directory.exists() ) |
| { |
| return false; |
| } |
| if ( directory.mkdir() ) |
| { |
| return true; |
| } |
| |
| File canonDir = null; |
| try |
| { |
| canonDir = directory.getCanonicalFile(); |
| } |
| catch ( IOException e ) |
| { |
| return false; |
| } |
| |
| File parentDir = canonDir.getParentFile(); |
| return ( parentDir != null && ( mkdirs( parentDir ) || parentDir.exists() ) && canonDir.mkdir() ); |
| } |
| |
| public static File createTempFile( String contents ) |
| throws IOException |
| { |
| return createTempFile( contents.getBytes( StandardCharsets.UTF_8 ), 1 ); |
| } |
| |
| public static File createTempFile( byte[] pattern, int repeat ) |
| throws IOException |
| { |
| mkdirs( TMP ); |
| File tmpFile = File.createTempFile( "tmpfile-", ".data", TMP ); |
| writeBytes( tmpFile, pattern, repeat ); |
| return tmpFile; |
| } |
| |
| public static File createTempDir() |
| throws IOException |
| { |
| return createTempDir( "" ); |
| } |
| |
| public static File createTempDir( String suffix ) |
| throws IOException |
| { |
| mkdirs( TMP ); |
| File tmpFile = File.createTempFile( "tmpdir-", suffix, TMP ); |
| deleteFile( tmpFile ); |
| mkdirs( tmpFile ); |
| return tmpFile; |
| } |
| |
| public static long copyFile( File source, File target ) |
| throws IOException |
| { |
| long total = 0; |
| |
| FileInputStream fis = null; |
| OutputStream fos = null; |
| try |
| { |
| fis = new FileInputStream( source ); |
| |
| mkdirs( target.getParentFile() ); |
| |
| fos = new BufferedOutputStream( new FileOutputStream( target ) ); |
| |
| for ( byte[] buffer = new byte[ 1024 * 32 ];; ) |
| { |
| int bytes = fis.read( buffer ); |
| if ( bytes < 0 ) |
| { |
| break; |
| } |
| |
| fos.write( buffer, 0, bytes ); |
| |
| total += bytes; |
| } |
| |
| fos.close(); |
| fos = null; |
| |
| fis.close(); |
| fis = null; |
| } |
| finally |
| { |
| try |
| { |
| if ( fos != null ) |
| { |
| fos.close(); |
| } |
| } |
| catch ( final IOException e ) |
| { |
| // Suppressed due to an exception already thrown in the try block. |
| } |
| finally |
| { |
| try |
| { |
| if ( fis != null ) |
| { |
| fis.close(); |
| } |
| } |
| catch ( final IOException e ) |
| { |
| // Suppressed due to an exception already thrown in the try block. |
| } |
| } |
| } |
| |
| return total; |
| } |
| |
| public static byte[] readBytes( File file ) |
| throws IOException |
| { |
| RandomAccessFile in = null; |
| try |
| { |
| in = new RandomAccessFile( file, "r" ); |
| byte[] actual = new byte[ (int) in.length() ]; |
| in.readFully( actual ); |
| in.close(); |
| in = null; |
| return actual; |
| } |
| finally |
| { |
| try |
| { |
| if ( in != null ) |
| { |
| in.close(); |
| } |
| } |
| catch ( final IOException e ) |
| { |
| // Suppressed due to an exception already thrown in the try block. |
| } |
| } |
| } |
| |
| public static void writeBytes( File file, byte[] pattern, int repeat ) |
| throws IOException |
| { |
| file.deleteOnExit(); |
| file.getParentFile().mkdirs(); |
| OutputStream out = null; |
| try |
| { |
| out = new BufferedOutputStream( new FileOutputStream( file ) ); |
| for ( int i = 0; i < repeat; i++ ) |
| { |
| out.write( pattern ); |
| } |
| out.close(); |
| out = null; |
| } |
| finally |
| { |
| try |
| { |
| if ( out != null ) |
| { |
| out.close(); |
| } |
| } |
| catch ( final IOException e ) |
| { |
| // Suppressed due to an exception already thrown in the try block. |
| } |
| } |
| } |
| |
| public static String readString( File file ) |
| throws IOException |
| { |
| byte[] content = readBytes( file ); |
| return new String( content, StandardCharsets.UTF_8 ); |
| } |
| |
| public static void writeString( File file, String content ) |
| throws IOException |
| { |
| writeBytes( file, content.getBytes( StandardCharsets.UTF_8 ), 1 ); |
| } |
| |
| public static void readProps( File file, Properties props ) |
| throws IOException |
| { |
| FileInputStream fis = null; |
| try |
| { |
| fis = new FileInputStream( file ); |
| props.load( fis ); |
| fis.close(); |
| fis = null; |
| } |
| finally |
| { |
| try |
| { |
| if ( fis != null ) |
| { |
| fis.close(); |
| } |
| } |
| catch ( final IOException e ) |
| { |
| // Suppressed due to an exception already thrown in the try block. |
| } |
| } |
| } |
| |
| public static void writeProps( File file, Properties props ) |
| throws IOException |
| { |
| file.getParentFile().mkdirs(); |
| |
| FileOutputStream fos = null; |
| try |
| { |
| fos = new FileOutputStream( file ); |
| props.store( fos, "aether-test" ); |
| fos.close(); |
| fos = null; |
| } |
| finally |
| { |
| try |
| { |
| if ( fos != null ) |
| { |
| fos.close(); |
| } |
| } |
| catch ( final IOException e ) |
| { |
| // Suppressed due to an exception already thrown in the try block. |
| } |
| } |
| } |
| |
| } |