import org.eclipse.jdt.internal.core.search.StringOperation;

	return StringOperation.getCamelCaseMatchingRegions(pattern, patternStart, patternEnd, name, nameStart, nameEnd, samePartCount) != null;

}

	return null;

/*******************************************************************************

 * Copyright (c) 2000, 2009 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.jdt.internal.core.search;

import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;

/**

 * This class is a collection of helper methods to manipulate strings during search.

 *

 * @noinstantiate This class is not intended to be instantiated by clients.

 */

public final class StringOperation {

public static final int[] getCamelCaseMatchingRegions(String pattern, int patternStart, int patternEnd, String name, int nameStart, int nameEnd, boolean samePartCount) {

//	/* !!!!!!!!!! WARNING !!!!!!!!!!

//	 * The content of this method has been fully copied to

//	 * SearchPattern#camelCaseMatch(String, int, int, String, int, int, boolean).

//	 *

//	 * So, if current method is modified, do NOT forget to copy again its content

//	 * to SearchPattern corresponding method!

//	 */

	if (name == null)

		return null; // null name cannot match

	if (pattern == null)

		return new int[] { patternStart, patternEnd-patternStart }; // null pattern is equivalent to '*'

	if (patternEnd < 0) 	patternEnd = pattern.length();

	if (nameEnd < 0) nameEnd = name.length();

	if (patternEnd <= patternStart) {

		return nameEnd <= nameStart

			? new int[] { patternStart, patternEnd-patternStart }

			: null;

	}

	if (nameEnd <= nameStart) return null;

	// check first pattern char

	if (name.charAt(nameStart) != pattern.charAt(patternStart)) {

		// first char must strictly match (upper/lower)

		return null;

	}

	char patternChar, nameChar;

	int iPattern = patternStart;

	int iName = nameStart;

	// init segments

	int parts = 1;

	for (int i=patternStart+1; i<patternEnd; i++) {

		if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[pattern.charAt(i)] & (ScannerHelper.C_UPPER_LETTER | ScannerHelper.C_DIGIT)) != 0) {

			parts++;

		}

	}

	int[] segments = null;

	int count = 0; // count

	// Main loop is on pattern characters

	int segmentStart = iName;

	while (true) {

		iPattern++;

		iName++;

		if (iPattern == patternEnd) { // we have exhausted pattern...

			// it's a match if the name can have additional parts (i.e. uppercase characters) or is also exhausted

			if (!samePartCount || iName == nameEnd) {

				if (segments == null) {

					segments = new int[2];

				}

				segments[count++] = segmentStart;

				segments[count++] = iName - segmentStart;

				if (count < segments.length) {

					System.arraycopy(segments, 0, segments = new int[count], 0, count);

				}

				return segments;

			}

			// otherwise it's a match only if the name has no more uppercase characters

			int segmentEnd = iName;

			while (true) {

				if (iName == nameEnd) {

					// we have exhausted the name, so it's a match

					if (segments == null) {

						segments = new int[2];

					}

					segments[count++] = segmentStart;

					segments[count++] = segmentEnd - segmentStart;

					if (count < segments.length) {

						System.arraycopy(segments, 0, segments = new int[count], 0, count);

					}

					return segments;

				}

				nameChar = name.charAt(iName);

				// test if the name character is uppercase

				if (nameChar < ScannerHelper.MAX_OBVIOUS) {

					if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar] & ScannerHelper.C_UPPER_LETTER) != 0) {

						return null;

					}

				}

				else if (!Character.isJavaIdentifierPart(nameChar) || Character.isUpperCase(nameChar)) {

					return null;

				}

				iName++;

			}

		}

		if (iName == nameEnd){

			// We have exhausted the name (and not the pattern), so it's not a match

			return null;

		}

		// For as long as we're exactly matching, bring it on (even if it's a lower case character)

		if ((patternChar = pattern.charAt(iPattern)) == name.charAt(iName)) {

			continue;

		}

		int segmentEnd = iName;

		// If characters are not equals, then it's not a match if patternChar is lowercase

		if (patternChar < ScannerHelper.MAX_OBVIOUS) {

			if ((ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[patternChar] & (ScannerHelper.C_UPPER_LETTER | ScannerHelper.C_DIGIT)) == 0) {

				return null;

			}

		} else if (Character.isJavaIdentifierPart(patternChar) && !Character.isUpperCase(patternChar) && !Character.isDigit(patternChar)) {

			return null;

		}

		// patternChar is uppercase, so let's find the next uppercase in name

		while (true) {

			if (iName == nameEnd){

	            //	We have exhausted name (and not pattern), so it's not a match

				return null;

			}

			nameChar = name.charAt(iName);

			if (nameChar < ScannerHelper.MAX_OBVIOUS) {

				int charNature = ScannerHelper.OBVIOUS_IDENT_CHAR_NATURES[nameChar];

				if ((charNature & (ScannerHelper.C_LOWER_LETTER | ScannerHelper.C_SPECIAL)) != 0) {

					// nameChar is lowercase

					iName++;

				} else if ((charNature & ScannerHelper.C_DIGIT) != 0) {

					// nameChar is digit => break if the digit is current pattern character otherwise consume it

					if (patternChar == nameChar) break;

					iName++;

				// nameChar is uppercase...

				} else  if (patternChar != nameChar) {

					//.. and it does not match patternChar, so it's not a match

					return null;

				} else {

					//.. and it matched patternChar. Back to the big loop

					break;

				}

			}

			// Same tests for non-obvious characters

			else if (Character.isJavaIdentifierPart(nameChar) && !Character.isUpperCase(nameChar)) {

				iName++;

			} else if (Character.isDigit(nameChar)) {

				if (patternChar == nameChar) break;

				iName++;

			} else  if (patternChar != nameChar) {

				return null;

			} else {

				break;

			}

		}

		// At this point, either name has been exhausted, or it is at an uppercase letter.

		// Since pattern is also at an uppercase letter

		if (segments == null) {

			segments = new int[parts*2];

		}

		segments[count++] = segmentStart;

		segments[count++] = segmentEnd - segmentStart;

		segmentStart = iName;

	}

}

