update readme

write better test method names

Author: imetaxas

README.md

@@ -10,29 +10,51 @@ Reality Check is an open source Fluent Assertion framework for Java.
 
 ### Examples
 
+#### Check files in system resources
+  ```
+  Reality.checkThatSystemResource(csvResource.getName()).exists();
+  Reality.checkThatSystemResource(csvResource1).hasSameContentAs(resource1);
+  ```
+#### Check CSV files in system resources
+  ```
+  Reality.checkThatCsvResource(csvResource.getName()).exists();
+  Reality.checkThatCsvResource(csvResource).doesNotExist();
+  ```
 #### Check files
   ```
   Reality.checkThat(file).isNull();
   Reality.checkThat(file).hasSameContentAs(file);
+  Reality.checkThatFile(filePath).exists();
   ```
 #### Check CSV files
   ```
-  Reality.checkThatFileCsv(file1).hasSameContentAs(file2);
-  Reality.checkThatFileCsv(file1).hasNotSameContentAs(file2);
+  Reality.checkThatCsvFile(file1).hasSameContentAs(file1);
+  Reality.checkThatCsvFile(file1).hasNotSameContentAs(file2);
+  Reality.checkThatCsvFile(filename).headerHasNoDigits();
   ```
 #### Check CSV strings
   ```
-  Reality.checkThatCsv(csvString1).hasSameContentAs(csvString2);
+  Reality.checkThatCsv(csvString1).hasSameContentAs(csvString1);
   Reality.checkThatCsv(csvString1).hasNotSameContentAs(csvString2);
   ```
 #### Check strings
   ```
   Reality.checkThat(string).isNotNull();
   Reality.checkThat(string).hasLength(12);
   ```
+#### Check integers
+  ```
+  Reality.checkThat(1).isEqualTo(1);
+  Reality.checkThat(1).isNotEqualTo(2);
+  ```
+#### Check booleans
+  ```
+  Reality.checkThat(true).isTrue();
+  Reality.checkThat(false).isFalse();
+  ```
 #### Check InputStreams
   ```
-  Reality.checkThat(new ByteArrayInputStream(byteArray1)).hasSameContentAs(new ByteArrayInputStream(byteArray2));
+  Reality.checkThat(new ByteArrayInputStream(byteArray1)).hasSameContentAs(new ByteArrayInputStream(byteArray1));
   Reality.checkThat(new ByteArrayInputStream(byteArray1)).hasNotSameContentAs(new ByteArrayInputStream(byteArray2));
   ```
 #### Check with custom message
@@ -41,6 +63,7 @@ Reality Check is an open source Fluent Assertion framework for Java.
   Reality.checkWithMessage("String has wrong length").that(string).hasLength(6);
   Reality.checkWithMessage("InputStream is NULL").that(new ByteArrayInputStream(byteArray)).isNotNull();
   Reality.checkWithMessage("Files have different content").thatCsvFile(file).hasSameContentAs(file);
+  Reality.checkWithMessage("Boolean is false").that(true).isTrue();
   ```
 #### Do multiple checks
   ```

src/main/java/com/yanimetaxas/realitycheck/asserter/AbstractAssert.java

