package org.testng;
import java.io.File;
import java.io.IOException;
/**
* Assertion tool for File centric assertions.
* Conceptually this is an extension of {@link Assert}
* Presents assertion methods with a more natural parameter order.
* The order is always <B>actualValue</B>, <B>expectedValue</B> [, message].
*
* @author <a href='mailto:pmendelson@trueoutcomes.com'>Paul Mendelon</a>
* @since 5.6
* @version $Revision: 650 $, $Date: 2009-01-05 03:51:54 -0800 (Mon, 05 Jan 2009) $
*/
public class FileAssert {
/**
* Protect constructor since it is a static only class
*/
private FileAssert() {
// hide constructor
}
/**
* Asserts that a {@code tstvalue} is a proper directory. If it isn't,
* an AssertionError, with the given message, is thrown.
* @param tstvalue the file to evaluate
* @param message the assertion error message
*/
static public void assertDirectory(File tstvalue, String message) {
boolean condition=false;
try {
condition=tstvalue.isDirectory();
} catch(SecurityException e) {
failSecurity(e,tstvalue,fileType(tstvalue),"Directory", message);
}
if(!condition) {
failFile(tstvalue,fileType(tstvalue),"Directory", message);
}
}
static public void assertDirectory(File tstvalue) {
assertDirectory(tstvalue, null);
}
/**
* Asserts that a {@code tstvalue} is a proper directory. If it isn't,
* an AssertionError, with the given message, is thrown.
* @param tstvalue the file to evaluate
* @param message the assertion error message
*/
static public void assertFile(File tstvalue, String message) {
boolean condition=false;
try {
condition=tstvalue.isFile();
} catch(SecurityException e) {
failSecurity(e,tstvalue,fileType(tstvalue),"File", message);
}
if(!condition) {
failFile(tstvalue,fileType(tstvalue),"File", message);
}
}
/**
* @see #assertFile(File, String)
*/
static public void assertFile(File tstvalue) {
assertFile(tstvalue, null);
}
/**
* Asserts that a {@code tstvalue} is a file of exactly {@code expected} characters
* or a directory of exactly {@code expected} entries. If it isn't,
* an AssertionError, with the given message, is thrown.
* @param tstvalue the file to evaluate
* @param message the assertion error message
*/
static public void assertLength(File tstvalue, long expected, String message) {
long actual=-1L;
try {
actual=tstvalue.isDirectory()?tstvalue.list().length:tstvalue.length();
} catch(SecurityException e) {
failSecurity(e,tstvalue,String.valueOf(actual),String.valueOf(expected), message);
}
if(actual!=expected) {
failFile(tstvalue,String.valueOf(actual),String.valueOf(expected), message);
}
}
/**
* @see #assertLength(File, long, String)
*/
static public void assertLength(File tstvalue, long expected) {
assertLength(tstvalue, expected, null);
}
/**
* Asserts that a {@code tstvalue} is a file of at least {@code expected} characters
* or a directory of at least {@code expected} entries. If it isn't,
* an AssertionError, with the given message, is thrown.
* @param tstvalue the file to evaluate
* @param message the assertion error message
*/
static public void assertMinLength(File tstvalue, long expected, String message) {
long actual=-1L;
try {
actual=tstvalue.isDirectory()?tstvalue.list().length:tstvalue.length();
} catch(SecurityException e) {
failSecurity(e,tstvalue,String.valueOf(actual),"at least "+String.valueOf(expected), message);
}
if(actual<expected) {
failFile(tstvalue,String.valueOf(actual),"at least "+String.valueOf(expected), message);
}
}
/**
* @see #assertMinLength(File, long, String)
*/
static public void assertMinLength(File tstvalue, long expected) {
assertMinLength(tstvalue, expected, null);
}
/**
* Asserts that a {@code tstvalue} is a file of at most {@code expected} characters
* or a directory of at most {@code expected} entries. If it isn't,
* an AssertionError, with the given message, is thrown.
* @param tstvalue the file to evaluate
* @param message the assertion error message
*/
static public void assertMaxLength(File tstvalue, long expected, String message) {
long actual=-1L;
try {
actual=tstvalue.isDirectory()?tstvalue.list().length:tstvalue.length();
} catch(SecurityException e) {
failSecurity(e,tstvalue,String.valueOf(actual),"at most "+String.valueOf(expected), message);
}
if(actual>expected) {
failFile(tstvalue,String.valueOf(actual),"at most "+String.valueOf(expected), message);
}
}
/**
* @see #assertMaxLength(File, long, String)
*/
static public void assertMaxLength(File tstvalue, long expected) {
assertMaxLength(tstvalue, expected, null);
}
/**
* Asserts that a {@code tstvalue} is readable. If it isn't,
* an AssertionError, with the given message, is thrown.
* @param tstvalue the file to evaluate
* @param message the assertion error message
*/
static public void assertReadable(File tstvalue, String message) {
boolean condition=false;
try {
condition=tstvalue.canRead();
} catch(SecurityException e) {
failSecurity(e,tstvalue,fileAccess(tstvalue),"Read Access", message);
}
if(!condition) {
failFile(tstvalue,fileAccess(tstvalue),"Read Access", message);
}
}
/**
* @see #assertReadable(File, String)
*/
static public void assertReadable(File tstvalue) {
assertReadable(tstvalue, null);
}
/**
* Asserts that a {@code tstvalue} is writeable. If it isn't,
* an AssertionError, with the given message, is thrown.
* @param tstvalue the file to evaluate
* @param message the assertion error message
*/
static public void assertWriteable(File tstvalue, String message) {
boolean condition=false;
try {
condition=tstvalue.canWrite();
} catch(SecurityException e) {
failSecurity(e,tstvalue,fileAccess(tstvalue),"Write Access", message);
}
if(!condition) {
failFile(tstvalue,fileAccess(tstvalue),"Write Access", message);
}
}
/**
* @see #assertWriteable(File, String)
*/
static public void assertWriteable(File tstvalue) {
assertReadable(tstvalue, null);
}
/**
* Asserts that a {@code tstvalue} is readable and writeable. If it isn't,
* an AssertionError, with the given message, is thrown.
* @param tstvalue the file to evaluate
* @param message the assertion error message
*/
static public void assertReadWrite(File tstvalue, String message) {
boolean condition=false;
try {
condition=tstvalue.canRead() && tstvalue.canWrite();
} catch(SecurityException e) {
failSecurity(e,tstvalue,fileAccess(tstvalue),"Read/Write Access", message);
}
if(!condition) {
failFile(tstvalue,fileAccess(tstvalue),"Read/Write Access", message);
}
}
/**
* @see #assertReadWrite(File, String)
*/
static public void assertReadWrite(File tstvalue) {
assertReadWrite(tstvalue, null);
}
/**
* Fails a test with the given message and wrapping the original exception.
*
* @param message the assertion error message
* @param realCause the original exception
*/
static public void fail(String message, Throwable realCause) {
AssertionError ae = new AssertionError(message);
ae.initCause(realCause);
throw ae;
}
/**
* Fails a test with the given message.
* @param message the assertion error message
*/
static public void fail(String message) {
throw new AssertionError(message);
}
/**
* Fails a test with no message.
*/
static public void fail() {
fail(null);
}
/**
* Formats failure for file assertions
*/
private static void failFile(File path, String actual, String expected, String message) {
String formatted = "";
if(message != null) {
formatted = message + " ";
}
fail(formatted + "expected <" + expected +"> but was <" + toString(path) + ">"
+(expected!=null?"<" + expected +">":""));
}
/**
* @param tstvalue
* @param string
* @param string2
* @param message
*/
private static void failSecurity(Exception e, File path, String actual, String expected, String message) {
String formatted = "";
if(message != null) {
formatted = message + " ";
}
fail(formatted + "expected <" + expected +"> but was <" + toString(path) + ">"
+"<"
+ (e!=null && e.getMessage()!=null && e.getMessage().length()>0
?e.getMessage()
:"not authorized by JVM")
+ ">");
}
/**
* String representation of what sort of file {@code path} is.
*/
private static String fileType(File path) {
try {
if(!path.exists())
return "Non existant";
else if (path.isDirectory())
return "Directory";
else if (path.isFile())
return "File";
else
return "Special File";
} catch (SecurityException e) {
return "Unauthorized";
}
}
/**
* String representation of what sort of file {@code path} is.
*/
private static String fileAccess(File path) {
try {
if(!path.exists())
return "Non existant";
else if (path.canWrite() && path.canRead())
return "Read/Write Access";
else if (path.canRead())
return "Read only Access";
else if (path.canWrite())
return "Write only Access";
else
return "No Access";
} catch (SecurityException e) {
return "Unauthorized";
}
}
private static String toString(File path) {
try {
return path.getCanonicalPath();
} catch(IOException e) {
return path.getAbsolutePath();
}
}
}