public static final int[] getPatternMatchingRegions(

	String pattern,

	int patternStart,

	int patternEnd,

	String name,

	int nameStart,

	int nameEnd,

	boolean isCaseSensitive) {

	if (name == null)

		return null; // null name cannot match

	if (pattern == null)

		return new int[] { patternStart, patternEnd-patternStart }; // null pattern is equivalent to '*'

	int iPattern = patternStart;

	int iName = nameStart;

	// init segments parts

	if (patternEnd < 0)

		patternEnd = pattern.length();

	if (nameEnd < 0)

		nameEnd = name.length();

	int questions = 0;

	int stars = 0;

	int parts = 0;

	char previous = 0;

	for (int i=patternStart; i<patternEnd; i++) {

		char ch = pattern.charAt(i);

		switch (ch) {

			case '?':

				questions++;

				break;

			case '*':

				stars++;

				break;

			default:

				switch (previous) {

					case 0 :

					case '?':

					case '*':

						parts++;

						break;

				}

		}

		previous = ch;

	}

	int[] segments = new int[parts*2];

	/* check first segment */

	int count = 0;

	int start = iName;

	char patternChar = 0;

	previous = 0;

	while ((iPattern < patternEnd)

		&& (patternChar = pattern.charAt(iPattern)) != '*') {

		if (iName == nameEnd)

			return null;

		if (patternChar == '?') {

			switch (previous) {

				case 0:

				case '?':

					break;

				default:

					segments[count++] = start;

					segments[count++] = iPattern-start;

					break;

			}

		} else {

			if (patternChar != (isCaseSensitive ? name.charAt(iName) : ScannerHelper.toLowerCase(name.charAt(iName)))) {

				return null;

			}

			switch (previous) {

				case 0:

				case '?':

					start = iPattern;

					break;

			}

		}

		iName++;

		iPattern++;

		previous = patternChar;

	}

	/* check sequence of star+segment */

	int segmentStart;

	if (patternChar == '*') {

		if (iPattern > 0) {

			segments[count++] = start;

			segments[count++] = iName-start;

			start = iName;

		}

		segmentStart = ++iPattern; // skip star

	} else {

		if (iName == nameEnd) {

			if (count == (parts*2)) return segments;

			int end = patternEnd;

			if (previous == '?') { // last char was a '?' => purge all trailing '?'

				while (pattern.charAt(--end-1) == '?') {

					if (end == start) {

						return new int[] { patternStart, patternEnd-patternStart };

					}

				}

			}

			return new int[] { start, end-start };

		}

		return null;

	}

	int prefixStart = iName;

	previous = patternChar;

	char previousSegment = patternChar;

	checkSegment : while (iName < nameEnd) {

		if (iPattern == patternEnd) {

			iPattern = segmentStart; // mismatch - restart current segment

			iName = ++prefixStart;

			previous = previousSegment;

			continue checkSegment;

		}

		/* segment is ending */

		if ((patternChar = pattern.charAt(iPattern)) == '*') {

			segmentStart = ++iPattern; // skip star

			if (segmentStart == patternEnd) {

				if (count < (parts*2)) {

					segments[count++] = start;

					segments[count++] = iName-start;

				}

				return segments;

			}

			switch (previous) {

				case '*':

				case '?':

					break;

				default:

					segments[count++] = start;

					segments[count++] = iName-start;

					break;

			}

			prefixStart = iName;

			start = prefixStart;

			previous = patternChar;

			previousSegment = patternChar;

			continue checkSegment;

		}

		/* check current name character */

		if (patternChar == '?') {

			switch (previous) {

				case '*':

				case '?':

					break;

				default:

					segments[count++] = start;

					segments[count++] = iName-start;

					break;

			}

		} else {

			if ((isCaseSensitive ? name.charAt(iName) : ScannerHelper.toLowerCase(name.charAt(iName))) != patternChar) {

				iPattern = segmentStart; // mismatch - restart current segment

				iName = ++prefixStart;

				start = prefixStart;

				if (previous == '?') count -= 2;

				previous = previousSegment;

				continue checkSegment;

			}

			switch (previous) {

				case '?':

					start = iName;

					break;

			}

		}

		iName++;

		iPattern++;

		previous = patternChar;

	}

	if ((segmentStart == patternEnd)

		|| (iName == nameEnd && iPattern == patternEnd)

		|| (iPattern == patternEnd - 1 && pattern.charAt(iPattern) == '*')) {

		if (count < (parts*2)) {

			segments[count++] = start;

			segments[count++] = iName-start;

		}

		return segments;

	}

	return null;

}

}

