| ///******************************************************************************* |
| // * Copyright (c) 2006, 2007 IBM Corporation and others. |
| // * All rights reserved. This program and the accompanying materials |
| // * are made available under the terms of the Eclipse Public License v1.0 |
| // * which accompanies this distribution, and is available at |
| // * http://www.eclipse.org/legal/epl-v10.html |
| // * |
| // * Contributors: |
| // * IBM Corporation - initial API and implementation |
| // *******************************************************************************/ |
| // |
| //package org.eclipse.ui.tests.dialogs; |
| // |
| //import java.util.ArrayList; |
| //import java.util.Iterator; |
| //import java.util.regex.Pattern; |
| // |
| //import junit.framework.TestCase; |
| // |
| //import org.eclipse.ui.dialogs.SearchPattern; |
| // |
| ///** |
| // * Test case for tests SearchPattern match functionality |
| // * |
| // * @since 3.3 |
| // * |
| // */ |
| //public class SearchPatternAuto extends TestCase { |
| // |
| // private static ArrayList resources = new ArrayList(); |
| // |
| // |
| // static { |
| // |
| // generateRescourcesTestCases('A', 'C', 8, ""); |
| // |
| // generateRescourcesTestCases('A', 'C', 4, ""); |
| // |
| // } |
| // /** |
| // * @param name |
| // */ |
| // public SearchPatternAuto(String name) { |
| // super(name); |
| // } |
| // |
| // /* (non-Javadoc) |
| // * @see junit.framework.TestCase#setUp() |
| // */ |
| // protected void setUp() throws Exception { |
| // super.setUp(); |
| // } |
| // |
| // /** |
| // * Generates strings data for match test cases. |
| // * |
| // * @param startChar |
| // * @param endChar |
| // * @param lenght |
| // * @param resource |
| // */ |
| // private static void generateRescourcesTestCases(char startChar, char endChar, int lenght, String resource){ |
| // for (char ch = startChar; ch <= endChar; ch++) { |
| // String res = resource + String.valueOf(ch); |
| // if (lenght == 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); |
| // else |
| // generateRescourcesTestCases(Character.toLowerCase((char)(startChar + 1)), Character.toLowerCase((char)(endChar + 1)), lenght, res); |
| // } |
| // } |
| // |
| // /* (non-Javadoc) |
| // * @see junit.framework.TestCase#tearDown() |
| // */ |
| // protected void tearDown() throws Exception { |
| // super.tearDown(); |
| // } |
| // |
| // /** |
| // * Tests exact match functionality. If we camelCase rule is enable, Pattern should starts with lowerCase character. |
| // * Result for "abcd " pattern should be similar to regexp pattern "abcd" with case insensitive. |
| // */ |
| // public void testExactMatch1() { |
| // String patternText = "abcd "; |
| // Pattern pattern = Pattern.compile("abcd", Pattern.CASE_INSENSITIVE); |
| // SearchPattern patternMatcher = new SearchPattern(); |
| // patternMatcher.setPattern(patternText); |
| // assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_EXACT_MATCH); |
| // for (Iterator iter = resources.iterator(); iter.hasNext();) { |
| // String res = (String) iter.next(); |
| // assertEquals(patternMatcher.matches(res), pattern.matcher(res).matches()); |
| // } |
| // } |
| // |
| // /** |
| // * 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. |
| // */ |
| // public void testExactMatch2() { |
| // String patternText = "abcdefgh<"; |
| // Pattern pattern = Pattern.compile("abcdefgh", Pattern.CASE_INSENSITIVE); |
| // SearchPattern patternMatcher = new SearchPattern(); |
| // patternMatcher.setPattern(patternText); |
| // assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_EXACT_MATCH); |
| // for (Iterator iter = resources.iterator(); iter.hasNext();) { |
| // String res = (String) iter.next(); |
| // assertEquals(patternMatcher.matches(res), pattern.matcher(res).matches()); |
| // } |
| // } |
| // |
| // /** |
| // * Tests prefix match functionality. If we camelCase rule is enable, Pattern should starts with lowerCase character. |
| // * Result for "ab" pattern should be similar to regexp pattern "ab.*" with case insensitive. |
| // */ |
| // public void testPrefixMatch() { |
| // String patternText = "ab"; |
| // Pattern pattern = Pattern.compile("ab.*", Pattern.CASE_INSENSITIVE); |
| // SearchPattern patternMatcher = new SearchPattern(); |
| // patternMatcher.setPattern(patternText); |
| // assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_PREFIX_MATCH); |
| // for (Iterator iter = resources.iterator(); iter.hasNext();) { |
| // String res = (String) iter.next(); |
| // assertEquals(patternMatcher.matches(res), pattern.matcher(res).matches()); |
| // } |
| // } |
| // |
| // /** |
| // * Tests pattern match functionality. It's similar to regexp patterns. |
| // * Result for "**cDe" pattern should be similar to regexp pattern ".*cde.*" with case insensitive. |
| // */ |
| // public void testPatternMatch1() { |
| // String patternText = "**cDe"; |
| // Pattern pattern = Pattern.compile(".*cde.*", Pattern.CASE_INSENSITIVE); |
| // SearchPattern patternMatcher = new SearchPattern(); |
| // patternMatcher.setPattern(patternText); |
| // assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_PATTERN_MATCH); |
| // for (Iterator iter = resources.iterator(); iter.hasNext();) { |
| // String res = (String) iter.next(); |
| // assertEquals(patternMatcher.matches(res), pattern.matcher(res).matches()); |
| // } |
| // } |
| // |
| // /** |
| // * 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. |
| // */ |
| // public void testPatternMatch2() { |
| // String patternText = "**c*e*i"; |
| // Pattern pattern = Pattern.compile(".*c.*e.*i.*", Pattern.CASE_INSENSITIVE); |
| // SearchPattern patternMatcher = new SearchPattern(); |
| // patternMatcher.setPattern(patternText); |
| // assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_PATTERN_MATCH); |
| // for (Iterator iter = resources.iterator(); iter.hasNext();) { |
| // String res = (String) iter.next(); |
| // assertEquals(patternMatcher.matches(res), pattern.matcher(res).matches()); |
| // } |
| // } |
| // |
| // /** |
| // * 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. |
| // */ |
| // public void testCamelCaseMatch1() { |
| // String patternText = "CD"; |
| // Pattern pattern = Pattern.compile("C[^A-Z]*D.*"); |
| // Pattern pattern2 = Pattern.compile("CD.*", Pattern.CASE_INSENSITIVE); |
| // SearchPattern patternMatcher = new SearchPattern(); |
| // patternMatcher.setPattern(patternText); |
| // assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_CAMELCASE_MATCH); |
| // for (Iterator iter = resources.iterator(); iter.hasNext();) { |
| // String res = (String) iter.next(); |
| // if (patternMatcher.matches(res) != pattern.matcher(res).matches()) { |
| // assertEquals(patternMatcher.matches(res), pattern2.matcher(res).matches()); |
| // } |
| // } |
| // } |
| // |
| // /** |
| // * 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.*" |
| // */ |
| // public void testCamelCaseMatch2() { |
| // String patternText = "AbCd "; |
| // Pattern pattern = Pattern.compile("Ab[^A-Z]*Cd[^A-Z]*"); |
| // SearchPattern patternMatcher = new SearchPattern(); |
| // patternMatcher.setPattern(patternText); |
| // assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_CAMELCASE_MATCH); |
| // for (Iterator iter = resources.iterator(); iter.hasNext();) { |
| // String res = (String) iter.next(); |
| // assertEquals(patternMatcher.matches(res), pattern.matcher(res).matches()); |
| // } |
| // } |
| // |
| // /** |
| // * 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]*" |
| // */ |
| // public void testCamelCaseMatch3() { |
| // String patternText = "AbCdE<"; |
| // Pattern pattern = Pattern.compile("Ab[^A-Z]*Cd[^A-Z]*E[^A-Z]*"); |
| // SearchPattern patternMatcher = new SearchPattern(); |
| // patternMatcher.setPattern(patternText); |
| // assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_CAMELCASE_MATCH); |
| // for (Iterator iter = resources.iterator(); iter.hasNext();) { |
| // String res = (String) iter.next(); |
| // assertEquals(patternMatcher.matches(res), pattern.matcher(res).matches()); |
| // } |
| // } |
| // |
| // /** |
| // * Tests blank match functionality. |
| // * Blank string should be recognize as blank pattern match rule. |
| // * It should match with all resources. |
| // * Result for SearchPattern should be similar to regexp pattern ".*" |
| // */ |
| // public void testBlankMatch() { |
| // String patternText = ""; |
| // Pattern pattern = Pattern.compile(".*", Pattern.CASE_INSENSITIVE); |
| // SearchPattern patternMatcher = new SearchPattern(); |
| // patternMatcher.setPattern(patternText); |
| // assertEquals(patternMatcher.getMatchRule(), SearchPattern.RULE_BLANK_MATCH); |
| // for (Iterator iter = resources.iterator(); iter.hasNext();) { |
| // String res = (String) iter.next(); |
| // assertEquals(patternMatcher.matches(res), pattern.matcher(res).matches()); |
| // } |
| // } |
| // |
| //} |