@@ -23,36 +23,36 @@ public AbstractAssert(ACTUAL actual, String customMessage) {
   @Override
   public SELF isNull() {
     if (this.actual != null) {
-      throwProperAssertionError("Subject is NULL");
+      throwAssertionErrorWithCustomMessage("Subject is NULL");
     }
     return self;
   }
 
   @Override
   public SELF isNotNull() {
     if (this.actual == null) {
-      throwProperAssertionError("Subject is not NULL");
+      throwAssertionErrorWithCustomMessage("Subject is not NULL");
     }
     return self;
   }
 
   @Override
   public SELF isEqualTo(ACTUAL expected) {
     if (!this.actual.equals(expected)) {
-      throwProperAssertionError("Subject is not equal");
+      throwAssertionErrorWithCustomMessage("Subject is not equal");
     }
     return self;
   }
 
   @Override
   public SELF isNotEqualTo(ACTUAL expected) {
     if (this.actual.equals(expected)) {
-      throwProperAssertionError("Subject is equal");
+      throwAssertionErrorWithCustomMessage("Subject is equal");
     }
     return self;
   }
 
-  void throwProperAssertionError(String defaultMessage) {
+  void throwAssertionErrorWithCustomMessage(String defaultMessage) {
     if (customMessage == null) {
       throw new AssertionError(defaultMessage);
     } else {

src/main/java/com/yanimetaxas/realitycheck/asserter/AbstractReadableAssert.java

@@ -32,14 +32,14 @@ public AbstractReadableAssert(ACTUAL actual, String message, ValidationStrategy
 
   public AbstractReadableAssert hasSameContentAs(InputStream expected) throws AssertionError {
     if(!IoUtil.contentEquals(new ByteArrayInputStream(getActualContent()), expected)){
-      throwProperAssertionError("InputStreams are NOT exactly the same");
+      throwAssertionErrorWithCustomMessage("InputStreams are NOT exactly the same");
     }
     return self;
   }
 
   public AbstractReadableAssert hasNotSameContentAs(InputStream expected) throws AssertionError {
     if(IoUtil.contentEquals(new ByteArrayInputStream(getActualContent()), expected)){
-      throwProperAssertionError("InputStreams are exactly the same");
+      throwAssertionErrorWithCustomMessage("InputStreams are exactly the same");
     }
     return self;
   }

src/main/java/com/yanimetaxas/realitycheck/asserter/BooleanAssert.java

@@ -16,14 +16,14 @@ public BooleanAssert(Boolean aBoolean, String customMessage) {
 
   public BooleanAssert isTrue() throws AssertionError {
     if(!actual) {
-      throwProperAssertionError("Is false");
+      throwAssertionErrorWithCustomMessage("Is false");
     }
     return self;
   }
 
   public BooleanAssert isFalse() throws AssertionError {
     if(actual) {
-      throwProperAssertionError("Is true");
+      throwAssertionErrorWithCustomMessage("Is true");
     }
     return self;
   }

src/main/java/com/yanimetaxas/realitycheck/asserter/StringAssert.java

@@ -15,91 +15,91 @@ public StringAssert(String string, String message) {
 
   public StringAssert hasLength(int size) throws AssertionError {
     if(actual.length() != size) {
-      throwProperAssertionError("Wrong length");
+      throwAssertionErrorWithCustomMessage("Wrong length");
     }
     return self;
   }
 
   public StringAssert equalsIgnoreCase(String expected) {
     if(!actual.equalsIgnoreCase(expected)) {
-      throwProperAssertionError("Not equal");
+      throwAssertionErrorWithCustomMessage("Not equal");
     }
     return self;
   }
 
   public StringAssert doesNotEqualIgnoreCase(String expected) {
     if(actual.equalsIgnoreCase(expected)) {
-      throwProperAssertionError("Equals");
+      throwAssertionErrorWithCustomMessage("Equals");
     }
     return self;
   }
 
   public StringAssert equals(String expected) {
     if(!actual.equals(expected)) {
-      throwProperAssertionError("Not equal");
+      throwAssertionErrorWithCustomMessage("Not equal");
     }
     return self;
   }
 
   public StringAssert doesNotEqual(String expected) {
     if(actual.equals(expected)) {
-      throwProperAssertionError("Equals");
+      throwAssertionErrorWithCustomMessage("Equals");
     }
     return self;
   }
 
   public StringAssert startsWith(String expected) {
     if(!actual.startsWith(expected)) {
-      throwProperAssertionError("Not start with");
+      throwAssertionErrorWithCustomMessage("Not start with");
     }
     return self;
   }
 
   public StringAssert endsWith(String expected) {
     if(!actual.endsWith(expected)) {
-      throwProperAssertionError("Not end with");
+      throwAssertionErrorWithCustomMessage("Not end with");
     }
     return self;
   }
 
   public StringAssert contains(String expected) {
     if(!actual.contains(expected)) {
-      throwProperAssertionError("Is not contained");
+      throwAssertionErrorWithCustomMessage("Is not contained");
     }
     return self;
   }
 
   public StringAssert doesNotContain(String expected) {
     if(actual.contains(expected)) {
-      throwProperAssertionError("Is contained");
+      throwAssertionErrorWithCustomMessage("Is contained");
     }
     return self;
   }
 
   public StringAssert isEmpty() {
     if(!actual.isEmpty()) {
-      throwProperAssertionError("Is not empty");
+      throwAssertionErrorWithCustomMessage("Is not empty");
     }
     return self;
   }
 
   public StringAssert isNotEmpty() {
     if(actual.isEmpty()) {
-      throwProperAssertionError("Is empty");
+      throwAssertionErrorWithCustomMessage("Is empty");
     }
     return self;
   }
 
   public StringAssert matches(String regex) {
     if(!actual.matches(regex)) {
-      throwProperAssertionError("Regex not matched");
+      throwAssertionErrorWithCustomMessage("Regex not matched");
     }
     return self;
   }
 
   public StringAssert doesNotMatch(String regex) {
     if(actual.matches(regex)) {
-      throwProperAssertionError("Regex matched");
+      throwAssertionErrorWithCustomMessage("Regex matched");
     }
     return self;
   }

src/main/java/com/yanimetaxas/realitycheck/util/IoUtil.java

@@ -32,7 +32,7 @@ private static File isResourceDirectory(String filename) {
     if(dir.isDirectory()){
       return dir;
     }
-    return null;
+    return new File("");
   }
 
   public static File toFile(String filepath) {