package org.eclipse.jdt.core.tests.model;

import junit.framework.Test;

import org.eclipse.jdt.core.search.SearchPattern;

public class UtilTest extends AbstractJavaModelTests {

public UtilTest(String name) {

	super(name);

}

public static Test suite() {

	return buildTestSuite(UtilTest.class);

}

/*

 * Print regions in a string.

 */

private String printRegions(String name, int[] regions) {

	if (regions == null) return null;

	if (regions.length == 0) return name;

	StringBuffer buffer = new StringBuffer();

	int start = 0;

	for (int i=0; i<regions.length; i+=2) {

		int segmentStart = regions[i];

		int rLength = regions[i+1];

		if (start != segmentStart) {

			if (start > 0) buffer.append(']');

			buffer.append(name.substring(start, segmentStart));

			buffer.append('[');

		} else if (start == 0) {

			buffer.append('[');

		}

		buffer.append(name.substring(segmentStart, segmentStart+rLength));

		start = segmentStart+rLength;

	}

	buffer.append(']');

	int nLength= name.length();

	if (nLength > start) {

		buffer.append(name.substring(start, nLength));

	}

	return buffer.toString();

}

public void test0001() {

	String name = "int";

	int[] regions = SearchPattern.getMatchingRegions("int",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[int]", printRegions(name, regions));

}

public void test0002() {

	String name = "class_path";

	int[] regions = SearchPattern.getMatchingRegions("class*path",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "[class]_[path]", printRegions(name, regions));

}

public void test0003() {

	String name = "boolean";

	int[] regions = SearchPattern.getMatchingRegions("boolean",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[boolean]", printRegions(name, regions));

}

public void test0004() {

	String name = "p3.p2.p";

	int[] regions = SearchPattern.getMatchingRegions("p3*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[p3].p2.p", printRegions(name, regions));

}

public void test0005() {

	String name = "p3.p2";

	int[] regions = SearchPattern.getMatchingRegions("p3*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[p3].p2", printRegions(name, regions));

}

public void test0006() {

	String name = "p3";

	int[] regions = SearchPattern.getMatchingRegions("p3*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[p3]", printRegions(name, regions));

}

public void test0007() {

	String name = "j1";

	int[] regions = SearchPattern.getMatchingRegions("j?",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]1", printRegions(name, regions));

}

public void test0008() {

	String name = "j2";

	int[] regions = SearchPattern.getMatchingRegions("j?",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]2", printRegions(name, regions));

}

public void test0009() {

	String name = "j3";

	int[] regions = SearchPattern.getMatchingRegions("j?",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]3", printRegions(name, regions));

}

public void test0010() {

	String name = "j4";

	int[] regions = SearchPattern.getMatchingRegions("j?",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]4", printRegions(name, regions));

}

public void test0011() {

	String name = "j5";

	int[] regions = SearchPattern.getMatchingRegions("j?",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]5", printRegions(name, regions));

}

public void test0012() {

	String name = "j6";

	int[] regions = SearchPattern.getMatchingRegions("j?",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]6", printRegions(name, regions));

}

public void test0013() {

	String name = "j7";

	int[] regions = SearchPattern.getMatchingRegions("j?",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]7", printRegions(name, regions));

}

public void test0014() {

	String name = "j1";

	int[] regions = SearchPattern.getMatchingRegions("j*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]1", printRegions(name, regions));

}

public void test0015() {

	String name = "java";

	int[] regions = SearchPattern.getMatchingRegions("j*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]ava", printRegions(name, regions));

}

public void test0016() {

	String name = "j7.qua.li.fied";

	int[] regions = SearchPattern.getMatchingRegions("j*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]7.qua.li.fied", printRegions(name, regions));

}

public void test0017() {

	String name = "java.lang";

	int[] regions = SearchPattern.getMatchingRegions("j*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]ava.lang", printRegions(name, regions));

}

public void test0018() {

	String name = "java.io";

	int[] regions = SearchPattern.getMatchingRegions("j*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]ava.io", printRegions(name, regions));

}

public void test0019() {

	String name = "j7.qua.li";

	int[] regions = SearchPattern.getMatchingRegions("j*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]7.qua.li", printRegions(name, regions));

}

public void test0020() {

	String name = "j7.qua";

	int[] regions = SearchPattern.getMatchingRegions("j*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j]7.qua", printRegions(name, regions));

}

public void test0021() {

	String name = "j7.qua.li.fied";

	int[] regions = SearchPattern.getMatchingRegions("j7.*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[j7.]qua.li.fied", printRegions(name, regions));

}

public void test0022() {

	String name = "j7.qua.li.fied";

	int[] regions = SearchPattern.getMatchingRegions("j7.*.*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "[j7.]qua[.]li.fied", printRegions(name, regions));

}

public void test0023() {

	String name = "java.lang";

	int[] regions = SearchPattern.getMatchingRegions("????.????",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "java[.]lang", printRegions(name, regions));

}

public void test0024() {

	String name = "java";

	int[] regions = SearchPattern.getMatchingRegions("*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 0, regions.length);

	assertEquals("Unexpected matching regions", "java", printRegions(name, regions));

}

public void test0025() {

	String name = "p2";

	int[] regions = SearchPattern.getMatchingRegions("*p2",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[p2]", printRegions(name, regions));

}

public void test0026() {

	String name = "p3.p2.p";

	int[] regions = SearchPattern.getMatchingRegions("*p2.*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "p3.[p2.]p", printRegions(name, regions));

}

public void test0027() {

	String name = "p3.p2.p.X";

	int[] regions = SearchPattern.getMatchingRegions("*p2.*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "p3.[p2.]p.X", printRegions(name, regions));

}

public void test0028() {

	String name = "p3.p2.p.X.count";

	int[] regions = SearchPattern.getMatchingRegions("*p2.*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "p3.[p2.]p.X.count", printRegions(name, regions));

}

public void test0029() {

	String name = "p2.Z";

	int[] regions = SearchPattern.getMatchingRegions("*p2.*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[p2.]Z", printRegions(name, regions));

}

public void test0030() {

	String name = "foo/1";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]/1", printRegions(name, regions));

}

public void test0031() {

	String name = "foo";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]", printRegions(name, regions));

}

public void test0032() {

	String name = "foo/0";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]/0", printRegions(name, regions));

}

public void test0033() {

	String name = "foo2/0";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]2/0", printRegions(name, regions));

}

public void test0034() {

	String name = "foo2";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]2", printRegions(name, regions));

}

public void test0035() {

	String name = "foo/2";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]/2", printRegions(name, regions));

}

public void test0036() {

	String name = "foo1/0";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]1/0", printRegions(name, regions));

}

public void test0037() {

	String name = "foo24346/0";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]24346/0", printRegions(name, regions));

}

public void test0038() {

	String name = "foo/3";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]/3", printRegions(name, regions));

}

