tests/org.eclipse.ui.tests/Eclipse UI Tests/org/eclipse/ui/tests/dialogs/SearchPatternAuto.java

/*******************************************************************************
 * 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());
		}
	}
	
}