org.eclipse.jdt.text.tests/src/org/eclipse/jdt/text/tests/JavaParameterListValidatorTest.java - jdt/eclipse.jdt.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2006 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.text.tests;


 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;

 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;

 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.StyleRange;

 import org.eclipse.jface.text.Document;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.TextPresentation;
 import org.eclipse.jface.text.contentassist.ContextInformation;
 import org.eclipse.jface.text.contentassist.IContextInformation;
 import org.eclipse.jface.text.tests.TestTextViewer;

 import org.eclipse.jdt.internal.ui.text.java.JavaParameterListValidator;


 public class JavaParameterListValidatorTest extends TestCase {

 	protected TestTextViewer fTextViewer;
 	protected IDocument fDocument;
 	protected JavaParameterListValidator fValidator;

 	public JavaParameterListValidatorTest(String name) {
 		super(name);
 	}

 	protected void setUp() {
 		fTextViewer= new TestTextViewer();
 		fDocument= new Document();
 		fValidator= new JavaParameterListValidator();
 	}

 	public static Test suite() {
 		return new TestSuite(JavaParameterListValidatorTest.class);
 	}

 	protected void tearDown () {
 		fTextViewer= null;
 		fDocument= null;
 		fValidator= null;
 	}

 	public void testParameterStyling() {
 		final String code= "a, b, c, d, e";
 		assertParameterInfoStyles(code, "int a, int b, int c, int d, int e", computeCommaPositions(code));
     }

 	public void testParameterStylingWithString() {
 		final String code= "a, b, \"foo, bar, and such\", d, e";
 		assertParameterInfoStyles(code, "int a, int b, String c, int d, int e", computeCommaPositions(code));
 	}

 	public void testParameterStylingWithEscapedString() {
 		final String code= "a, b, \"foo, b\\\"ar, and such\\\\\", d, e";
 		assertParameterInfoStyles(code, "int a, int b, String c, int d, int e", computeCommaPositions(code));
 	}

 	public void testParameterStylingWithComment() {
 		final String code= "a, b, c /* the ( argument */, d, e";
 		assertParameterInfoStyles(code, "int a, int b, String c, int d, int e", computeCommaPositions(code));
 	}

 	public void testParameterStylingWithGenerics() {
 		final String code= "new HashMap <String, HashMap<String,Integer[]>>(), p1, p2";
 		assertParameterInfoStyles(code, "Map<String, Map> m, int p1, int p2", computeCommaPositions(code));
 	}

 	public void testParameterStylingWithGenericsAndComments() {
 		final String code= "new HashMap <String, /* comment > */HashMap<String,Integer[]>>(), p1, p2";
 		assertParameterInfoStyles(code, "Map<String, Map> m, int p1, int p2", new int[] {64, 68});
 	}

 	public void testParameterStylingWithConstants() {
 		final String code= "MAX < MIN, MAX > MIN";
 		assertParameterInfoStyles(code, "boolean b1, boolean b2", new int[] {9});
 	}

 	public void testParameterStylingWithGenericsThatLookLikeConstants() {
 		final String code= "new MAX < MIN, MAX >";
 		assertParameterInfoStyles(code, "MAX<?,?>", new int[0]);
 	}

 	private void assertParameterInfoStyles(String code, String infostring, int[] argumentCommas) {
 		fDocument.set(code);
 		fTextViewer.setDocument(fDocument);

 		int[] parameterCommas= computeCommaPositions(infostring);
 		IContextInformation info= new ContextInformation("context", infostring);
 		fValidator.install(info, fTextViewer, 0);

 		TextPresentation p= new TextPresentation();
 		for (int i= 0; i < fDocument.getLength(); i++) {
 			fValidator.updatePresentation(i, p);
 			assertEquals(createPresentation(i, parameterCommas, argumentCommas, infostring), p);
 		}
     }

 	private int[] computeCommaPositions(String code) {
 	    int pos= 0;
 		List positions= new ArrayList();
 		while (pos < code.length() && pos != -1) {
 			char ch= code.charAt(pos);
 			switch (ch) {
 	            case ',':
 		            positions.add(new Integer(pos));
 		            break;
 	            case '<':
 	            	pos= code.indexOf('>', pos);
 	            	break;
 	            case '(':
 	            	pos= code.indexOf(')', pos);
 	            	break;
 	            case '[':
 	            	pos= code.indexOf(']', pos);
 	            	break;
 	            case '{':
 	            	pos= code.indexOf('}', pos);
 	            	break;
 	            case '"':
 	            	pos= findLiteralEnd(code, pos + 1, '"');
 	            	break;
 	            case '/':
 	            	if (pos < code.length() - 1 && code.charAt(pos + 1) == '*')
 	            		pos= findCommentEnd(code, pos + 2);
 	            	break;
 	            case '\'':
 	            	pos= findLiteralEnd(code, pos + 1, '\'');
 	            	break;
 	            default:
 	            	break;
             }
 			if (pos != -1)
 				pos++;
 		}

 		int[] fields= new int[positions.size()];
 		for (int i= 0; i < fields.length; i++)
 	        fields[i]= ((Integer) positions.get(i)).intValue();
 	    return fields;
     }

     private int findCommentEnd(String code, int pos) {
     	while (pos < code.length()) {
     		pos= code.indexOf('*', pos);
     		if (pos == -1 || pos == code.length() - 1)
     			break;
     		if (code.charAt(pos + 1) == '/')
     			return pos;
     		pos++;
     	}
 	    return -1;
     }

 	private int findLiteralEnd(String code, int pos, char peer) {
     	while (pos < code.length()) {
     		char ch= code.charAt(pos);
     		if (ch == peer)
     			return pos;
     		if (ch == '\\')
     			pos += 2;
     		else
     			pos++;
     	}
 	    return -1;
     }

 	private TextPresentation createPresentation(int position, int[] parameterCommas, int[] argumentCommas, String contextInfo) {
 		int length= contextInfo.length();
 		TextPresentation p= new TextPresentation();


 		int boldStart= 0;
 		int boldEnd= length;

 		for (int i= 0; i < argumentCommas.length; i++) {
 	        int argumentComma= argumentCommas[i];
 	        int parameterComma= parameterCommas[i];

 	        if (argumentComma < position)
 	        	boldStart= parameterComma + 1;
 	        if (argumentComma >= position) {
 	        	boldEnd= parameterComma;
 	        	break;
 	        }
         }

 		if (boldStart > 0)
 			p.addStyleRange(new StyleRange(0, boldStart, null, null, SWT.NORMAL));

 		p.addStyleRange(new StyleRange(boldStart, boldEnd - boldStart, null, null, SWT.BOLD));

 		if (boldEnd < length)
 			p.addStyleRange(new StyleRange(boldEnd, length - boldEnd, null, null, SWT.NORMAL));

 		// TODO handle no range at all

 		return p;
 	}

 	private static void assertEquals(TextPresentation expected, TextPresentation actual) {
 		// check lengths
 		assertTrue(expected.getDenumerableRanges() == actual.getDenumerableRanges());
 		// check default range
 		assertEquals(expected.getDefaultStyleRange(), actual.getDefaultStyleRange());
 		// check rest
 		Iterator e1= expected.getAllStyleRangeIterator();
 		Iterator e2= actual.getAllStyleRangeIterator();
 		while (e1.hasNext())
 			assertEquals(e1.next(), e2.next());
 	}

 	protected String print(TextPresentation presentation) {
 		StringBuffer buf= new StringBuffer();
 		if (presentation != null) {
 			// default range
 			buf.append("Default style range: ");
 			StyleRange range= presentation.getDefaultStyleRange();
 			if (range != null)
 				buf.append(range.toString());
 			buf.append('\n');
 			// rest
 			Iterator e= presentation.getAllStyleRangeIterator();
 			while (e.hasNext()) {
 				buf.append(e.next().toString());
 				buf.append('\n');
 			}
 		}
 		return buf.toString();
 	}
 	public void testValidPositions() {
 		assertValidPositions("(a, b, c)");
 	}

 	public void testValidPositionsWithComment() {
 		assertValidPositions("(a, b /* the ( argument */, c)");
 	}

 	public void testValidPositionsWithString() {
 		assertValidPositions("(a, \"foo, bar, and such\", c)");
 	}

 	public void testValidGenericPositions() throws Exception {
 	    assertValidPositions("(new A<T>(), new B<T>())");
     }

 	public void testValidAllPositions() throws Exception {
 		assertValidPositions("(new HashMap<String, HashMap<String,Integer[]>>(), p1, p2)");
 	}

 	public void testValidArrayPositions() throws Exception {
 		assertValidPositions("(foo[], bar[13])");
 	}

 	/**
 	 * Asserts that the context information is invalid both at both borders of the passed string,
 	 * but valid at each position within the string.
 	 *
 	 * @param code the code to test, typically a parenthesized expression such as
 	 *        <code>(a, b, c)</code>
 	 */
 	private void assertValidPositions(final String code) {
 	    fDocument.set(code + " ");
 		fTextViewer.setDocument(fDocument);

 		IContextInformation info= new ContextInformation("context", "info");
 		fValidator.install(info, fTextViewer, 1);

 		assertTrue(!fValidator.isContextInformationValid(0));
 		final int length= code.length();
 		final int firstInnerPosition= 1;
 		final int lastInnerPosition= length - 1;

 		// forward
 		for (int pos= firstInnerPosition; pos <= lastInnerPosition; pos++)
 			assertTrue(fValidator.isContextInformationValid(pos));
 		assertTrue(!fValidator.isContextInformationValid(length));

 		// backward
 		for (int pos= lastInnerPosition; pos >= firstInnerPosition; pos--)
 			assertTrue(fValidator.isContextInformationValid(pos));
 		assertTrue(!fValidator.isContextInformationValid(0));
     }
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2006 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.text.tests;


	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;

	import junit.framework.Test;
	import junit.framework.TestCase;
	import junit.framework.TestSuite;

	import org.eclipse.swt.SWT;
	import org.eclipse.swt.custom.StyleRange;

	import org.eclipse.jface.text.Document;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.TextPresentation;
	import org.eclipse.jface.text.contentassist.ContextInformation;
	import org.eclipse.jface.text.contentassist.IContextInformation;
	import org.eclipse.jface.text.tests.TestTextViewer;

	import org.eclipse.jdt.internal.ui.text.java.JavaParameterListValidator;


	public class JavaParameterListValidatorTest extends TestCase {

	protected TestTextViewer fTextViewer;
	protected IDocument fDocument;
	protected JavaParameterListValidator fValidator;

	public JavaParameterListValidatorTest(String name) {
	super(name);
	}

	protected void setUp() {
	fTextViewer= new TestTextViewer();
	fDocument= new Document();
	fValidator= new JavaParameterListValidator();
	}

	public static Test suite() {
	return new TestSuite(JavaParameterListValidatorTest.class);
	}

	protected void tearDown () {
	fTextViewer= null;
	fDocument= null;
	fValidator= null;
	}

	public void testParameterStyling() {
	final String code= "a, b, c, d, e";
	assertParameterInfoStyles(code, "int a, int b, int c, int d, int e", computeCommaPositions(code));
	}

	public void testParameterStylingWithString() {
	final String code= "a, b, \"foo, bar, and such\", d, e";
	assertParameterInfoStyles(code, "int a, int b, String c, int d, int e", computeCommaPositions(code));
	}

	public void testParameterStylingWithEscapedString() {
	final String code= "a, b, \"foo, b\\\"ar, and such\\\\\", d, e";
	assertParameterInfoStyles(code, "int a, int b, String c, int d, int e", computeCommaPositions(code));
	}

	public void testParameterStylingWithComment() {
	final String code= "a, b, c /* the ( argument */, d, e";
	assertParameterInfoStyles(code, "int a, int b, String c, int d, int e", computeCommaPositions(code));
	}

	public void testParameterStylingWithGenerics() {
	final String code= "new HashMap <String, HashMap<String,Integer[]>>(), p1, p2";
	assertParameterInfoStyles(code, "Map<String, Map> m, int p1, int p2", computeCommaPositions(code));
	}

	public void testParameterStylingWithGenericsAndComments() {
	final String code= "new HashMap <String, /* comment > */HashMap<String,Integer[]>>(), p1, p2";
	assertParameterInfoStyles(code, "Map<String, Map> m, int p1, int p2", new int[] {64, 68});
	}

	public void testParameterStylingWithConstants() {
	final String code= "MAX < MIN, MAX > MIN";
	assertParameterInfoStyles(code, "boolean b1, boolean b2", new int[] {9});
	}

	public void testParameterStylingWithGenericsThatLookLikeConstants() {
	final String code= "new MAX < MIN, MAX >";
	assertParameterInfoStyles(code, "MAX<?,?>", new int[0]);
	}

	private void assertParameterInfoStyles(String code, String infostring, int[] argumentCommas) {
	fDocument.set(code);
	fTextViewer.setDocument(fDocument);

	int[] parameterCommas= computeCommaPositions(infostring);
	IContextInformation info= new ContextInformation("context", infostring);
	fValidator.install(info, fTextViewer, 0);

	TextPresentation p= new TextPresentation();
	for (int i= 0; i < fDocument.getLength(); i++) {
	fValidator.updatePresentation(i, p);
	assertEquals(createPresentation(i, parameterCommas, argumentCommas, infostring), p);
	}
	}

	private int[] computeCommaPositions(String code) {
	int pos= 0;
	List positions= new ArrayList();
	while (pos < code.length() && pos != -1) {
	char ch= code.charAt(pos);
	switch (ch) {
	case ',':
	positions.add(new Integer(pos));
	break;
	case '<':
	pos= code.indexOf('>', pos);
	break;
	case '(':
	pos= code.indexOf(')', pos);
	break;
	case '[':
	pos= code.indexOf(']', pos);
	break;
	case '{':
	pos= code.indexOf('}', pos);
	break;
	case '"':
	pos= findLiteralEnd(code, pos + 1, '"');
	break;
	case '/':
	if (pos < code.length() - 1 && code.charAt(pos + 1) == '*')
	pos= findCommentEnd(code, pos + 2);
	break;
	case '\'':
	pos= findLiteralEnd(code, pos + 1, '\'');
	break;
	default:
	break;
	}
	if (pos != -1)
	pos++;
	}

	int[] fields= new int[positions.size()];
	for (int i= 0; i < fields.length; i++)
	fields[i]= ((Integer) positions.get(i)).intValue();
	return fields;
	}

	private int findCommentEnd(String code, int pos) {
	while (pos < code.length()) {
	pos= code.indexOf('*', pos);
	if (pos == -1 \|\| pos == code.length() - 1)
	break;
	if (code.charAt(pos + 1) == '/')
	return pos;
	pos++;
	}
	return -1;
	}

	private int findLiteralEnd(String code, int pos, char peer) {
	while (pos < code.length()) {
	char ch= code.charAt(pos);
	if (ch == peer)
	return pos;
	if (ch == '\\')
	pos += 2;
	else
	pos++;
	}
	return -1;
	}

	private TextPresentation createPresentation(int position, int[] parameterCommas, int[] argumentCommas, String contextInfo) {
	int length= contextInfo.length();
	TextPresentation p= new TextPresentation();


	int boldStart= 0;
	int boldEnd= length;

	for (int i= 0; i < argumentCommas.length; i++) {
	int argumentComma= argumentCommas[i];
	int parameterComma= parameterCommas[i];

	if (argumentComma < position)
	boldStart= parameterComma + 1;
	if (argumentComma >= position) {
	boldEnd= parameterComma;
	break;
	}
	}

	if (boldStart > 0)
	p.addStyleRange(new StyleRange(0, boldStart, null, null, SWT.NORMAL));

	p.addStyleRange(new StyleRange(boldStart, boldEnd - boldStart, null, null, SWT.BOLD));

	if (boldEnd < length)
	p.addStyleRange(new StyleRange(boldEnd, length - boldEnd, null, null, SWT.NORMAL));

	// TODO handle no range at all

	return p;
	}

	private static void assertEquals(TextPresentation expected, TextPresentation actual) {
	// check lengths
	assertTrue(expected.getDenumerableRanges() == actual.getDenumerableRanges());
	// check default range
	assertEquals(expected.getDefaultStyleRange(), actual.getDefaultStyleRange());
	// check rest
	Iterator e1= expected.getAllStyleRangeIterator();
	Iterator e2= actual.getAllStyleRangeIterator();
	while (e1.hasNext())
	assertEquals(e1.next(), e2.next());
	}

	protected String print(TextPresentation presentation) {
	StringBuffer buf= new StringBuffer();
	if (presentation != null) {
	// default range
	buf.append("Default style range: ");
	StyleRange range= presentation.getDefaultStyleRange();
	if (range != null)
	buf.append(range.toString());
	buf.append('\n');
	// rest
	Iterator e= presentation.getAllStyleRangeIterator();
	while (e.hasNext()) {
	buf.append(e.next().toString());
	buf.append('\n');
	}
	}
	return buf.toString();
	}
	public void testValidPositions() {
	assertValidPositions("(a, b, c)");
	}

	public void testValidPositionsWithComment() {
	assertValidPositions("(a, b /* the ( argument */, c)");
	}

	public void testValidPositionsWithString() {
	assertValidPositions("(a, \"foo, bar, and such\", c)");
	}

	public void testValidGenericPositions() throws Exception {
	assertValidPositions("(new A<T>(), new B<T>())");
	}

	public void testValidAllPositions() throws Exception {
	assertValidPositions("(new HashMap<String, HashMap<String,Integer[]>>(), p1, p2)");
	}

	public void testValidArrayPositions() throws Exception {
	assertValidPositions("(foo[], bar[13])");
	}

	/**
	* Asserts that the context information is invalid both at both borders of the passed string,
	* but valid at each position within the string.
	*
	* @param code the code to test, typically a parenthesized expression such as
	* <code>(a, b, c)</code>
	*/
	private void assertValidPositions(final String code) {
	fDocument.set(code + " ");
	fTextViewer.setDocument(fDocument);

	IContextInformation info= new ContextInformation("context", "info");
	fValidator.install(info, fTextViewer, 1);

	assertTrue(!fValidator.isContextInformationValid(0));
	final int length= code.length();
	final int firstInnerPosition= 1;
	final int lastInnerPosition= length - 1;

	// forward
	for (int pos= firstInnerPosition; pos <= lastInnerPosition; pos++)
	assertTrue(fValidator.isContextInformationValid(pos));
	assertTrue(!fValidator.isContextInformationValid(length));

	// backward
	for (int pos= lastInnerPosition; pos >= firstInnerPosition; pos--)
	assertTrue(fValidator.isContextInformationValid(pos));
	assertTrue(!fValidator.isContextInformationValid(0));
	}
	}