public void test0039() {

	String name = "foobar/0";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]bar/0", printRegions(name, regions));

}

public void test0040() {

	String name = "foo24346";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]24346", printRegions(name, regions));

}

public void test0041() {

	String name = "foobar";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]bar", printRegions(name, regions));

}

public void test0042() {

	String name = "foo1";

	int[] regions = SearchPattern.getMatchingRegions("foo*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[foo]1", printRegions(name, regions));

}

public void test0043() {

	String name = "X31985";

	int[] regions = SearchPattern.getMatchingRegions("x31985",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[X31985]", printRegions(name, regions));

}

public void test0044() {

	String name = "p24741";

	int[] regions = SearchPattern.getMatchingRegions("p24741",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[p24741]", printRegions(name, regions));

}

public void test0045() {

	String name = "p24741.A";

	int[] regions = SearchPattern.getMatchingRegions("p24741.*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[p24741.]A", printRegions(name, regions));

}

public void test0046() {

	String name = "Y";

	int[] regions = SearchPattern.getMatchingRegions("y",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[Y]", printRegions(name, regions));

}

public void test0047() {

	String name = "int[]";

	int[] regions = SearchPattern.getMatchingRegions("int[]",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[int[]]", printRegions(name, regions));

}

public void test0048() {

	String name = "boolean[]";

	int[] regions = SearchPattern.getMatchingRegions("boolean[]",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[boolean[]]", printRegions(name, regions));

}

public void test0049() {

	String name = "RuntimeException/java.lang//!";

	int[] regions = SearchPattern.getMatchingRegions("RE",  name, SearchPattern.R_CAMELCASE_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "[R]untime[E]xception/java.lang//!", printRegions(name, regions));

}

public void test0050() {

	String name = "RuntimeException/java.lang//!";

	int[] regions = SearchPattern.getMatchingRegions("RException",  name, SearchPattern.R_CAMELCASE_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "[R]untime[Exception]/java.lang//!", printRegions(name, regions));

}

public void test0051() {

	String name = "RuntimeException/java.lang//!";

	int[] regions = SearchPattern.getMatchingRegions("RuntimeException",  name, SearchPattern.R_CAMELCASE_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[RuntimeException]/java.lang//!", printRegions(name, regions));

}

public void test0052() {

	String name = "RuntimeException/java.lang//!";

	int[] regions = SearchPattern.getMatchingRegions("r*e*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "[R]untim[e]Exception/java.lang//!", printRegions(name, regions));

}

public void test0053() {

	String name = "RuntimeException";

	int[] regions = SearchPattern.getMatchingRegions("r*e*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "[R]untim[e]Exception", printRegions(name, regions));

}

public void test0054() {

	String name = "References/a3//";

	int[] regions = SearchPattern.getMatchingRegions("r*e*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "[Re]ferences/a3//", printRegions(name, regions));

}

public void test0055() {

	String name = "References";

	int[] regions = SearchPattern.getMatchingRegions("r*e*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "[Re]ferences", printRegions(name, regions));

}

public void test0056() {

	String name = "CloneNotSupportedException/java.lang//!";

	int[] regions = SearchPattern.getMatchingRegions("CNS",  name, SearchPattern.R_CAMELCASE_MATCH);

	assertEquals("Unexpected regions length", 6, regions.length);

	assertEquals("Unexpected matching regions", "[C]lone[N]ot[S]upportedException/java.lang//!", printRegions(name, regions));

}

public void test0057() {

	String name = "AA/d8//";

	int[] regions = SearchPattern.getMatchingRegions("AA",  name, SearchPattern.R_CAMELCASE_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[AA]/d8//", printRegions(name, regions));

}

public void test0058() {

	String name = "AbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyz/c9///S";

	int[] regions = SearchPattern.getMatchingRegions("AA",  name, SearchPattern.R_CAMELCASE_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "[A]bcdefghijklmnopqrstuvwxyz[A]bcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyz/c9///S", printRegions(name, regions));

}

public void test0059() {

	String name = "gen_obj";

	int[] regions = SearchPattern.getMatchingRegions("gen_???",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_]obj", printRegions(name, regions));

}

public void test0060() {

	String name = "gen_exc";

	int[] regions = SearchPattern.getMatchingRegions("gen_???",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_]exc", printRegions(name, regions));

}

public void test0061() {

	String name = "gen_wld";

	int[] regions = SearchPattern.getMatchingRegions("gen_???",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_]wld", printRegions(name, regions));

}

public void test0062() {

	String name = "gen_thr";

	int[] regions = SearchPattern.getMatchingRegions("gen_???",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_]thr", printRegions(name, regions));

}

public void test0063() {

	String name = "gen_run";

	int[] regions = SearchPattern.getMatchingRegions("gen_???",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_]run", printRegions(name, regions));

}

public void test0064() {

	String name = "gen_exc";

	int[] regions = SearchPattern.getMatchingRegions("gen_*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_]exc", printRegions(name, regions));

}

public void test0065() {

	String name = "gen_www";

	int[] regions = SearchPattern.getMatchingRegions("gen_*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_]www", printRegions(name, regions));

}

public void test0066() {

	String name = "test";

	int[] regions = SearchPattern.getMatchingRegions("test",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[test]", printRegions(name, regions));

}

public void test0067() {

	String name = "gen_obj";

	int[] regions = SearchPattern.getMatchingRegions("gen_obj",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_obj]", printRegions(name, regions));

}

public void test0068() {

	String name = "gen_exc";

	int[] regions = SearchPattern.getMatchingRegions("gen_exc",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_exc]", printRegions(name, regions));

}

public void test0069() {

	String name = "gen_wld";

	int[] regions = SearchPattern.getMatchingRegions("gen_wld",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_wld]", printRegions(name, regions));

}

public void test0070() {

	String name = "gen_thr";

	int[] regions = SearchPattern.getMatchingRegions("gen_thr",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_thr]", printRegions(name, regions));

}

public void test0071() {

	String name = "gen_run";

	int[] regions = SearchPattern.getMatchingRegions("gen_run",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[gen_run]", printRegions(name, regions));

}

public void test0072() {

	String name = "qgen_obj";

	int[] regions = SearchPattern.getMatchingRegions("?gen_*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "q[gen_]obj", printRegions(name, regions));

}

public void test0073() {

	String name = "qgen_wld";

	int[] regions = SearchPattern.getMatchingRegions("?gen_*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "q[gen_]wld", printRegions(name, regions));

}

public void test0074() {

	String name = "qgen_run";

	int[] regions = SearchPattern.getMatchingRegions("?gen_*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "q[gen_]run", printRegions(name, regions));

}

public void test0075() {

	String name = "qgen_exc";

	int[] regions = SearchPattern.getMatchingRegions("?gen_*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "q[gen_]exc", printRegions(name, regions));

}

public void test0076() {

	String name = "qgen_thr";

	int[] regions = SearchPattern.getMatchingRegions("?gen_*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "q[gen_]thr", printRegions(name, regions));

}

public void test0077() {

	String name = "qgen_run";

	int[] regions = SearchPattern.getMatchingRegions("qgen_*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[qgen_]run", printRegions(name, regions));

}

public void test0078() {

	String name = "qgen_obj";

	int[] regions = SearchPattern.getMatchingRegions("qgen_obj",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[qgen_obj]", printRegions(name, regions));

}

public void test0079() {

	String name = "qgen_exc";

	int[] regions = SearchPattern.getMatchingRegions("qgen_exc",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[qgen_exc]", printRegions(name, regions));

}

public void test0080() {

	String name = "qgen_wld";

	int[] regions = SearchPattern.getMatchingRegions("qgen_wld",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[qgen_wld]", printRegions(name, regions));

}

public void test0081() {

	String name = "qgen_thr";

	int[] regions = SearchPattern.getMatchingRegions("qgen_thr",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[qgen_thr]", printRegions(name, regions));

}

public void test0082() {

	String name = "qgen_run";

	int[] regions = SearchPattern.getMatchingRegions("qgen_run",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[qgen_run]", printRegions(name, regions));

}

public void test0083() {

	String name = "complete/4";

	int[] regions = SearchPattern.getMatchingRegions("complete/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[complete/]4", printRegions(name, regions));

}

public void test0084() {

	String name = "complete/2";

	int[] regions = SearchPattern.getMatchingRegions("complete/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[complete/]2", printRegions(name, regions));

}

public void test0085() {

	String name = "complete";

	int[] regions = SearchPattern.getMatchingRegions("complete",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[complete]", printRegions(name, regions));

}

public void test0086() {

	String name = "generic/1";

	int[] regions = SearchPattern.getMatchingRegions("*e?e*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "g[e]n[e]ric/1", printRegions(name, regions));

}

public void test0087() {

	String name = "generic/3";

	int[] regions = SearchPattern.getMatchingRegions("*e?e*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "g[e]n[e]ric/3", printRegions(name, regions));

}

public void test0088() {

	String name = "FREDERIC/0";

	int[] regions = SearchPattern.getMatchingRegions("*e?e*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "FR[E]D[E]RIC/0", printRegions(name, regions));

}

public void test0089() {

	String name = "generic";

	int[] regions = SearchPattern.getMatchingRegions("*e?e*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 4, regions.length);

	assertEquals("Unexpected matching regions", "g[e]n[e]ric", printRegions(name, regions));

}

public void test0090() {

	String name = "complete/2";

	int[] regions = SearchPattern.getMatchingRegions("complete/2",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[complete/2]", printRegions(name, regions));

}

public void test0091() {

	String name = "generic/1";

	int[] regions = SearchPattern.getMatchingRegions("generic/1",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[generic/1]", printRegions(name, regions));

}

public void test0092() {

	String name = "generic";

	int[] regions = SearchPattern.getMatchingRegions("generic",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[generic]", printRegions(name, regions));

}

public void test0093() {

	String name = "g5.m.def";

	int[] regions = SearchPattern.getMatchingRegions("g5.m.def",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[g5.m.def]", printRegions(name, regions));

}

public void test0094() {

	String name = "generic/1";

	int[] regions = SearchPattern.getMatchingRegions("generic/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[generic/]1", printRegions(name, regions));

}

public void test0095() {

	String name = "generic/3";

	int[] regions = SearchPattern.getMatchingRegions("generic/3",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[generic/3]", printRegions(name, regions));

}

public void test0096() {

	String name = "complete/4";

	int[] regions = SearchPattern.getMatchingRegions("complete/4",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[complete/4]", printRegions(name, regions));

}

public void test0097() {

	String name = "A/e8//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/e8//", printRegions(name, regions));

}

public void test0098() {

	String name = "A/p8//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/p8//", printRegions(name, regions));

}

public void test0099() {

	String name = "A/d8//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/d8//", printRegions(name, regions));

}

public void test0100() {

	String name = "A/r8//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/r8//", printRegions(name, regions));

}

public void test0101() {

	String name = "AA/d8//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]A/d8//", printRegions(name, regions));

}

public void test0102() {

	String name = "A/PackageReference//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/PackageReference//", printRegions(name, regions));

}

public void test0103() {

	String name = "A/a8//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/a8//", printRegions(name, regions));

}

public void test0104() {

	String name = "Azz/MemberTypeReference//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]zz/MemberTypeReference//", printRegions(name, regions));

}

public void test0105() {

	String name = "A/ObjectMemberTypeReference//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/ObjectMemberTypeReference//", printRegions(name, regions));

}

public void test0106() {

	String name = "A/a9//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/a9//", printRegions(name, regions));

}

public void test0107() {

	String name = "A/r9//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/r9//", printRegions(name, regions));

}

public void test0108() {

	String name = "A/e9//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/e9//", printRegions(name, regions));

}

public void test0109() {

	String name = "AA/q1///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]A/q1///S", printRegions(name, regions));

}

public void test0110() {

	String name = "A///";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]///", printRegions(name, regions));

}

public void test0111() {

	String name = "A/p//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/p//", printRegions(name, regions));

}

public void test0112() {

	String name = "A/a//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/a//", printRegions(name, regions));

}

public void test0113() {

	String name = "AzzMember/MemberTypeReference/Azz/";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]zzMember/MemberTypeReference/Azz/", printRegions(name, regions));

}

public void test0114() {

	String name = "A/VariousTypeReferences//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/VariousTypeReferences//", printRegions(name, regions));

}

public void test0115() {

	String name = "AncestorEnumeration/p10.a.b.om/X/";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]ncestorEnumeration/p10.a.b.om/X/", printRegions(name, regions));

}

public void test0116() {

	String name = "AQE/q6///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]QE/q6///S", printRegions(name, regions));

}

public void test0117() {

	String name = "A/r//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/r//", printRegions(name, regions));

}

public void test0118() {

	String name = "A1/c11///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]1/c11///S", printRegions(name, regions));

}

public void test0119() {

	String name = "A2/c11///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]2/c11///S", printRegions(name, regions));

}

public void test0120() {

	String name = "A3/c11///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]3/c11///S", printRegions(name, regions));

}

public void test0121() {

	String name = "A/a5///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/a5///S", printRegions(name, regions));

}

public void test0122() {

	String name = "AA////S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]A////S", printRegions(name, regions));

}

public void test0123() {

	String name = "A21485/r3//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]21485/r3//", printRegions(name, regions));

}

public void test0124() {

	String name = "AA/p6///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]A/p6///S", printRegions(name, regions));

}

public void test0125() {

	String name = "AQ/q6///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]Q/q6///S", printRegions(name, regions));

}

public void test0126() {

	String name = "A/c1//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/c1//", printRegions(name, regions));

}

public void test0127() {

	String name = "A/b1//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/b1//", printRegions(name, regions));

}

public void test0128() {

	String name = "A/p7/0/";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/p7/0/", printRegions(name, regions));

}

public void test0129() {

	String name = "A/q2//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/q2//", printRegions(name, regions));

}

public void test0130() {

	String name = "A/c2//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/c2//", printRegions(name, regions));

}

public void test0131() {

	String name = "A/c11//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/c11//", printRegions(name, regions));

}

