Update PathTraversalDetectorTest cases to use this new INSTANCE

bitterpanda63 · bitterpanda63 · commit 8a70bb606fc7 · 2025-11-21T10:30:00.000+01:00
diff --git a/agent_api/src/test/java/vulnerabilities/path_traversal/PathTraversalDetectorTest.java b/agent_api/src/test/java/vulnerabilities/path_traversal/PathTraversalDetectorTest.java
@@ -7,7 +7,6 @@
 import static org.junit.jupiter.api.Assertions.*;
 
 public class PathTraversalDetectorTest {
-    private final PathTraversalDetector pathTraversalDetector = new PathTraversalDetector();
     private void assertNotAttack(Detector.DetectorResult detectorResult) {
         assertFalse(detectorResult.isDetectedAttack());
     }
@@ -16,199 +15,199 @@ private void assertAttack(Detector.DetectorResult detectorResult) {
     }
     @Test
     public void testEmptyUserInput() {
-        assertNotAttack(pathTraversalDetector.run("", new String[]{"test.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("", new String[]{"test.txt"}));
     }
 
     @Test
     public void testEmptyFileInput() {
-        assertNotAttack(pathTraversalDetector.run("test", new String[]{""}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("test", new String[]{""}));
     }
 
     @Test
     public void testEmptyUserInputAndFileInput() {
-        assertNotAttack(pathTraversalDetector.run("", new String[]{""}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("", new String[]{""}));
     }
 
     @Test
     public void testUserInputIsASingleCharacter() {
-        assertNotAttack(pathTraversalDetector.run("t", new String[]{"test.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("t", new String[]{"test.txt"}));
     }
 
     @Test
     public void testFileInputIsASingleCharacter() {
-        assertNotAttack(pathTraversalDetector.run("test", new String[]{"t"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("test", new String[]{"t"}));
     }
 
     @Test
     public void testSameAsUserInput() {
-        assertNotAttack(pathTraversalDetector.run("text.txt", new String[]{"text.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("text.txt", new String[]{"text.txt"}));
     }
 
     @Test
     public void testWithDirectoryBefore() {
-        assertNotAttack(pathTraversalDetector.run("text.txt", new String[]{"directory/text.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("text.txt", new String[]{"directory/text.txt"}));
     }
 
     @Test
     public void testWithBothDirectoryBefore() {
-        assertNotAttack(pathTraversalDetector.run("directory/text.txt", new String[]{"directory/text.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("directory/text.txt", new String[]{"directory/text.txt"}));
     }
 
     @Test
     public void testUserInputAndFileInputAreSingleCharacters() {
-        assertNotAttack(pathTraversalDetector.run("t", new String[]{"t"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("t", new String[]{"t"}));
     }
 
     @Test
     public void testItFlagsDotDotSlash() {
-        assertAttack(pathTraversalDetector.run("../", new String[]{"../test.txt"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("../", new String[]{"../test.txt"}));
     }
 
     @Test
     public void testItFlagsDotDotSlashSlash() {
-        assertAttack(pathTraversalDetector.run("..//", new String[]{"..//test.txt"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("..//", new String[]{"..//test.txt"}));
     }
 
     @Test
     public void testItFlagsMoreComplexPaths() {
-        assertAttack(pathTraversalDetector.run("..//secrets/key.txt", new String[]{"resources/blog/..//secrets/key.txt"}));
-        assertAttack(pathTraversalDetector.run(".././/secrets/key.txt", new String[]{"resources/blog/.././/secrets/key.txt"}));
-        assertAttack(pathTraversalDetector.run("////../secrets/key.txt", new String[]{"resources/blog/////../secrets/key.txt"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("..//secrets/key.txt", new String[]{"resources/blog/..//secrets/key.txt"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run(".././/secrets/key.txt", new String[]{"resources/blog/.././/secrets/key.txt"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("////../secrets/key.txt", new String[]{"resources/blog/////../secrets/key.txt"}));
     }
 
     @Test
     public void testItFlagsBackslashDotDot() {
-        assertAttack(pathTraversalDetector.run("..\\", new String[]{"..\\test.txt",}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("..\\", new String[]{"..\\test.txt",}));
     }
 
     @Test
     public void testItFlagsDoubleDotSlash() {
-        assertAttack(pathTraversalDetector.run("../../", new String[]{"../../test.txt"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("../../", new String[]{"../../test.txt"}));
     }
 
     @Test
     public void testItFlagsDoubleDotBackslash() {
-        assertAttack(pathTraversalDetector.run("..\\..\\", new String[]{"..\\..\\test.txt",}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("..\\..\\", new String[]{"..\\..\\test.txt",}));
     }
 
     @Test
     public void testItFlagsFourDotSlash() {
-        assertAttack(pathTraversalDetector.run("../../../../", new String[]{"../../../../test.txt"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("../../../../", new String[]{"../../../../test.txt"}));
     }
 
     @Test
     public void testItFlagsThreeDotBackslash() {
-        assertAttack(pathTraversalDetector.run("..\\..\\..\\", new String[]{"..\\..\\..\\test.txt",}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("..\\..\\..\\", new String[]{"..\\..\\..\\test.txt",}));
     }
 
     @Test
     public void testUserInputIsLongerThanFilePath() {
-        assertNotAttack(pathTraversalDetector.run("../../file.txt", new String[]{"../file.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("../../file.txt", new String[]{"../file.txt"}));
     }
 
     @Test
     public void testAbsoluteLinuxPath() {
-        assertAttack(pathTraversalDetector.run("/etc/passwd", new String[]{"/etc/passwd"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("/etc/passwd", new String[]{"/etc/passwd"}));
     }
 
     @Test
     public void testLinuxUserDirectory() {
-        assertAttack(pathTraversalDetector.run("/home/user/", new String[]{"/home/user/file.txt"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("/home/user/", new String[]{"/home/user/file.txt"}));
     }
 
     @Test
     public void testWindowsDriveLetter() {
-        assertAttack(pathTraversalDetector.run("C:\\", new String[]{"C:\\file.txt"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("C:\\", new String[]{"C:\\file.txt"}));
     }
 
     @Test
     public void testNoPathTraversal() {
-        assertNotAttack(pathTraversalDetector.run("/storage/file.txt", new String[]{"/appdata/storage/file.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("/storage/file.txt", new String[]{"/appdata/storage/file.txt"}));
     }
 
     @Test
     public void testDoesNotFlagTest() {
-        assertNotAttack(pathTraversalDetector.run("test", new String[]{"/app/test.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("test", new String[]{"/app/test.txt"}));
     }
 
     @Test
     public void testDoesNotFlagExampleTestTxt() {
-        assertNotAttack(pathTraversalDetector.run("example/test.txt", new String[]{"/app/data/example/test.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("example/test.txt", new String[]{"/app/data/example/test.txt"}));
     }
 
     @Test
     public void testDoesNotAbsolutePathWithDifferentFolder() {
-        assertNotAttack(pathTraversalDetector.run("/etc/hack/config", new String[]{"/etc/app/config"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("/etc/hack/config", new String[]{"/etc/app/config"}));
     }
 
     @Test
     public void testDoesNotAbsolutePathInsideAnotherFolder() {
-        assertNotAttack(pathTraversalDetector.run("/etc/config", new String[]{"/etc/app/data/etc/config"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("/etc/config", new String[]{"/etc/app/data/etc/config"}));
     }
 
     @Test
     public void testUserInputContainsMultipleUnsafePathParts() {
-        assertNotAttack(pathTraversalDetector.run("../../../", new String[]{"directory/../../file.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("../../../", new String[]{"directory/../../file.txt"}));
     }
 
     @Test
     public void testUserInputWithMixedPathSeparators() {
-        assertNotAttack(pathTraversalDetector.run("..\\..\\", new String[]{"directory/../file.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("..\\..\\", new String[]{"directory/../file.txt"}));
     }
 
     @Test
     public void testUserInputWithEncodedCharacters() {
-        assertAttack(pathTraversalDetector.run("%2E%2E/../", new String[]{"directory/%2E%2E/../file.txt"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("%2E%2E/../", new String[]{"directory/%2E%2E/../file.txt"}));
     }
 
     @Test
     public void testUserInputWithEncodedBackslash() {
-        assertNotAttack(pathTraversalDetector.run("%5C%5C", new String[]{"directory/%5C%5Cfile.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("%5C%5C", new String[]{"directory/%5C%5Cfile.txt"}));
     }
 
     @Test
     public void testUserInputWithSpaces() {
-        assertNotAttack(pathTraversalDetector.run("test file", new String[]{"directory/test file.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("test file", new String[]{"directory/test file.txt"}));
     }
 
     @Test
     public void testUserInputWithLeadingSpaces() {
-        assertNotAttack(pathTraversalDetector.run(" test.txt", new String[]{"directory/test.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run(" test.txt", new String[]{"directory/test.txt"}));
     }
 
     @Test
     public void testUserInputWithTrailingSpaces() {
-        assertNotAttack(pathTraversalDetector.run("test.txt ", new String[]{"directory/test.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("test.txt ", new String[]{"directory/test.txt"}));
     }
 
     @Test
     public void testUserInputWithSpecialCharacters() {
-        assertNotAttack(pathTraversalDetector.run("test@file.txt", new String[]{"directory/test@file.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("test@file.txt", new String[]{"directory/test@file.txt"}));
     }
 
     @Test
     public void testUserInputWithAbsolutePath() {
-        assertAttack(pathTraversalDetector.run("/etc/passwd", new String[]{"/etc/passwd"}));
+        assertAttack(PathTraversalDetector.INSTANCE.run("/etc/passwd", new String[]{"/etc/passwd"}));
     }
 
     @Test
     public void testUserInputWithMixedCase() {
-        assertNotAttack(pathTraversalDetector.run("Test.txt", new String[]{"directory/test.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("Test.txt", new String[]{"directory/test.txt"}));
     }
 
     @Test
     public void testUserInputWithLongPath() {
         String longUserInput = "a".repeat(260); // Assuming a long input
-        assertNotAttack(pathTraversalDetector.run(longUserInput, new String[]{"directory/test.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run(longUserInput, new String[]{"directory/test.txt"}));
     }
 
     @Test
     public void testUserInputWithEmptyFilePath() {
-        assertNotAttack(pathTraversalDetector.run("test", new String[]{""}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("test", new String[]{""}));
     }
 
     @Test
     public void testUserInputWithFilePathContainingSpaces() {
-        assertNotAttack(pathTraversalDetector.run("test file", new String[]{"directory/test file.txt"}));
+        assertNotAttack(PathTraversalDetector.INSTANCE.run("test file", new String[]{"directory/test file.txt"}));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,6 @@`
`7`	`7`	`import static org.junit.jupiter.api.Assertions.*;`
`8`	`8`
`9`	`9`	`public class PathTraversalDetectorTest {`
`10`		`- private final PathTraversalDetector pathTraversalDetector = new PathTraversalDetector();`
`11`	`10`	`private void assertNotAttack(Detector.DetectorResult detectorResult) {`
`12`	`11`	`assertFalse(detectorResult.isDetectedAttack());`
`13`	`12`	`}`
`@@ -16,199 +15,199 @@ private void assertAttack(Detector.DetectorResult detectorResult) {`
`16`	`15`	`}`
`17`	`16`	`@Test`
`18`	`17`	`public void testEmptyUserInput() {`
`19`		`- assertNotAttack(pathTraversalDetector.run("", new String[]{"test.txt"}));`
	`18`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("", new String[]{"test.txt"}));`
`20`	`19`	`}`
`21`	`20`
`22`	`21`	`@Test`
`23`	`22`	`public void testEmptyFileInput() {`
`24`		`- assertNotAttack(pathTraversalDetector.run("test", new String[]{""}));`
	`23`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("test", new String[]{""}));`
`25`	`24`	`}`
`26`	`25`
`27`	`26`	`@Test`
`28`	`27`	`public void testEmptyUserInputAndFileInput() {`
`29`		`- assertNotAttack(pathTraversalDetector.run("", new String[]{""}));`
	`28`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("", new String[]{""}));`
`30`	`29`	`}`
`31`	`30`
`32`	`31`	`@Test`
`33`	`32`	`public void testUserInputIsASingleCharacter() {`
`34`		`- assertNotAttack(pathTraversalDetector.run("t", new String[]{"test.txt"}));`
	`33`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("t", new String[]{"test.txt"}));`
`35`	`34`	`}`
`36`	`35`
`37`	`36`	`@Test`
`38`	`37`	`public void testFileInputIsASingleCharacter() {`
`39`		`- assertNotAttack(pathTraversalDetector.run("test", new String[]{"t"}));`
	`38`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("test", new String[]{"t"}));`
`40`	`39`	`}`
`41`	`40`
`42`	`41`	`@Test`
`43`	`42`	`public void testSameAsUserInput() {`
`44`		`- assertNotAttack(pathTraversalDetector.run("text.txt", new String[]{"text.txt"}));`
	`43`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("text.txt", new String[]{"text.txt"}));`
`45`	`44`	`}`
`46`	`45`
`47`	`46`	`@Test`
`48`	`47`	`public void testWithDirectoryBefore() {`
`49`		`- assertNotAttack(pathTraversalDetector.run("text.txt", new String[]{"directory/text.txt"}));`
	`48`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("text.txt", new String[]{"directory/text.txt"}));`
`50`	`49`	`}`
`51`	`50`
`52`	`51`	`@Test`
`53`	`52`	`public void testWithBothDirectoryBefore() {`
`54`		`- assertNotAttack(pathTraversalDetector.run("directory/text.txt", new String[]{"directory/text.txt"}));`
	`53`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("directory/text.txt", new String[]{"directory/text.txt"}));`
`55`	`54`	`}`
`56`	`55`
`57`	`56`	`@Test`
`58`	`57`	`public void testUserInputAndFileInputAreSingleCharacters() {`
`59`		`- assertNotAttack(pathTraversalDetector.run("t", new String[]{"t"}));`
	`58`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("t", new String[]{"t"}));`
`60`	`59`	`}`
`61`	`60`
`62`	`61`	`@Test`
`63`	`62`	`public void testItFlagsDotDotSlash() {`
`64`		`- assertAttack(pathTraversalDetector.run("../", new String[]{"../test.txt"}));`
	`63`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("../", new String[]{"../test.txt"}));`
`65`	`64`	`}`
`66`	`65`
`67`	`66`	`@Test`
`68`	`67`	`public void testItFlagsDotDotSlashSlash() {`
`69`		`- assertAttack(pathTraversalDetector.run("..//", new String[]{"..//test.txt"}));`
	`68`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("..//", new String[]{"..//test.txt"}));`
`70`	`69`	`}`
`71`	`70`
`72`	`71`	`@Test`
`73`	`72`	`public void testItFlagsMoreComplexPaths() {`
`74`		`- assertAttack(pathTraversalDetector.run("..//secrets/key.txt", new String[]{"resources/blog/..//secrets/key.txt"}));`
`75`		`- assertAttack(pathTraversalDetector.run(".././/secrets/key.txt", new String[]{"resources/blog/.././/secrets/key.txt"}));`
`76`		`- assertAttack(pathTraversalDetector.run("////../secrets/key.txt", new String[]{"resources/blog/////../secrets/key.txt"}));`
	`73`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("..//secrets/key.txt", new String[]{"resources/blog/..//secrets/key.txt"}));`
	`74`	`+ assertAttack(PathTraversalDetector.INSTANCE.run(".././/secrets/key.txt", new String[]{"resources/blog/.././/secrets/key.txt"}));`
	`75`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("////../secrets/key.txt", new String[]{"resources/blog/////../secrets/key.txt"}));`
`77`	`76`	`}`
`78`	`77`
`79`	`78`	`@Test`
`80`	`79`	`public void testItFlagsBackslashDotDot() {`
`81`		`- assertAttack(pathTraversalDetector.run("..\\", new String[]{"..\\test.txt",}));`
	`80`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("..\\", new String[]{"..\\test.txt",}));`
`82`	`81`	`}`
`83`	`82`
`84`	`83`	`@Test`
`85`	`84`	`public void testItFlagsDoubleDotSlash() {`
`86`		`- assertAttack(pathTraversalDetector.run("../../", new String[]{"../../test.txt"}));`
	`85`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("../../", new String[]{"../../test.txt"}));`
`87`	`86`	`}`
`88`	`87`
`89`	`88`	`@Test`
`90`	`89`	`public void testItFlagsDoubleDotBackslash() {`
`91`		`- assertAttack(pathTraversalDetector.run("..\\..\\", new String[]{"..\\..\\test.txt",}));`
	`90`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("..\\..\\", new String[]{"..\\..\\test.txt",}));`
`92`	`91`	`}`
`93`	`92`
`94`	`93`	`@Test`
`95`	`94`	`public void testItFlagsFourDotSlash() {`
`96`		`- assertAttack(pathTraversalDetector.run("../../../../", new String[]{"../../../../test.txt"}));`
	`95`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("../../../../", new String[]{"../../../../test.txt"}));`
`97`	`96`	`}`
`98`	`97`
`99`	`98`	`@Test`
`100`	`99`	`public void testItFlagsThreeDotBackslash() {`
`101`		`- assertAttack(pathTraversalDetector.run("..\\..\\..\\", new String[]{"..\\..\\..\\test.txt",}));`
	`100`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("..\\..\\..\\", new String[]{"..\\..\\..\\test.txt",}));`
`102`	`101`	`}`
`103`	`102`
`104`	`103`	`@Test`
`105`	`104`	`public void testUserInputIsLongerThanFilePath() {`
`106`		`- assertNotAttack(pathTraversalDetector.run("../../file.txt", new String[]{"../file.txt"}));`
	`105`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("../../file.txt", new String[]{"../file.txt"}));`
`107`	`106`	`}`
`108`	`107`
`109`	`108`	`@Test`
`110`	`109`	`public void testAbsoluteLinuxPath() {`
`111`		`- assertAttack(pathTraversalDetector.run("/etc/passwd", new String[]{"/etc/passwd"}));`
	`110`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("/etc/passwd", new String[]{"/etc/passwd"}));`
`112`	`111`	`}`
`113`	`112`
`114`	`113`	`@Test`
`115`	`114`	`public void testLinuxUserDirectory() {`
`116`		`- assertAttack(pathTraversalDetector.run("/home/user/", new String[]{"/home/user/file.txt"}));`
	`115`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("/home/user/", new String[]{"/home/user/file.txt"}));`
`117`	`116`	`}`
`118`	`117`
`119`	`118`	`@Test`
`120`	`119`	`public void testWindowsDriveLetter() {`
`121`		`- assertAttack(pathTraversalDetector.run("C:\\", new String[]{"C:\\file.txt"}));`
	`120`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("C:\\", new String[]{"C:\\file.txt"}));`
`122`	`121`	`}`
`123`	`122`
`124`	`123`	`@Test`
`125`	`124`	`public void testNoPathTraversal() {`
`126`		`- assertNotAttack(pathTraversalDetector.run("/storage/file.txt", new String[]{"/appdata/storage/file.txt"}));`
	`125`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("/storage/file.txt", new String[]{"/appdata/storage/file.txt"}));`
`127`	`126`	`}`
`128`	`127`
`129`	`128`	`@Test`
`130`	`129`	`public void testDoesNotFlagTest() {`
`131`		`- assertNotAttack(pathTraversalDetector.run("test", new String[]{"/app/test.txt"}));`
	`130`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("test", new String[]{"/app/test.txt"}));`
`132`	`131`	`}`
`133`	`132`
`134`	`133`	`@Test`
`135`	`134`	`public void testDoesNotFlagExampleTestTxt() {`
`136`		`- assertNotAttack(pathTraversalDetector.run("example/test.txt", new String[]{"/app/data/example/test.txt"}));`
	`135`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("example/test.txt", new String[]{"/app/data/example/test.txt"}));`
`137`	`136`	`}`
`138`	`137`
`139`	`138`	`@Test`
`140`	`139`	`public void testDoesNotAbsolutePathWithDifferentFolder() {`
`141`		`- assertNotAttack(pathTraversalDetector.run("/etc/hack/config", new String[]{"/etc/app/config"}));`
	`140`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("/etc/hack/config", new String[]{"/etc/app/config"}));`
`142`	`141`	`}`
`143`	`142`
`144`	`143`	`@Test`
`145`	`144`	`public void testDoesNotAbsolutePathInsideAnotherFolder() {`
`146`		`- assertNotAttack(pathTraversalDetector.run("/etc/config", new String[]{"/etc/app/data/etc/config"}));`
	`145`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("/etc/config", new String[]{"/etc/app/data/etc/config"}));`
`147`	`146`	`}`
`148`	`147`
`149`	`148`	`@Test`
`150`	`149`	`public void testUserInputContainsMultipleUnsafePathParts() {`
`151`		`- assertNotAttack(pathTraversalDetector.run("../../../", new String[]{"directory/../../file.txt"}));`
	`150`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("../../../", new String[]{"directory/../../file.txt"}));`
`152`	`151`	`}`
`153`	`152`
`154`	`153`	`@Test`
`155`	`154`	`public void testUserInputWithMixedPathSeparators() {`
`156`		`- assertNotAttack(pathTraversalDetector.run("..\\..\\", new String[]{"directory/../file.txt"}));`
	`155`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("..\\..\\", new String[]{"directory/../file.txt"}));`
`157`	`156`	`}`
`158`	`157`
`159`	`158`	`@Test`
`160`	`159`	`public void testUserInputWithEncodedCharacters() {`
`161`		`- assertAttack(pathTraversalDetector.run("%2E%2E/../", new String[]{"directory/%2E%2E/../file.txt"}));`
	`160`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("%2E%2E/../", new String[]{"directory/%2E%2E/../file.txt"}));`
`162`	`161`	`}`
`163`	`162`
`164`	`163`	`@Test`
`165`	`164`	`public void testUserInputWithEncodedBackslash() {`
`166`		`- assertNotAttack(pathTraversalDetector.run("%5C%5C", new String[]{"directory/%5C%5Cfile.txt"}));`
	`165`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("%5C%5C", new String[]{"directory/%5C%5Cfile.txt"}));`
`167`	`166`	`}`
`168`	`167`
`169`	`168`	`@Test`
`170`	`169`	`public void testUserInputWithSpaces() {`
`171`		`- assertNotAttack(pathTraversalDetector.run("test file", new String[]{"directory/test file.txt"}));`
	`170`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("test file", new String[]{"directory/test file.txt"}));`
`172`	`171`	`}`
`173`	`172`
`174`	`173`	`@Test`
`175`	`174`	`public void testUserInputWithLeadingSpaces() {`
`176`		`- assertNotAttack(pathTraversalDetector.run(" test.txt", new String[]{"directory/test.txt"}));`
	`175`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run(" test.txt", new String[]{"directory/test.txt"}));`
`177`	`176`	`}`
`178`	`177`
`179`	`178`	`@Test`
`180`	`179`	`public void testUserInputWithTrailingSpaces() {`
`181`		`- assertNotAttack(pathTraversalDetector.run("test.txt ", new String[]{"directory/test.txt"}));`
	`180`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("test.txt ", new String[]{"directory/test.txt"}));`
`182`	`181`	`}`
`183`	`182`
`184`	`183`	`@Test`
`185`	`184`	`public void testUserInputWithSpecialCharacters() {`
`186`		`- assertNotAttack(pathTraversalDetector.run("[email protected]", new String[]{"directory/[email protected]"}));`
	`185`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("[email protected]", new String[]{"directory/[email protected]"}));`
`187`	`186`	`}`
`188`	`187`
`189`	`188`	`@Test`
`190`	`189`	`public void testUserInputWithAbsolutePath() {`
`191`		`- assertAttack(pathTraversalDetector.run("/etc/passwd", new String[]{"/etc/passwd"}));`
	`190`	`+ assertAttack(PathTraversalDetector.INSTANCE.run("/etc/passwd", new String[]{"/etc/passwd"}));`
`192`	`191`	`}`
`193`	`192`
`194`	`193`	`@Test`
`195`	`194`	`public void testUserInputWithMixedCase() {`
`196`		`- assertNotAttack(pathTraversalDetector.run("Test.txt", new String[]{"directory/test.txt"}));`
	`195`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("Test.txt", new String[]{"directory/test.txt"}));`
`197`	`196`	`}`
`198`	`197`
`199`	`198`	`@Test`
`200`	`199`	`public void testUserInputWithLongPath() {`
`201`	`200`	`String longUserInput = "a".repeat(260); // Assuming a long input`
`202`		`- assertNotAttack(pathTraversalDetector.run(longUserInput, new String[]{"directory/test.txt"}));`
	`201`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run(longUserInput, new String[]{"directory/test.txt"}));`
`203`	`202`	`}`
`204`	`203`
`205`	`204`	`@Test`
`206`	`205`	`public void testUserInputWithEmptyFilePath() {`
`207`		`- assertNotAttack(pathTraversalDetector.run("test", new String[]{""}));`
	`206`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("test", new String[]{""}));`
`208`	`207`	`}`
`209`	`208`
`210`	`209`	`@Test`
`211`	`210`	`public void testUserInputWithFilePathContainingSpaces() {`
`212`		`- assertNotAttack(pathTraversalDetector.run("test file", new String[]{"directory/test file.txt"}));`
	`211`	`+ assertNotAttack(PathTraversalDetector.INSTANCE.run("test file", new String[]{"directory/test file.txt"}));`
`213`	`212`	`}`
`214`	`213`	`}`