From a33c5c65828ee81fcfd53f95f7d7bc915ef5d86e Mon Sep 17 00:00:00 2001 From: flbruto <19573915+fbruton@users.noreply.github.com> Date: Mon, 5 Jun 2023 18:54:51 +0000 Subject: [PATCH 1/4] Add contains methods to ByteMatcher --- .../emissary/util/search/ByteMatcher.java | 65 +++++++++++++++++++ .../emissary/util/search/ByteMatcherTest.java | 62 ++++++++++++++++++ 2 files changed, 127 insertions(+) diff --git a/src/main/java/emissary/util/search/ByteMatcher.java b/src/main/java/emissary/util/search/ByteMatcher.java index f6147d1f94..54f4bc9907 100755 --- a/src/main/java/emissary/util/search/ByteMatcher.java +++ b/src/main/java/emissary/util/search/ByteMatcher.java @@ -1,6 +1,7 @@ package emissary.util.search; import java.nio.charset.Charset; +import java.util.Arrays; import javax.annotation.Nullable; /** @@ -66,6 +67,70 @@ public int length() { return mydata.length; } + public boolean containsAny(String... patterns) { + return Arrays.stream(patterns).anyMatch(this::contains); + } + + public boolean containsAnyIgnoreCase(String... patterns) { + return Arrays.stream(patterns).anyMatch(this::containsIgnoreCase); + } + + public boolean containsAny(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).anyMatch(pattern -> contains(pattern, beginIndex, endIndex)); + } + + public boolean containsAnyIgnoreCase(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).anyMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); + } + + public boolean containsAll(String... patterns) { + return Arrays.stream(patterns).allMatch(this::contains); + } + + public boolean containsAllIgnoreCase(String... patterns) { + return Arrays.stream(patterns).allMatch(this::containsIgnoreCase); + } + + public boolean containsAll(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).allMatch(pattern -> contains(pattern, beginIndex, endIndex)); + } + + public boolean containsAllIgnoreCase(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).allMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); + } + + public boolean contains(String pattern) { + return contains(pattern.getBytes()); + } + + public boolean containsIgnoreCase(String pattern) { + return containsIgnoreCase(pattern.getBytes()); + } + + public boolean contains(String pattern, int beginIndex, int endIndex) { + return contains(pattern.getBytes(), beginIndex, endIndex); + } + + public boolean containsIgnoreCase(String pattern, int beginIndex, int endIndex) { + return containsIgnoreCase(pattern.getBytes(), beginIndex, endIndex); + } + + public boolean contains(byte[] pattern) { + return indexOf(pattern) >= 0; + } + + public boolean containsIgnoreCase(byte[] pattern) { + return indexIgnoreCase(pattern) >= 0; + } + + public boolean contains(byte[] pattern, int beginIndex, int endIndex) { + return indexOf(pattern, beginIndex, endIndex) >= 0; + } + + public boolean containsIgnoreCase(byte[] pattern, int beginIndex, int endIndex) { + return indexIgnoreCase(pattern, beginIndex, endIndex) >= 0; + } + /** * This method finds a pattern in the text and returns the offset * diff --git a/src/test/java/emissary/util/search/ByteMatcherTest.java b/src/test/java/emissary/util/search/ByteMatcherTest.java index 9bf2253e84..8c8be71525 100644 --- a/src/test/java/emissary/util/search/ByteMatcherTest.java +++ b/src/test/java/emissary/util/search/ByteMatcherTest.java @@ -283,4 +283,66 @@ void testNullDataBytesIgnoreCase() { assertEquals(-1, this.b.indexIgnoreCase("Fred".getBytes()), "Match pos not found"); } + @Test + void testContainsAny() { + assertTrue(this.b.containsAny("fox", "test")); + assertFalse(this.b.containsAny("fOX", "TEST")); + assertFalse(this.b.containsAny("no", "tokens", "found")); + + assertTrue(this.b.containsAny(16, b.length(), "fox", "test")); + assertFalse(this.b.containsAny(16, 18, "fox", "test")); + } + + @Test + void testContainsAnyIgnoreCase() { + assertTrue(this.b.containsAnyIgnoreCase("fox", "test")); + assertTrue(this.b.containsAnyIgnoreCase("fOX", "TEST")); + assertFalse(this.b.containsAnyIgnoreCase("no", "tokens", "found")); + + assertTrue(this.b.containsAnyIgnoreCase(16, 19, "fOX", "TEST")); + assertFalse(this.b.containsAnyIgnoreCase(17, b.length(), "fOX", "TEST")); + } + + + @Test + void testContainsAll() { + assertTrue(this.b.containsAll("fox", "jumped", "dog", "lazy")); + assertFalse(this.b.containsAll("fox", "jumped", "dog", "LAZY")); + assertFalse(this.b.containsAll("no", "tokens", "found")); + + assertTrue(this.b.containsAll(0, b.length(), "fox", "jumped", "dog", "lazy")); + assertFalse(this.b.containsAll(0, b.length() - 1, "fox", "jumped", "dog", "lazy")); + } + + @Test + void testContainsAllIgnoreCase() { + assertTrue(this.b.containsAllIgnoreCase("fox", "jumped", "dog", "lazy")); + assertTrue(this.b.containsAllIgnoreCase("fox", "jumped", "dog", "LAZY")); + assertFalse(this.b.containsAllIgnoreCase("no", "tokens", "found")); + + assertTrue(this.b.containsAllIgnoreCase(16, b.length(), "fox", "jumped", "dog", "LAZY")); + assertFalse(this.b.containsAllIgnoreCase(17, b.length(), "fox", "jumped", "dog", "LAZY")); + } + + @Test + void testContains() { + assertTrue(this.b.contains("fox")); + } + + @Test + void testContainsIgnoreCase() { + assertTrue(this.b.containsIgnoreCase("FoX")); + } + + @Test + void testContainsWithIndices() { + assertTrue(this.b.contains("quick brown fox", 4, 19)); + assertFalse(this.b.contains("quick brown fox", 4, 18)); + } + + @Test + void testContainsWithIndicesIgnoreCase() { + assertTrue(this.b.containsIgnoreCase("Quick BROWN fOX", 4, data.length())); + assertFalse(this.b.containsIgnoreCase("Quick BROWN fOX", 5, data.length())); + } } From 820350c347772428d7f73f506c87e744ed792d22 Mon Sep 17 00:00:00 2001 From: flbruto <19573915+fbruton@users.noreply.github.com> Date: Thu, 8 Jun 2023 13:39:38 +0000 Subject: [PATCH 2/4] Attempt to reorder methods based on comments --- .../emissary/util/search/ByteMatcher.java | 56 +++++++++---------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/src/main/java/emissary/util/search/ByteMatcher.java b/src/main/java/emissary/util/search/ByteMatcher.java index 54f4bc9907..a53b77c19d 100755 --- a/src/main/java/emissary/util/search/ByteMatcher.java +++ b/src/main/java/emissary/util/search/ByteMatcher.java @@ -71,60 +71,60 @@ public boolean containsAny(String... patterns) { return Arrays.stream(patterns).anyMatch(this::contains); } - public boolean containsAnyIgnoreCase(String... patterns) { - return Arrays.stream(patterns).anyMatch(this::containsIgnoreCase); - } - - public boolean containsAny(int beginIndex, int endIndex, String... patterns) { - return Arrays.stream(patterns).anyMatch(pattern -> contains(pattern, beginIndex, endIndex)); + public boolean containsAll(String... patterns) { + return Arrays.stream(patterns).allMatch(this::contains); } - public boolean containsAnyIgnoreCase(int beginIndex, int endIndex, String... patterns) { - return Arrays.stream(patterns).anyMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); + public boolean contains(String pattern) { + return contains(pattern.getBytes()); } - public boolean containsAll(String... patterns) { - return Arrays.stream(patterns).allMatch(this::contains); + public boolean contains(byte[] pattern) { + return indexOf(pattern) >= 0; } - public boolean containsAllIgnoreCase(String... patterns) { - return Arrays.stream(patterns).allMatch(this::containsIgnoreCase); + public boolean containsAny(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).anyMatch(pattern -> contains(pattern, beginIndex, endIndex)); } public boolean containsAll(int beginIndex, int endIndex, String... patterns) { return Arrays.stream(patterns).allMatch(pattern -> contains(pattern, beginIndex, endIndex)); } - public boolean containsAllIgnoreCase(int beginIndex, int endIndex, String... patterns) { - return Arrays.stream(patterns).allMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); - } - - public boolean contains(String pattern) { - return contains(pattern.getBytes()); + public boolean contains(String pattern, int beginIndex, int endIndex) { + return contains(pattern.getBytes(), beginIndex, endIndex); } - public boolean containsIgnoreCase(String pattern) { - return containsIgnoreCase(pattern.getBytes()); + public boolean contains(byte[] pattern, int beginIndex, int endIndex) { + return indexOf(pattern, beginIndex, endIndex) >= 0; } - public boolean contains(String pattern, int beginIndex, int endIndex) { - return contains(pattern.getBytes(), beginIndex, endIndex); + public boolean containsAnyIgnoreCase(String... patterns) { + return Arrays.stream(patterns).anyMatch(this::containsIgnoreCase); } - public boolean containsIgnoreCase(String pattern, int beginIndex, int endIndex) { - return containsIgnoreCase(pattern.getBytes(), beginIndex, endIndex); + public boolean containsAllIgnoreCase(String... patterns) { + return Arrays.stream(patterns).allMatch(this::containsIgnoreCase); } - public boolean contains(byte[] pattern) { - return indexOf(pattern) >= 0; + public boolean containsIgnoreCase(String pattern) { + return containsIgnoreCase(pattern.getBytes()); } public boolean containsIgnoreCase(byte[] pattern) { return indexIgnoreCase(pattern) >= 0; } - public boolean contains(byte[] pattern, int beginIndex, int endIndex) { - return indexOf(pattern, beginIndex, endIndex) >= 0; + public boolean containsAnyIgnoreCase(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).anyMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); + } + + public boolean containsAllIgnoreCase(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).allMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); + } + + public boolean containsIgnoreCase(String pattern, int beginIndex, int endIndex) { + return containsIgnoreCase(pattern.getBytes(), beginIndex, endIndex); } public boolean containsIgnoreCase(byte[] pattern, int beginIndex, int endIndex) { From 849279aa101ac72ff598bbb09e520b3854b9fba2 Mon Sep 17 00:00:00 2001 From: flbruto <19573915+fbruton@users.noreply.github.com> Date: Sat, 10 Jun 2023 00:38:39 +0000 Subject: [PATCH 3/4] Second attempt to reorder methods based on comments --- .../emissary/util/search/ByteMatcher.java | 56 +++++++++---------- 1 file changed, 28 insertions(+), 28 deletions(-) diff --git a/src/main/java/emissary/util/search/ByteMatcher.java b/src/main/java/emissary/util/search/ByteMatcher.java index a53b77c19d..a89a148b45 100755 --- a/src/main/java/emissary/util/search/ByteMatcher.java +++ b/src/main/java/emissary/util/search/ByteMatcher.java @@ -67,14 +67,6 @@ public int length() { return mydata.length; } - public boolean containsAny(String... patterns) { - return Arrays.stream(patterns).anyMatch(this::contains); - } - - public boolean containsAll(String... patterns) { - return Arrays.stream(patterns).allMatch(this::contains); - } - public boolean contains(String pattern) { return contains(pattern.getBytes()); } @@ -83,14 +75,6 @@ public boolean contains(byte[] pattern) { return indexOf(pattern) >= 0; } - public boolean containsAny(int beginIndex, int endIndex, String... patterns) { - return Arrays.stream(patterns).anyMatch(pattern -> contains(pattern, beginIndex, endIndex)); - } - - public boolean containsAll(int beginIndex, int endIndex, String... patterns) { - return Arrays.stream(patterns).allMatch(pattern -> contains(pattern, beginIndex, endIndex)); - } - public boolean contains(String pattern, int beginIndex, int endIndex) { return contains(pattern.getBytes(), beginIndex, endIndex); } @@ -99,12 +83,28 @@ public boolean contains(byte[] pattern, int beginIndex, int endIndex) { return indexOf(pattern, beginIndex, endIndex) >= 0; } - public boolean containsAnyIgnoreCase(String... patterns) { - return Arrays.stream(patterns).anyMatch(this::containsIgnoreCase); + public boolean containsAny(String... patterns) { + return Arrays.stream(patterns).anyMatch(this::contains); } - public boolean containsAllIgnoreCase(String... patterns) { - return Arrays.stream(patterns).allMatch(this::containsIgnoreCase); + public boolean containsAny(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).anyMatch(pattern -> contains(pattern, beginIndex, endIndex)); + } + + public boolean containsAll(String... patterns) { + return Arrays.stream(patterns).allMatch(this::contains); + } + + public boolean containsAll(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).allMatch(pattern -> contains(pattern, beginIndex, endIndex)); + } + + public boolean containsIgnoreCase(String pattern, int beginIndex, int endIndex) { + return containsIgnoreCase(pattern.getBytes(), beginIndex, endIndex); + } + + public boolean containsIgnoreCase(byte[] pattern, int beginIndex, int endIndex) { + return indexIgnoreCase(pattern, beginIndex, endIndex) >= 0; } public boolean containsIgnoreCase(String pattern) { @@ -115,20 +115,20 @@ public boolean containsIgnoreCase(byte[] pattern) { return indexIgnoreCase(pattern) >= 0; } - public boolean containsAnyIgnoreCase(int beginIndex, int endIndex, String... patterns) { - return Arrays.stream(patterns).anyMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); + public boolean containsAnyIgnoreCase(String... patterns) { + return Arrays.stream(patterns).anyMatch(this::containsIgnoreCase); } - public boolean containsAllIgnoreCase(int beginIndex, int endIndex, String... patterns) { - return Arrays.stream(patterns).allMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); + public boolean containsAnyIgnoreCase(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).anyMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); } - public boolean containsIgnoreCase(String pattern, int beginIndex, int endIndex) { - return containsIgnoreCase(pattern.getBytes(), beginIndex, endIndex); + public boolean containsAllIgnoreCase(String... patterns) { + return Arrays.stream(patterns).allMatch(this::containsIgnoreCase); } - public boolean containsIgnoreCase(byte[] pattern, int beginIndex, int endIndex) { - return indexIgnoreCase(pattern, beginIndex, endIndex) >= 0; + public boolean containsAllIgnoreCase(int beginIndex, int endIndex, String... patterns) { + return Arrays.stream(patterns).allMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); } /** From 21fa3bdc4a15cfa5b9c626f61aa3f0372c00ae4a Mon Sep 17 00:00:00 2001 From: flbruto <19573915+fbruton@users.noreply.github.com> Date: Sat, 24 Jun 2023 19:38:17 +0000 Subject: [PATCH 4/4] Adding Javadocs --- .../emissary/util/search/ByteMatcher.java | 127 ++++++++++++++++++ 1 file changed, 127 insertions(+) diff --git a/src/main/java/emissary/util/search/ByteMatcher.java b/src/main/java/emissary/util/search/ByteMatcher.java index a89a148b45..e4d8ed858a 100755 --- a/src/main/java/emissary/util/search/ByteMatcher.java +++ b/src/main/java/emissary/util/search/ByteMatcher.java @@ -67,66 +67,193 @@ public int length() { return mydata.length; } + /** + * Checks if data contains the string pattern + * + * @param pattern string to find + * + * @return true if data contains the search pattern, false if not or null string input + */ public boolean contains(String pattern) { return contains(pattern.getBytes()); } + /** + * Checks if data contains the byte array pattern + * + * @param pattern bytes to find + * + * @return true if data contains the search pattern, false if not or null byte array input + */ public boolean contains(byte[] pattern) { return indexOf(pattern) >= 0; } + /** + * Checks if data contains the string pattern + * + * @param pattern string to find + * @param beginIndex start index + * @param endIndex the index to stop searching at, exclusive + * + * @return true if data contains the search pattern, false if not or null string input + */ public boolean contains(String pattern, int beginIndex, int endIndex) { return contains(pattern.getBytes(), beginIndex, endIndex); } + /** + * Checks if data contains the byte array pattern + * + * @param pattern bytes to find + * @param beginIndex start index + * @param endIndex the index to stop searching at, exclusive + * + * @return true if data contains the search pattern, false if not or null byte array input + */ public boolean contains(byte[] pattern, int beginIndex, int endIndex) { return indexOf(pattern, beginIndex, endIndex) >= 0; } + /** + * Checks if data contains any of the string patterns + * + * @param patterns strings to find + * + * @return true if data contains the search pattern, false if not or null string input + */ public boolean containsAny(String... patterns) { return Arrays.stream(patterns).anyMatch(this::contains); } + /** + * Checks if data contains any of the string patterns + * + * @param beginIndex start index + * @param endIndex the index to stop searching at, exclusive + * + * @param patterns true if data contains any search pattern, false if not or null string input + */ public boolean containsAny(int beginIndex, int endIndex, String... patterns) { return Arrays.stream(patterns).anyMatch(pattern -> contains(pattern, beginIndex, endIndex)); } + /** + * Checks if data contains all string patterns + * + * @param patterns strings to find + * + * @return true if data contains all search patterns, false if not or null string input + */ public boolean containsAll(String... patterns) { return Arrays.stream(patterns).allMatch(this::contains); } + /** + * Checks if data contains all string patterns + * + * @param beginIndex start index + * @param endIndex the index to stop searching at, exclusive + * @param patterns strings to find + * + * @return true if data contains all search patterns, false if not or null string input + */ public boolean containsAll(int beginIndex, int endIndex, String... patterns) { return Arrays.stream(patterns).allMatch(pattern -> contains(pattern, beginIndex, endIndex)); } + /** + * Checks if data contains the string pattern ignoring upper/lower case + * + * @param pattern string to find + * @param beginIndex start index + * @param endIndex the index to stop searching at, exclusive + * + * @return true if data contains search pattern, false if not or null string input + */ public boolean containsIgnoreCase(String pattern, int beginIndex, int endIndex) { return containsIgnoreCase(pattern.getBytes(), beginIndex, endIndex); } + /** + * Checks if data contains the byte array pattern ignoring upper/lower case + * + * @param pattern bytes to find + * @param beginIndex start index + * @param endIndex the index to stop searching at, exclusive + * + * @return true if data contains all search patterns, false if not or null byte array input + */ public boolean containsIgnoreCase(byte[] pattern, int beginIndex, int endIndex) { return indexIgnoreCase(pattern, beginIndex, endIndex) >= 0; } + /** + * Checks if data contains the string pattern ignoring upper/lower case + * + * @param pattern string to find + * + * @return true if data contains search pattern, false if not or null string input + */ public boolean containsIgnoreCase(String pattern) { return containsIgnoreCase(pattern.getBytes()); } + /** + * Checks if data contains the byte array pattern ignoring upper/lower case + * + * @param pattern bytes to find + * + * @return true if data contains search pattern, false if not or null byte array input + */ public boolean containsIgnoreCase(byte[] pattern) { return indexIgnoreCase(pattern) >= 0; } + /** + * Checks if data contains any of the string patterns ignoring upper/lower case + * + * @param patterns strings to find + * + * @return true if data contains any search pattern, false if not or null string input + */ public boolean containsAnyIgnoreCase(String... patterns) { return Arrays.stream(patterns).anyMatch(this::containsIgnoreCase); } + /** + * Checks if data contains any of the string patterns ignoring upper/lower case + * + * @param beginIndex start index + * @param endIndex the index to stop searching at, exclusive + * @param patterns strings to find + * + * @return true if data contains any search pattern, false if not or null string input + */ public boolean containsAnyIgnoreCase(int beginIndex, int endIndex, String... patterns) { return Arrays.stream(patterns).anyMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); } + /** + * Checks if data contains all string patterns ignoring upper/lower case + * + * @param patterns strings to find + * + * @return true if data contains search pattern, false if not or null string input + */ public boolean containsAllIgnoreCase(String... patterns) { return Arrays.stream(patterns).allMatch(this::containsIgnoreCase); } + /** + * Checks if data contains all string patterns ignoring upper/lower case + * + * @param beginIndex start index + * @param endIndex the index to stop searching at, exclusive + * @param patterns strings to find + * + * @return true if data contains all search patterns, false if not or null string input + */ public boolean containsAllIgnoreCase(int beginIndex, int endIndex, String... patterns) { return Arrays.stream(patterns).allMatch(pattern -> containsIgnoreCase(pattern, beginIndex, endIndex)); }