public void test0132() {

	String name = "A1/q9///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]1/q9///S", printRegions(name, regions));

}

public void test0133() {

	String name = "A/d3//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/d3//", printRegions(name, regions));

}

public void test0134() {

	String name = "A/s3//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/s3//", printRegions(name, regions));

}

public void test0135() {

	String name = "A/TypeReferenceInArray//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/TypeReferenceInArray//", printRegions(name, regions));

}

public void test0136() {

	String name = "A/e4//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/e4//", printRegions(name, regions));

}

public void test0137() {

	String name = "A/p4//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/p4//", printRegions(name, regions));

}

public void test0138() {

	String name = "A/b4//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/b4//", printRegions(name, regions));

}

public void test0139() {

	String name = "AbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyz/c9///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]bcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyz/c9///S", printRegions(name, regions));

}

public void test0140() {

	String name = "A29366/e1//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]29366/e1//", printRegions(name, regions));

}

public void test0141() {

	String name = "A/s5//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/s5//", printRegions(name, regions));

}

public void test0142() {

	String name = "A/b5//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/b5//", printRegions(name, regions));

}

public void test0143() {

	String name = "A/p5//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/p5//", printRegions(name, regions));

}

public void test0144() {

	String name = "A/d9.p1//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/d9.p1//", printRegions(name, regions));

}

