Replace hamcrest assertions with jUnit assertions

rhowe · spullara · commit 01054a7a038f · 2024-02-26T09:44:11.000-08:00
Hamcrest isn't really adding anything here, so we may as well just use
the junit assertion APIs
diff --git a/compiler/src/test/java/com/github/mustachejava/resolver/ClasspathResolverTest.java b/compiler/src/test/java/com/github/mustachejava/resolver/ClasspathResolverTest.java
@@ -4,58 +4,56 @@
 
 import java.io.Reader;
 
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 
 public class ClasspathResolverTest {
 
     @Test
     public void getReaderNullRootAndResourceHasRelativePath() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver();
         try (Reader reader = underTest.getReader("nested_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
     @Test
     public void getReaderWithRootAndResourceHasRelativePath() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver("templates");
         try (Reader reader = underTest.getReader("absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
     @Test
     public void getReaderWithRootThatHasTrailingForwardSlashAndResourceHasRelativePath() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver("templates/");
         try (Reader reader = underTest.getReader("absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
     @Test
     public void getReaderWithRootAndResourceHasAbsolutePath() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver("templates");
         try (Reader reader = underTest.getReader("/absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
     @Test
     public void getReaderWithRootThatHasTrailingForwardSlashAndResourceHasAbsolutePath() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver("templates/");
         try (Reader reader = underTest.getReader("/absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
     @Test
     public void getReaderNullRootDoesNotFindFileWithAbsolutePath() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver();
         try (Reader reader = underTest.getReader("/nested_partials_template.html")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -75,15 +73,15 @@ public void getReaderNullRootAndNullResourceThrowsNullPointer() throws Exception
     public void getReaderWithRootAndResourceHasDoubleDotRelativePath() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver("templates");
         try (Reader reader = underTest.getReader("absolute/../absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
     @Test
     public void getReaderWithRootAndResourceHasDotRelativePath() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver("templates");
         try (Reader reader = underTest.getReader("absolute/./nested_partials_sub.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
@@ -106,7 +104,7 @@ public void getReaderWithRootAndResourceHasInvalidPathThrows() throws Exception
     public void getReaderNullRootAndResourceIsDirectory() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver();
         try (Reader reader = underTest.getReader("templates/absolute")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -115,7 +113,7 @@ public void getReaderNullRootAndResourceIsDirectory() throws Exception {
     public void getReaderWithRootAndResourceIsDirectory() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver("templates");
         try (Reader reader = underTest.getReader("absolute")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -124,7 +122,7 @@ public void getReaderWithRootAndResourceIsDirectory() throws Exception {
     public void getReaderWithRootAndResourceAboveRoot() throws Exception {
         ClasspathResolver underTest = new ClasspathResolver("templates/absolute");
         try (Reader reader = underTest.getReader("../absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 }
diff --git a/compiler/src/test/java/com/github/mustachejava/resolver/FileSystemResolverTest.java b/compiler/src/test/java/com/github/mustachejava/resolver/FileSystemResolverTest.java
@@ -10,10 +10,8 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.hamcrest.CoreMatchers.nullValue;
-import static org.hamcrest.core.Is.is;
-import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 
 public class FileSystemResolverTest {
 
@@ -23,7 +21,7 @@ public class FileSystemResolverTest {
     public void getReaderDefaultRootAndResourceHasRelativePath() throws Exception {
         FileSystemResolver underTest = new FileSystemResolver();
         try (Reader reader = underTest.getReader(resources + "/nested_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
@@ -32,7 +30,7 @@ public void getReaderFileRootAndResourceHasRelativePath() throws Exception {
         File fileRoot = new File(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(fileRoot);
         try (Reader reader = underTest.getReader("absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
@@ -41,15 +39,15 @@ public void getReaderPathRootAndResourceHasRelativePath() throws Exception {
         Path pathRoot = Paths.get(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(pathRoot);
         try (Reader reader = underTest.getReader("absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
     @Test
     public void getReaderDefaultRootDoesNotFindFileWithAbsolutePath() throws Exception {
         FileSystemResolver underTest = new FileSystemResolver();
         try (Reader reader = underTest.getReader("/" + resources + "/nested_partials_template.html")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -58,7 +56,7 @@ public void getReaderFileRootAndResourceHasAbsolutePath() throws Exception {
         File fileRoot = new File(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(fileRoot);
         try (Reader reader = underTest.getReader("/absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
@@ -67,7 +65,7 @@ public void getReaderPathRootAndResourceHasAbsolutePath() throws Exception {
         Path pathRoot = Paths.get(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(pathRoot);
         try (Reader reader = underTest.getReader("/absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
@@ -95,7 +93,7 @@ public void getReaderPathRootAndNullResourceThrowsNullPointer() throws Exception
     public void getReaderDefaultRootAndResourceHasDoubleDotRelativePath() throws Exception {
         FileSystemResolver underTest = new FileSystemResolver();
         try (Reader reader = underTest.getReader(resources + "/templates_filepath/../nested_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
@@ -104,7 +102,7 @@ public void getReaderFileRootAndResourceHasDoubleDotRelativePath() throws Except
         File fileRoot = new File(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(fileRoot);
         try (Reader reader = underTest.getReader("absolute/../absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
@@ -113,15 +111,15 @@ public void getReaderPathRootAndResourceHasDoubleDotRelativePath() throws Except
         Path pathRoot = Paths.get(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(pathRoot);
         try (Reader reader = underTest.getReader("absolute/../absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
     @Test
     public void getReaderDefaultRootAndResourceHasDotRelativePath() throws Exception {
         FileSystemResolver underTest = new FileSystemResolver();
         try (Reader reader = underTest.getReader(resources + "/templates_filepath/./absolute_partials_template.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
@@ -130,7 +128,7 @@ public void getReaderFileRootAndResourceHasDotRelativePath() throws Exception {
         File fileRoot = new File(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(fileRoot);
         try (Reader reader = underTest.getReader("absolute/./nested_partials_sub.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
@@ -139,15 +137,15 @@ public void getReaderPathRootAndResourceHasDotRelativePath() throws Exception {
         Path pathRoot = Paths.get(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(pathRoot);
         try (Reader reader = underTest.getReader("absolute/./nested_partials_sub.html")) {
-            assertThat(reader, is(notNullValue()));
+            assertNotNull(reader);
         }
     }
 
     @Test
     public void getReaderDefaultRootAndResourceHasInvalidPath() throws Exception {
         FileSystemResolver underTest = new FileSystemResolver();
         try (Reader reader = underTest.getReader("\0")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -156,7 +154,7 @@ public void getReaderFileRootAndResourceHasInvalidPath() throws Exception {
         File fileRoot = new File(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(fileRoot);
         try (Reader reader = underTest.getReader("\0")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -165,7 +163,7 @@ public void getReaderPathRootAndResourceHasInvalidPath() throws Exception {
         Path pathRoot = Paths.get(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(pathRoot);
         try (Reader reader = underTest.getReader("\0")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -176,7 +174,7 @@ public void getReaderPathRootAndNonDefaultFileSystem() throws Exception {
             Path pathRoot = zipFileSystem.getPath("templates");
             FileSystemResolver underTest = new FileSystemResolver(pathRoot);
             try (Reader reader = underTest.getReader("absolute_partials_template.html")) {
-                assertThat(reader, is(notNullValue()));
+                assertNotNull(reader);
             }
         }
     }
@@ -185,7 +183,7 @@ public void getReaderPathRootAndNonDefaultFileSystem() throws Exception {
     public void getReaderDefaultRootAndResourceIsDirectory() throws Exception {
         FileSystemResolver underTest = new FileSystemResolver();
         try (Reader reader = underTest.getReader(resources + "/templates_filepath")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -194,7 +192,7 @@ public void getReaderFileRootAndResourceIsDirectory() throws Exception {
         File fileRoot = new File(resources);
         FileSystemResolver underTest = new FileSystemResolver(fileRoot);
         try (Reader reader = underTest.getReader("templates_filepath")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -203,7 +201,7 @@ public void getReaderPathRootAndResourceIsDirectory() throws Exception {
         Path pathRoot = Paths.get(resources);
         FileSystemResolver underTest = new FileSystemResolver(pathRoot);
         try (Reader reader = underTest.getReader("templates_filepath")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -214,7 +212,7 @@ public void getReaderPathRootAndResourceIsDirectory() throws Exception {
     public void getReaderDefaultRootAndResourceAboveRootNotFound() throws Exception {
         FileSystemResolver underTest = new FileSystemResolver();
         try (Reader reader = underTest.getReader("../this_file_does_not_exist.html")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -230,7 +228,7 @@ public void getReaderFileRootAndResourceAboveRootNotFound() throws Exception {
         File fileRoot = new File(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(fileRoot);
         try (Reader reader = underTest.getReader("../this_file_does_not_exist.html")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 
@@ -246,7 +244,7 @@ public void getReaderPathRootAndResourceAboveRootNotFound() throws Exception {
         Path pathRoot = Paths.get(resources + "/templates_filepath");
         FileSystemResolver underTest = new FileSystemResolver(pathRoot);
         try (Reader reader = underTest.getReader("../this_file_does_not_exist.html")) {
-            assertThat(reader, is(nullValue()));
+            assertNull(reader);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -4,58 +4,56 @@`
`4`	`4`
`5`	`5`	`import java.io.Reader;`
`6`	`6`
`7`		`-import static org.hamcrest.CoreMatchers.notNullValue;`
`8`		`-import static org.hamcrest.CoreMatchers.nullValue;`
`9`		`-import static org.hamcrest.core.Is.is;`
`10`		`-import static org.junit.Assert.assertThat;`
	`7`	`+import static org.junit.Assert.assertNotNull;`
	`8`	`+import static org.junit.Assert.assertNull;`
`11`	`9`
`12`	`10`	`public class ClasspathResolverTest {`
`13`	`11`
`14`	`12`	`@Test`
`15`	`13`	`public void getReaderNullRootAndResourceHasRelativePath() throws Exception {`
`16`	`14`	`ClasspathResolver underTest = new ClasspathResolver();`
`17`	`15`	`try (Reader reader = underTest.getReader("nested_partials_template.html")) {`
`18`		`- assertThat(reader, is(notNullValue()));`
	`16`	`+ assertNotNull(reader);`
`19`	`17`	`}`
`20`	`18`	`}`
`21`	`19`
`22`	`20`	`@Test`
`23`	`21`	`public void getReaderWithRootAndResourceHasRelativePath() throws Exception {`
`24`	`22`	`ClasspathResolver underTest = new ClasspathResolver("templates");`
`25`	`23`	`try (Reader reader = underTest.getReader("absolute_partials_template.html")) {`
`26`		`- assertThat(reader, is(notNullValue()));`
	`24`	`+ assertNotNull(reader);`
`27`	`25`	`}`
`28`	`26`	`}`
`29`	`27`
`30`	`28`	`@Test`
`31`	`29`	`public void getReaderWithRootThatHasTrailingForwardSlashAndResourceHasRelativePath() throws Exception {`
`32`	`30`	`ClasspathResolver underTest = new ClasspathResolver("templates/");`
`33`	`31`	`try (Reader reader = underTest.getReader("absolute_partials_template.html")) {`
`34`		`- assertThat(reader, is(notNullValue()));`
	`32`	`+ assertNotNull(reader);`
`35`	`33`	`}`
`36`	`34`	`}`
`37`	`35`
`38`	`36`	`@Test`
`39`	`37`	`public void getReaderWithRootAndResourceHasAbsolutePath() throws Exception {`
`40`	`38`	`ClasspathResolver underTest = new ClasspathResolver("templates");`
`41`	`39`	`try (Reader reader = underTest.getReader("/absolute_partials_template.html")) {`
`42`		`- assertThat(reader, is(notNullValue()));`
	`40`	`+ assertNotNull(reader);`
`43`	`41`	`}`
`44`	`42`	`}`
`45`	`43`
`46`	`44`	`@Test`
`47`	`45`	`public void getReaderWithRootThatHasTrailingForwardSlashAndResourceHasAbsolutePath() throws Exception {`
`48`	`46`	`ClasspathResolver underTest = new ClasspathResolver("templates/");`
`49`	`47`	`try (Reader reader = underTest.getReader("/absolute_partials_template.html")) {`
`50`		`- assertThat(reader, is(notNullValue()));`
	`48`	`+ assertNotNull(reader);`
`51`	`49`	`}`
`52`	`50`	`}`
`53`	`51`
`54`	`52`	`@Test`
`55`	`53`	`public void getReaderNullRootDoesNotFindFileWithAbsolutePath() throws Exception {`
`56`	`54`	`ClasspathResolver underTest = new ClasspathResolver();`
`57`	`55`	`try (Reader reader = underTest.getReader("/nested_partials_template.html")) {`
`58`		`- assertThat(reader, is(nullValue()));`
	`56`	`+ assertNull(reader);`
`59`	`57`	`}`
`60`	`58`	`}`
`61`	`59`
`@@ -75,15 +73,15 @@ public void getReaderNullRootAndNullResourceThrowsNullPointer() throws Exception`
`75`	`73`	`public void getReaderWithRootAndResourceHasDoubleDotRelativePath() throws Exception {`
`76`	`74`	`ClasspathResolver underTest = new ClasspathResolver("templates");`
`77`	`75`	`try (Reader reader = underTest.getReader("absolute/../absolute_partials_template.html")) {`
`78`		`- assertThat(reader, is(notNullValue()));`
	`76`	`+ assertNotNull(reader);`
`79`	`77`	`}`
`80`	`78`	`}`
`81`	`79`
`82`	`80`	`@Test`
`83`	`81`	`public void getReaderWithRootAndResourceHasDotRelativePath() throws Exception {`
`84`	`82`	`ClasspathResolver underTest = new ClasspathResolver("templates");`
`85`	`83`	`try (Reader reader = underTest.getReader("absolute/./nested_partials_sub.html")) {`
`86`		`- assertThat(reader, is(notNullValue()));`
	`84`	`+ assertNotNull(reader);`
`87`	`85`	`}`
`88`	`86`	`}`
`89`	`87`
`@@ -106,7 +104,7 @@ public void getReaderWithRootAndResourceHasInvalidPathThrows() throws Exception`
`106`	`104`	`public void getReaderNullRootAndResourceIsDirectory() throws Exception {`
`107`	`105`	`ClasspathResolver underTest = new ClasspathResolver();`
`108`	`106`	`try (Reader reader = underTest.getReader("templates/absolute")) {`
`109`		`- assertThat(reader, is(nullValue()));`
	`107`	`+ assertNull(reader);`
`110`	`108`	`}`
`111`	`109`	`}`
`112`	`110`
`@@ -115,7 +113,7 @@ public void getReaderNullRootAndResourceIsDirectory() throws Exception {`
`115`	`113`	`public void getReaderWithRootAndResourceIsDirectory() throws Exception {`
`116`	`114`	`ClasspathResolver underTest = new ClasspathResolver("templates");`
`117`	`115`	`try (Reader reader = underTest.getReader("absolute")) {`
`118`		`- assertThat(reader, is(nullValue()));`
	`116`	`+ assertNull(reader);`
`119`	`117`	`}`
`120`	`118`	`}`
`121`	`119`
`@@ -124,7 +122,7 @@ public void getReaderWithRootAndResourceIsDirectory() throws Exception {`
`124`	`122`	`public void getReaderWithRootAndResourceAboveRoot() throws Exception {`
`125`	`123`	`ClasspathResolver underTest = new ClasspathResolver("templates/absolute");`
`126`	`124`	`try (Reader reader = underTest.getReader("../absolute_partials_template.html")) {`
`127`		`- assertThat(reader, is(notNullValue()));`
	`125`	`+ assertNotNull(reader);`
`128`	`126`	`}`
`129`	`127`	`}`
`130`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,10 +10,8 @@`
`10`	`10`	`import java.nio.file.Path;`
`11`	`11`	`import java.nio.file.Paths;`
`12`	`12`
`13`		`-import static org.hamcrest.CoreMatchers.notNullValue;`
`14`		`-import static org.hamcrest.CoreMatchers.nullValue;`
`15`		`-import static org.hamcrest.core.Is.is;`
`16`		`-import static org.junit.Assert.assertThat;`
	`13`	`+import static org.junit.Assert.assertNotNull;`
	`14`	`+import static org.junit.Assert.assertNull;`
`17`	`15`
`18`	`16`	`public class FileSystemResolverTest {`
`19`	`17`
`@@ -23,7 +21,7 @@ public class FileSystemResolverTest {`
`23`	`21`	`public void getReaderDefaultRootAndResourceHasRelativePath() throws Exception {`
`24`	`22`	`FileSystemResolver underTest = new FileSystemResolver();`
`25`	`23`	`try (Reader reader = underTest.getReader(resources + "/nested_partials_template.html")) {`
`26`		`- assertThat(reader, is(notNullValue()));`
	`24`	`+ assertNotNull(reader);`
`27`	`25`	`}`
`28`	`26`	`}`
`29`	`27`
`@@ -32,7 +30,7 @@ public void getReaderFileRootAndResourceHasRelativePath() throws Exception {`
`32`	`30`	`File fileRoot = new File(resources + "/templates_filepath");`
`33`	`31`	`FileSystemResolver underTest = new FileSystemResolver(fileRoot);`
`34`	`32`	`try (Reader reader = underTest.getReader("absolute_partials_template.html")) {`
`35`		`- assertThat(reader, is(notNullValue()));`
	`33`	`+ assertNotNull(reader);`
`36`	`34`	`}`
`37`	`35`	`}`
`38`	`36`
`@@ -41,15 +39,15 @@ public void getReaderPathRootAndResourceHasRelativePath() throws Exception {`
`41`	`39`	`Path pathRoot = Paths.get(resources + "/templates_filepath");`
`42`	`40`	`FileSystemResolver underTest = new FileSystemResolver(pathRoot);`
`43`	`41`	`try (Reader reader = underTest.getReader("absolute_partials_template.html")) {`
`44`		`- assertThat(reader, is(notNullValue()));`
	`42`	`+ assertNotNull(reader);`
`45`	`43`	`}`
`46`	`44`	`}`
`47`	`45`
`48`	`46`	`@Test`
`49`	`47`	`public void getReaderDefaultRootDoesNotFindFileWithAbsolutePath() throws Exception {`
`50`	`48`	`FileSystemResolver underTest = new FileSystemResolver();`
`51`	`49`	`try (Reader reader = underTest.getReader("/" + resources + "/nested_partials_template.html")) {`
`52`		`- assertThat(reader, is(nullValue()));`
	`50`	`+ assertNull(reader);`
`53`	`51`	`}`
`54`	`52`	`}`
`55`	`53`
`@@ -58,7 +56,7 @@ public void getReaderFileRootAndResourceHasAbsolutePath() throws Exception {`
`58`	`56`	`File fileRoot = new File(resources + "/templates_filepath");`
`59`	`57`	`FileSystemResolver underTest = new FileSystemResolver(fileRoot);`
`60`	`58`	`try (Reader reader = underTest.getReader("/absolute_partials_template.html")) {`
`61`		`- assertThat(reader, is(notNullValue()));`
	`59`	`+ assertNotNull(reader);`
`62`	`60`	`}`
`63`	`61`	`}`
`64`	`62`
`@@ -67,7 +65,7 @@ public void getReaderPathRootAndResourceHasAbsolutePath() throws Exception {`
`67`	`65`	`Path pathRoot = Paths.get(resources + "/templates_filepath");`
`68`	`66`	`FileSystemResolver underTest = new FileSystemResolver(pathRoot);`
`69`	`67`	`try (Reader reader = underTest.getReader("/absolute_partials_template.html")) {`
`70`		`- assertThat(reader, is(notNullValue()));`
	`68`	`+ assertNotNull(reader);`
`71`	`69`	`}`
`72`	`70`	`}`
`73`	`71`
`@@ -95,7 +93,7 @@ public void getReaderPathRootAndNullResourceThrowsNullPointer() throws Exception`
`95`	`93`	`public void getReaderDefaultRootAndResourceHasDoubleDotRelativePath() throws Exception {`
`96`	`94`	`FileSystemResolver underTest = new FileSystemResolver();`
`97`	`95`	`try (Reader reader = underTest.getReader(resources + "/templates_filepath/../nested_partials_template.html")) {`
`98`		`- assertThat(reader, is(notNullValue()));`
	`96`	`+ assertNotNull(reader);`
`99`	`97`	`}`
`100`	`98`	`}`
`101`	`99`
`@@ -104,7 +102,7 @@ public void getReaderFileRootAndResourceHasDoubleDotRelativePath() throws Except`
`104`	`102`	`File fileRoot = new File(resources + "/templates_filepath");`
`105`	`103`	`FileSystemResolver underTest = new FileSystemResolver(fileRoot);`
`106`	`104`	`try (Reader reader = underTest.getReader("absolute/../absolute_partials_template.html")) {`
`107`		`- assertThat(reader, is(notNullValue()));`
	`105`	`+ assertNotNull(reader);`
`108`	`106`	`}`
`109`	`107`	`}`
`110`	`108`
`@@ -113,15 +111,15 @@ public void getReaderPathRootAndResourceHasDoubleDotRelativePath() throws Except`
`113`	`111`	`Path pathRoot = Paths.get(resources + "/templates_filepath");`
`114`	`112`	`FileSystemResolver underTest = new FileSystemResolver(pathRoot);`
`115`	`113`	`try (Reader reader = underTest.getReader("absolute/../absolute_partials_template.html")) {`
`116`		`- assertThat(reader, is(notNullValue()));`
	`114`	`+ assertNotNull(reader);`
`117`	`115`	`}`
`118`	`116`	`}`
`119`	`117`
`120`	`118`	`@Test`
`121`	`119`	`public void getReaderDefaultRootAndResourceHasDotRelativePath() throws Exception {`
`122`	`120`	`FileSystemResolver underTest = new FileSystemResolver();`
`123`	`121`	`try (Reader reader = underTest.getReader(resources + "/templates_filepath/./absolute_partials_template.html")) {`
`124`		`- assertThat(reader, is(notNullValue()));`
	`122`	`+ assertNotNull(reader);`
`125`	`123`	`}`
`126`	`124`	`}`
`127`	`125`
`@@ -130,7 +128,7 @@ public void getReaderFileRootAndResourceHasDotRelativePath() throws Exception {`
`130`	`128`	`File fileRoot = new File(resources + "/templates_filepath");`
`131`	`129`	`FileSystemResolver underTest = new FileSystemResolver(fileRoot);`
`132`	`130`	`try (Reader reader = underTest.getReader("absolute/./nested_partials_sub.html")) {`
`133`		`- assertThat(reader, is(notNullValue()));`
	`131`	`+ assertNotNull(reader);`
`134`	`132`	`}`
`135`	`133`	`}`
`136`	`134`
`@@ -139,15 +137,15 @@ public void getReaderPathRootAndResourceHasDotRelativePath() throws Exception {`
`139`	`137`	`Path pathRoot = Paths.get(resources + "/templates_filepath");`
`140`	`138`	`FileSystemResolver underTest = new FileSystemResolver(pathRoot);`
`141`	`139`	`try (Reader reader = underTest.getReader("absolute/./nested_partials_sub.html")) {`
`142`		`- assertThat(reader, is(notNullValue()));`
	`140`	`+ assertNotNull(reader);`
`143`	`141`	`}`
`144`	`142`	`}`
`145`	`143`
`146`	`144`	`@Test`
`147`	`145`	`public void getReaderDefaultRootAndResourceHasInvalidPath() throws Exception {`
`148`	`146`	`FileSystemResolver underTest = new FileSystemResolver();`
`149`	`147`	`try (Reader reader = underTest.getReader("\0")) {`
`150`		`- assertThat(reader, is(nullValue()));`
	`148`	`+ assertNull(reader);`
`151`	`149`	`}`
`152`	`150`	`}`
`153`	`151`
`@@ -156,7 +154,7 @@ public void getReaderFileRootAndResourceHasInvalidPath() throws Exception {`
`156`	`154`	`File fileRoot = new File(resources + "/templates_filepath");`
`157`	`155`	`FileSystemResolver underTest = new FileSystemResolver(fileRoot);`
`158`	`156`	`try (Reader reader = underTest.getReader("\0")) {`
`159`		`- assertThat(reader, is(nullValue()));`
	`157`	`+ assertNull(reader);`
`160`	`158`	`}`
`161`	`159`	`}`
`162`	`160`
`@@ -165,7 +163,7 @@ public void getReaderPathRootAndResourceHasInvalidPath() throws Exception {`
`165`	`163`	`Path pathRoot = Paths.get(resources + "/templates_filepath");`
`166`	`164`	`FileSystemResolver underTest = new FileSystemResolver(pathRoot);`
`167`	`165`	`try (Reader reader = underTest.getReader("\0")) {`
`168`		`- assertThat(reader, is(nullValue()));`
	`166`	`+ assertNull(reader);`
`169`	`167`	`}`
`170`	`168`	`}`
`171`	`169`
`@@ -176,7 +174,7 @@ public void getReaderPathRootAndNonDefaultFileSystem() throws Exception {`
`176`	`174`	`Path pathRoot = zipFileSystem.getPath("templates");`
`177`	`175`	`FileSystemResolver underTest = new FileSystemResolver(pathRoot);`
`178`	`176`	`try (Reader reader = underTest.getReader("absolute_partials_template.html")) {`
`179`		`- assertThat(reader, is(notNullValue()));`
	`177`	`+ assertNotNull(reader);`
`180`	`178`	`}`
`181`	`179`	`}`
`182`	`180`	`}`
`@@ -185,7 +183,7 @@ public void getReaderPathRootAndNonDefaultFileSystem() throws Exception {`
`185`	`183`	`public void getReaderDefaultRootAndResourceIsDirectory() throws Exception {`
`186`	`184`	`FileSystemResolver underTest = new FileSystemResolver();`
`187`	`185`	`try (Reader reader = underTest.getReader(resources + "/templates_filepath")) {`
`188`		`- assertThat(reader, is(nullValue()));`
	`186`	`+ assertNull(reader);`
`189`	`187`	`}`
`190`	`188`	`}`
`191`	`189`
`@@ -194,7 +192,7 @@ public void getReaderFileRootAndResourceIsDirectory() throws Exception {`
`194`	`192`	`File fileRoot = new File(resources);`
`195`	`193`	`FileSystemResolver underTest = new FileSystemResolver(fileRoot);`
`196`	`194`	`try (Reader reader = underTest.getReader("templates_filepath")) {`
`197`		`- assertThat(reader, is(nullValue()));`
	`195`	`+ assertNull(reader);`
`198`	`196`	`}`
`199`	`197`	`}`
`200`	`198`
`@@ -203,7 +201,7 @@ public void getReaderPathRootAndResourceIsDirectory() throws Exception {`
`203`	`201`	`Path pathRoot = Paths.get(resources);`
`204`	`202`	`FileSystemResolver underTest = new FileSystemResolver(pathRoot);`
`205`	`203`	`try (Reader reader = underTest.getReader("templates_filepath")) {`
`206`		`- assertThat(reader, is(nullValue()));`
	`204`	`+ assertNull(reader);`
`207`	`205`	`}`
`208`	`206`	`}`
`209`	`207`
`@@ -214,7 +212,7 @@ public void getReaderPathRootAndResourceIsDirectory() throws Exception {`
`214`	`212`	`public void getReaderDefaultRootAndResourceAboveRootNotFound() throws Exception {`
`215`	`213`	`FileSystemResolver underTest = new FileSystemResolver();`
`216`	`214`	`try (Reader reader = underTest.getReader("../this_file_does_not_exist.html")) {`
`217`		`- assertThat(reader, is(nullValue()));`
	`215`	`+ assertNull(reader);`
`218`	`216`	`}`
`219`	`217`	`}`
`220`	`218`
`@@ -230,7 +228,7 @@ public void getReaderFileRootAndResourceAboveRootNotFound() throws Exception {`
`230`	`228`	`File fileRoot = new File(resources + "/templates_filepath");`
`231`	`229`	`FileSystemResolver underTest = new FileSystemResolver(fileRoot);`
`232`	`230`	`try (Reader reader = underTest.getReader("../this_file_does_not_exist.html")) {`
`233`		`- assertThat(reader, is(nullValue()));`
	`231`	`+ assertNull(reader);`
`234`	`232`	`}`
`235`	`233`	`}`
`236`	`234`
`@@ -246,7 +244,7 @@ public void getReaderPathRootAndResourceAboveRootNotFound() throws Exception {`
`246`	`244`	`Path pathRoot = Paths.get(resources + "/templates_filepath");`
`247`	`245`	`FileSystemResolver underTest = new FileSystemResolver(pathRoot);`
`248`	`246`	`try (Reader reader = underTest.getReader("../this_file_does_not_exist.html")) {`
`249`		`- assertThat(reader, is(nullValue()));`
	`247`	`+ assertNull(reader);`
`250`	`248`	`}`
`251`	`249`	`}`
`252`	`250`	`}`