Make SearchPattern test case more readable
* fix typos and grammar
* ending pattern with " " or "<" should have the same results, therefore
test these in the same way in order to avoid confusion
* fix assertEquals() parameters order
* make identifiers more self-explaining
Signed-off-by: Petr Bodnar <p.bodnar@centrum.cz>
Change-Id: Id6605422b939f201e8a4fe7852e1bf725e0dd8dd
Reviewed-on: https://git.eclipse.org/r/c/platform/eclipse.platform.ui/+/192602
Tested-by: Platform Bot <platform-bot@eclipse.org>
Reviewed-by: Mickael Istria <mistria@redhat.com>
diff --git a/tests/org.eclipse.ui.tests/Eclipse UI Tests/org/eclipse/ui/tests/dialogs/SearchPatternAuto.java b/tests/org.eclipse.ui.tests/Eclipse UI Tests/org/eclipse/ui/tests/dialogs/SearchPatternAuto.java
index 391cab5..71da081 100644
--- a/tests/org.eclipse.ui.tests/Eclipse UI Tests/org/eclipse/ui/tests/dialogs/SearchPatternAuto.java
+++ b/tests/org.eclipse.ui.tests/Eclipse UI Tests/org/eclipse/ui/tests/dialogs/SearchPatternAuto.java
@@ -26,18 +26,20 @@
import org.junit.Test;
/**
- * Test case for tests SearchPattern match functionality
+ * Tests of the SearchPattern's match functionality.
*
* @since 3.3
- *
*/
public class SearchPatternAuto {
+ /**
+ * Items to be filtered.
+ */
private static List<String> resources = new ArrayList<>();
static {
- generateRescourcesTestCases('A', 'C', 8, "");
- generateRescourcesTestCases('A', 'C', 4, "");
+ generateResourcesTestCases('A', 'C', 8, "");
+ generateResourcesTestCases('A', 'C', 4, "");
}
/**
@@ -45,44 +47,39 @@
*
* @param startChar
* @param endChar
- * @param lenght
+ * @param length
* @param resource
*/
- private static void generateRescourcesTestCases(char startChar, char endChar, int lenght, String resource){
+ private static void generateResourcesTestCases(char startChar, char endChar, int length, String resource) {
for (char ch = startChar; ch <= endChar; ch++) {
String res = resource + ch;
- if (lenght == res.length()) {
+ if (length == res.length()) {
resources.add(res);
} else if ((res.trim().length() % 2) == 0) {
- generateRescourcesTestCases(Character.toUpperCase((char)(startChar + 1)), Character.toUpperCase((char)(endChar + 1)), lenght, res);
+ generateResourcesTestCases(Character.toUpperCase((char)(startChar + 1)), Character.toUpperCase((char)(endChar + 1)), length, res);
} else {
- generateRescourcesTestCases(Character.toLowerCase((char)(startChar + 1)), Character.toLowerCase((char)(endChar + 1)), lenght, res);
+ generateResourcesTestCases(Character.toLowerCase((char)(startChar + 1)), Character.toLowerCase((char)(endChar + 1)), length, res);
}
}
}
/**
- * Tests exact match functionality. If we camelCase rule is enable, Pattern should starts with lowerCase character.
+ * Tests exact match functionality.
+ * If camelCase rule is enabled, Pattern should start with lowerCase character.
* Result for "abcd " pattern should be similar to regexp pattern "abcd" with case insensitive.
*/
@Test
- public void testExactMatch1() {
+ public void testExactMatch() {
Pattern pattern = Pattern.compile("abcd", Pattern.CASE_INSENSITIVE);
assertMatches("abcd ", SearchPattern.RULE_EXACT_MATCH, pattern);
+ // alternative ending character:
+ assertMatches("abcd<", SearchPattern.RULE_EXACT_MATCH, pattern);
}
- /**
- * Tests exact match functionality. If we camelCase rule is enable, Pattern should starts with lowerCase character.
- * Result for "abcdefgh<" pattern should be similar to regexp pattern "abcdefgh" with case insensitive.
- */
- @Test
- public void testExactMatch2() {
- Pattern pattern = Pattern.compile("abcdefgh", Pattern.CASE_INSENSITIVE);
- assertMatches("abcdefgh<", SearchPattern.RULE_EXACT_MATCH, pattern);
- }
/**
- * Tests prefix match functionality. If we camelCase rule is enable, Pattern should starts with lowerCase character.
+ * Tests prefix match functionality.
+ * If camelCase rule is enabled, Pattern should start with lowerCase character.
* Result for "ab" pattern should be similar to regexp pattern "ab.*" with case insensitive.
*/
@Test
@@ -93,32 +90,34 @@
/**
* Tests pattern match functionality. It's similar to regexp patterns.
- * Result for "**cDe" pattern should be similar to regexp pattern ".*cde.*" with case insensitive.
+ * Result for "*cDe" pattern should be similar to regexp pattern ".*cde.*" with case insensitive.
*/
@Test
public void testPatternMatch1() {
Pattern pattern = Pattern.compile(".*cde.*", Pattern.CASE_INSENSITIVE);
+ assertMatches("*cDe", SearchPattern.RULE_PATTERN_MATCH, pattern);
+ // 1 or more consecutive '*' has to be the same as 1 '*'
assertMatches("**cDe", SearchPattern.RULE_PATTERN_MATCH, pattern);
}
/**
* Tests pattern match functionality. It's similar to regexp patterns.
- * Result for "**c*e*i" pattern should be similar to regexp pattern ".*c.*e.*i.*" with case insensitive.
+ * Result for "*c*e*i" pattern should be similar to regexp pattern ".*c.*e.*i.*" with case insensitive.
*/
@Test
public void testPatternMatch2() {
Pattern pattern = Pattern.compile(".*c.*e.*i.*", Pattern.CASE_INSENSITIVE);
- assertMatches("**c*e*i", SearchPattern.RULE_PATTERN_MATCH, pattern);
+ assertMatches("*c*e*i", SearchPattern.RULE_PATTERN_MATCH, pattern);
}
/**
* Tests camelCase match functionality.
- * Every string starts with upperCase characters should be recognize as camelCase pattern match rule.
- * Result for "CD" SearchPattern should be similar to regexp pattern "C[^A-Z]*D.*" or "CD.*"
- * If pattern contains only upperCase characters result contains all prefix match elements.
+ * Every string starting with an upperCase character should be recognized as camelCase pattern match rule.
+ * Result for "CD" SearchPattern should be similar to regexp pattern "C[^A-Z]*D.*".
+ * If pattern contains only upperCase characters, result also contains all prefix match elements.
*/
@Test
- public void testCamelCaseMatch1() {
+ public void testCamelCaseMatch() {
Pattern pattern = Pattern.compile("C[^A-Z]*D.*");
Pattern pattern2 = Pattern.compile("CD.*", Pattern.CASE_INSENSITIVE);
assertMatches("CD", SearchPattern.RULE_CAMELCASE_MATCH, pattern, pattern2);
@@ -126,29 +125,20 @@
/**
* Tests camelCase match functionality.
- * Every string starts with upperCase characters should be recognize as camelCase pattern match rule.
- * Result for "AbCd " SearchPattern should be similar to regexp pattern "C[^A-Z]*D.*" or "CD.*"
+ * Every string starting with an upperCase character should be recognized as camelCase pattern match rule.
+ * Result for "AbCd " SearchPattern should be similar to regexp pattern "Ab[^A-Z]*Cd[^A-Z]*".
*/
@Test
- public void testCamelCaseMatch2() {
+ public void testCamelCaseForcedEndMatch() {
Pattern pattern = Pattern.compile("Ab[^A-Z]*Cd[^A-Z]*");
assertMatches("AbCd ", SearchPattern.RULE_CAMELCASE_MATCH, pattern);
- }
-
- /**
- * Tests camelCase match functionality.
- * Every string starts with upperCase characters should be recognize as camelCase pattern match rule.
- * Result for "AbCdE<" SearchPattern should be similar to regexp pattern "Ab[^A-Z]*Cd[^A-Z]*E[^A-Z]*"
- */
- @Test
- public void testCamelCaseMatch3() {
- Pattern pattern = Pattern.compile("Ab[^A-Z]*Cd[^A-Z]*E[^A-Z]*");
- assertMatches("AbCdE<", SearchPattern.RULE_CAMELCASE_MATCH, pattern);
+ // alternative ending character:
+ assertMatches("AbCd<", SearchPattern.RULE_CAMELCASE_MATCH, pattern);
}
/**
* Tests blank match functionality.
- * Blank string should be recognize as blank pattern match rule.
+ * Blank string should be recognized as a blank pattern match rule.
* It should match with all resources.
* Result for SearchPattern should be similar to regexp pattern ".*"
*/
@@ -158,28 +148,29 @@
assertMatches("", SearchPattern.RULE_BLANK_MATCH, pattern);
}
- private void assertMatches(String patternText, int searchPattern, Pattern... patterns) {
+ private void assertMatches(String patternText, int expectedMatchRule, Pattern... matchingPatterns) {
SearchPattern patternMatcher = new SearchPattern();
patternMatcher.setPattern(patternText);
- assertEquals(patternMatcher.getMatchRule(), searchPattern);
+ assertEquals(expectedMatchRule, patternMatcher.getMatchRule());
for (String res : resources) {
- boolean anyMatches = anyMatches(res, patterns);
+ boolean anyMatches = anyMatches(res, matchingPatterns);
boolean patternMatches = patternMatcher.matches(res);
if (patternMatches) {
- assertTrue("Pattern '" + patternText + "' matches '" + res + "' but other patterns don't.", anyMatches);
+ assertTrue("Pattern '" + patternText + "' matches '" + res + "', but it shouldn't.", anyMatches);
} else {
- assertFalse("Pattern '" + patternText + "' doesn't match '" + res + "' but other patterns do.",
+ assertFalse("Pattern '" + patternText + "' doesn't match '" + res + "', but it should.",
anyMatches);
}
}
}
private static boolean anyMatches(String res, Pattern... patterns) {
- boolean result = false;
for (Pattern pattern : patterns) {
- result |= pattern.matcher(res).matches();
+ if (pattern.matcher(res).matches()) {
+ return true;
+ }
}
- return result;
+ return false;
}
}