public void test0145() {

	String name = "A1/e5//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]1/e5//", printRegions(name, regions));

}

public void test0146() {

	String name = "A$B/q3//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]$B/q3//", printRegions(name, regions));

}

public void test0147() {

	String name = "A/a3.b//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/a3.b//", printRegions(name, regions));

}

public void test0148() {

	String name = "A/b6//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/b6//", printRegions(name, regions));

}

public void test0149() {

	String name = "A/p6//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/p6//", printRegions(name, regions));

}

public void test0150() {

	String name = "A/a6//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/a6//", printRegions(name, regions));

}

public void test0151() {

	String name = "A/r6//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/r6//", printRegions(name, regions));

}

public void test0152() {

	String name = "A/e6//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/e6//", printRegions(name, regions));

}

public void test0153() {

	String name = "AxisFilter/net.sf.saxon.om/Navigator/	";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]xisFilter/net.sf.saxon.om/Navigator/	", printRegions(name, regions));

}

public void test0154() {

	String name = "AQ/sd//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]Q/sd//", printRegions(name, regions));

}

public void test0155() {

	String name = "AQE/sd///S";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]QE/sd///S", printRegions(name, regions));

}

public void test0156() {

	String name = "A/e7//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/e7//", printRegions(name, regions));

}

public void test0157() {

	String name = "A/r7//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/r7//", printRegions(name, regions));

}

public void test0158() {

	String name = "A/d7//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/d7//", printRegions(name, regions));

}

public void test0159() {

	String name = "A/p7//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/p7//", printRegions(name, regions));

}

public void test0160() {

	String name = "A/NoReference//";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]/NoReference//", printRegions(name, regions));

}

public void test0161() {

	String name = "A";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]", printRegions(name, regions));

}

public void test0162() {

	String name = "Azz";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]zz", printRegions(name, regions));

}

public void test0163() {

	String name = "AxisFilter";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]xisFilter", printRegions(name, regions));

}

public void test0164() {

	String name = "AQE";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]QE", printRegions(name, regions));

}

public void test0165() {

	String name = "AA";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]A", printRegions(name, regions));

}

public void test0166() {

	String name = "A$B";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]$B", printRegions(name, regions));

}

public void test0167() {

	String name = "A1";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]1", printRegions(name, regions));

}

public void test0168() {

	String name = "A21485";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]21485", printRegions(name, regions));

}

public void test0169() {

	String name = "AbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyz";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]bcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyz", printRegions(name, regions));

}

public void test0170() {

	String name = "AzzMember";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]zzMember", printRegions(name, regions));

}

public void test0171() {

	String name = "AQ";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]Q", printRegions(name, regions));

}

public void test0172() {

	String name = "AncestorEnumeration";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]ncestorEnumeration", printRegions(name, regions));

}

public void test0173() {

	String name = "A3";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]3", printRegions(name, regions));

}

public void test0174() {

	String name = "A2";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]2", printRegions(name, regions));

}

public void test0175() {

	String name = "A29366";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]29366", printRegions(name, regions));

}

public void test0176() {

	String name = "AAABBB";

	int[] regions = SearchPattern.getMatchingRegions("a*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[A]AABBB", printRegions(name, regions));

}

public void test0177() {

	String name = "Link";

	int[] regions = SearchPattern.getMatchingRegions("link",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[Link]", printRegions(name, regions));

}

public void test0178() {

	String name = "java.lang";

	int[] regions = SearchPattern.getMatchingRegions("*.lang",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "java[.lang]", printRegions(name, regions));

}

public void test0179() {

	String name = "Collection/java.util//?";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Collec[tion/]java.util//?", printRegions(name, regions));

}

public void test0180() {

	String name = "RetentionPolicy/java.lang.annotation//?";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "RetentionPolicy/java.lang.annota[tion/]/?", printRegions(name, regions));

}

public void test0181() {

	String name = "InterruptedException/java.lang//!";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "InterruptedExcep[tion/]java.lang//!", printRegions(name, regions));

}

public void test0182() {

	String name = "IllegalMonitorStateException/java.lang//!";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "IllegalMonitorStateExcep[tion/]java.lang//!", printRegions(name, regions));

}

public void test0183() {

	String name = "Inherited/java.lang.annotation//?";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Inherited/java.lang.annota[tion/]/?", printRegions(name, regions));

}

public void test0184() {

	String name = "ElementType/java.lang.annotation//?";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "ElementType/java.lang.annota[tion/]/?", printRegions(name, regions));

}

public void test0185() {

	String name = "Documented/java.lang.annotation//?";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Documented/java.lang.annota[tion/]/?", printRegions(name, regions));

}

public void test0186() {

	String name = "CloneNotSupportedException/java.lang//!";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "CloneNotSupportedExcep[tion/]java.lang//!", printRegions(name, regions));

}

public void test0187() {

	String name = "Exception/java.lang//!";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Excep[tion/]java.lang//!", printRegions(name, regions));

}

public void test0188() {

	String name = "Annotation/java.lang.annotation//?";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Annota[tion/]java.lang.annotation//?", printRegions(name, regions));

}

public void test0189() {

	String name = "Target/java.lang.annotation//?";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Target/java.lang.annota[tion/]/?", printRegions(name, regions));

}

public void test0190() {

	String name = "Retention/java.lang.annotation//?";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Reten[tion/]java.lang.annotation//?", printRegions(name, regions));

}

public void test0191() {

	String name = "Annotation";

	int[] regions = SearchPattern.getMatchingRegions("*tion",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Annota[tion]", printRegions(name, regions));

}

public void test0192() {

	String name = "java.lang.annotation";

	int[] regions = SearchPattern.getMatchingRegions("*.lang*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "java[.lang].annotation", printRegions(name, regions));

}

public void test0193() {

	String name = "CloneNotSupportedException";

	int[] regions = SearchPattern.getMatchingRegions("*tion",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "CloneNotSupportedExcep[tion]", printRegions(name, regions));

}

public void test0194() {

	String name = "InterruptedException";

	int[] regions = SearchPattern.getMatchingRegions("*tion",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "InterruptedExcep[tion]", printRegions(name, regions));

}

public void test0195() {

	String name = "IllegalMonitorStateException";

	int[] regions = SearchPattern.getMatchingRegions("*tion",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "IllegalMonitorStateExcep[tion]", printRegions(name, regions));

}

public void test0196() {

	String name = "Exception";

	int[] regions = SearchPattern.getMatchingRegions("*tion",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Excep[tion]", printRegions(name, regions));

}

public void test0197() {

	String name = "Collection";

	int[] regions = SearchPattern.getMatchingRegions("*tion",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Collec[tion]", printRegions(name, regions));

}

public void test0198() {

	String name = "Retention";

	int[] regions = SearchPattern.getMatchingRegions("*tion",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Reten[tion]", printRegions(name, regions));

}

public void test0199() {

	String name = "Collection/b87627//?";

	int[] regions = SearchPattern.getMatchingRegions("*tion/*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "Collec[tion/]b87627//?", printRegions(name, regions));

}

public void test0200() {

	String name = "test.Test$StaticClass";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "test[.Test]$StaticClass", printRegions(name, regions));

}

public void test0201() {

	String name = "test.Test";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "test[.Test]", printRegions(name, regions));

}

public void test0202() {

	String name = ".Test";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[.Test]", printRegions(name, regions));

}

public void test0203() {

	String name = "b124645.test.0";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "b124645[.test].0", printRegions(name, regions));

}

public void test0204() {

	String name = "b95794.Test";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "b95794[.Test]", printRegions(name, regions));

}

public void test0205() {

	String name = "b123679.test.0";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "b123679[.test].0", printRegions(name, regions));

}

public void test0206() {

	String name = "b124645.test";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "b124645[.test]", printRegions(name, regions));

}

public void test0207() {

	String name = "b123679.test.Test";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "b123679[.test].Test", printRegions(name, regions));

}

public void test0208() {

	String name = "b123679.test.Test.StaticClass";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "b123679[.test].Test.StaticClass", printRegions(name, regions));

}

public void test0209() {

	String name = "b127628.Test127628";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "b127628[.Test]127628", printRegions(name, regions));

}

public void test0210() {

	String name = "b123679.test";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "b123679[.test]", printRegions(name, regions));

}

public void test0211() {

	String name = "pack.age.Test";

	int[] regions = SearchPattern.getMatchingRegions("*.test*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "pack.age[.Test]", printRegions(name, regions));

}

public void test0212() {

	String name = "b124645.test";

	int[] regions = SearchPattern.getMatchingRegions("b12*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[b12]4645.test", printRegions(name, regions));

}

public void test0213() {

	String name = "b124645.xy";

	int[] regions = SearchPattern.getMatchingRegions("b12*",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[b12]4645.xy", printRegions(name, regions));

}

public void test0214() {

	String name = "b97087.Bug";

	int[] regions = SearchPattern.getMatchingRegions("b97087.bug",  name, SearchPattern.R_PATTERN_MATCH);

	assertEquals("Unexpected regions length", 2, regions.length);

	assertEquals("Unexpected matching regions", "[b97087.Bug]", printRegions(name, regions));

}

public void test0215() {

	String name = "E/pack//?";

	int[] regions = SearchPattern.getMatchingRegions("e*",  name, SearchPattern.R_PATTERN_MATCH);