org.eclipse.photran.core.vpg.tests/src/org/eclipse/photran/internal/tests/refactoring/rename/RenameTestCase.java - ptp/org.eclipse.photran - Git at Google

 /*******************************************************************************
  * Copyright (c) 2008 University of Illinois at Urbana-Champaign 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:
  *     UIUC - Initial API and implementation
  *******************************************************************************/
 package org.eclipse.photran.internal.tests.refactoring.rename;

 import java.io.IOException;
 import java.net.URISyntaxException;
 import java.util.Set;

 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.jface.text.TextSelection;
 import org.eclipse.ltk.core.refactoring.Change;
 import org.eclipse.ltk.core.refactoring.RefactoringStatus;
 import org.eclipse.photran.internal.core.refactoring.RenameRefactoring;
 import org.eclipse.photran.internal.core.refactoring.interfaces.IRenameRefactoring;
 import org.eclipse.photran.internal.core.util.LineCol;
 import org.eclipse.photran.internal.core.vpg.PhotranVPG;
 import org.eclipse.photran.internal.tests.Activator;
 import org.eclipse.photran.internal.tests.PhotranWorkspaceTestCase;
 import org.eclipse.photran.internal.tests.refactoring.rename.RenameTestSuite.Ident;

 public abstract class RenameTestCase extends PhotranWorkspaceTestCase
 {
     private static final String DIR = "refactoring-test-code/rename";

     private static NullProgressMonitor pm = new NullProgressMonitor();

     protected String filename;
     protected Ident variable;
     protected LineCol position;
     protected String newName;

     public RenameTestCase() {;}  // when JUnit invokes a subclass outside a test suite

     public RenameTestCase(String filename, Ident variable, LineCol position, String newName)
     {
         this.filename = filename;
         this.variable = variable;
         this.newName = newName;
         this.position = position;
         this.setName("test");
     }

 //    public void testLevenshtein()
 //    {
 //        assertEquals(0, levenshteinDistance("", ""));
 //        assertEquals(0, levenshteinDistance("kitten", "kitten"));
 //        assertEquals(6, levenshteinDistance("", "kitten"));
 //        assertEquals(6, levenshteinDistance("kitten", ""));
 //        assertEquals(3, levenshteinDistance("kitten", "sitting"));
 //        assertEquals(3, levenshteinDistance("kitten", "kit"));
 //        assertEquals(1, levenshteinDistance("kitten", "kittten"));
 //        assertEquals(2, levenshteinDistance("kitten", "kien"));
 //    }

     /**
      * Computes the Levenshtein distance between two strings.
      *
      * @return the Levenshtein distance between <code>s</code> and <code>t</code>
      */
     /*
      * This is a well-known algorithm; see, for example,
      * http://en.wikipedia.org/wiki/Levenshtein_distance
      */
     protected int levenshteinDistance(String s, String t)
     {
         int m = s.length(), n = t.length();

         int[][] d = new int[m+1][n+1];

         for (int i = 1; i <= m; i++)
             d[i][0] = i;
         for (int j = 1; j <= n; j++)
             d[0][j] = j;

         for (int i = 1; i <= m; i++)
         {
             for (int j = 1; j <= n; j++)
             {
                 int cost = s.charAt(i-1) == t.charAt(j-1) ? 0 : 1;
                 d[i][j] = min(d[i-1][j] + 1,       // deletion
                               d[i][j-1] + 1,       // insertion
                               d[i-1][j-1] + cost); // substitution
             }
         }

         return d[m][n];
     }

     private int min(int a, int b, int c)
     {
         return Math.min(Math.min(a, b), c);
     }

     protected void assertLevDist(String errorMessage, int expected, String s, String t)
     {
         int actual = levenshteinDistance(s, t);

         if (actual != expected)
         {
             // Use assertEquals so that JUnit will pop up a comparison viewer
             assertEquals("Unexpected Levenshtein distance " + actual + " (expected " + expected + ") " + errorMessage,
                          s,
                          t);
         }
     }

     /**
      * Renames the identifier at the given position in the given workspace file to the given new name.  Files in the workspace
      * are updated accordingly.
      */
     protected void doRename(String filename, LineCol lineCol, String newName, Set<String> allFiles) throws Exception
     {
         String description = "Attempt to rename identifier at " + lineCol;

         IRenameRefactoring refactoring = createRefactoring(filename, lineCol, allFiles);

         RefactoringStatus status = refactoring.checkInitialConditions(pm);
         assertTrue(description + " failed initial precondition check: " + status.toString(), !status.hasError());

         refactoring.setNewNameForIdentifier(newName);

         status = refactoring.checkFinalConditions(pm);
         assertTrue(description + " failed final precondition check: " + status.toString(), !status.hasError());

         Change change = refactoring.createChange(pm);
         assertNotNull(description + " returned null Change object", change);
         assertTrue(description + " returned invalid Change object", change.isValid(pm).isOK());
         change.perform(pm);

         project.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
     }

     /**
      * Attempts to renames the identifier at the given position in the given workspace file to the given new name, with
      * the expectation that at least one precondition will fail.  Returns the first failing status.  Does not actually
      * perform the refactoring.
      */
     protected RefactoringStatus attemptRename(String filename, LineCol lineCol, String newName, Set<String> allFiles) throws Exception
     {
         IRenameRefactoring refactoring = createRefactoring(filename, lineCol, allFiles);

         RefactoringStatus status = refactoring.checkInitialConditions(pm);
         if (status.hasError()) return status;

         refactoring.setNewNameForIdentifier(newName);

         status = refactoring.checkFinalConditions(pm);
         return status;
     }

     private IRenameRefactoring createRefactoring(final String filename, final LineCol lineCol, final Set<String> allFiles) throws Exception
     {
     	PhotranVPG.getInstance().clearDatabase();

         final IFile thisFile = importFile(Activator.getDefault(), DIR, filename);
         for (String f : allFiles)
             importFile(Activator.getDefault(), DIR, f);

         // Originally, we called acquireTransientAST on each IFile
         PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
         //project.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor()); // Runs in separate thread... grrr...

 //        System.out.println(filename);
 //        for (String f : allFiles)
 //            System.out.println(f);
 //        PhotranVPG.getInstance().db.printOn(System.out);

         IRenameRefactoring r = createRefactoring();
         r.initialize(thisFile, new TextSelection(getLineColOffset(filename, lineCol), 0));
         return r;
     }

     protected abstract IRenameRefactoring createRefactoring();

     protected String readTestFile(String filename) throws IOException, URISyntaxException
     {
         return super.readTestFile(Activator.getDefault(), DIR, filename);
     }

     public static class ExpectSuccess extends RenameTestCase
     {
         public ExpectSuccess() {;}  // when JUnit invokes this outside a test suite

         public ExpectSuccess(String filename, Ident variable, LineCol position, String newName)
         {
             super(filename, variable, position, newName);
         }

         /**
          * Given an array with all of the positions of identifiers that should be renamed together, try applying the Rename refactoring to
          * each, and make sure all the others change with it.
          */
         public void test() throws Exception
         {
             if (filename == null || variable == null || newName == null) return; // when JUnit invokes this outside a test suite
             //System.out.println("***** " + variable.getName() + " ==> " + newName + " *****");

             doRename(filename, position, newName, variable.getFiles());
             for (String filename : variable.getFiles())
             {
                 int totalLevDist = variable.getReferences(filename).length * levenshteinDistance(variable.getName(), newName);
                 assertLevDist("renaming " + variable.getName() + " to " + newName + " (" + position + " - " + variable.getReferences(filename).length + " occurrences)",
                               totalLevDist,
                               readTestFile(filename), // original file
                               readWorkspaceFile(filename)); // refactored file
             }
         }

         @Override protected IRenameRefactoring createRefactoring()
         {
             return new RenameRefactoring();
         }
     }

     public static class ExpectFailure extends RenameTestCase
     {
         public ExpectFailure() {;}  // when JUnit invokes this outside a test suite

         public ExpectFailure(String filename, Ident variable, LineCol position, String newName)
         {
             super(filename, variable, position, newName);
         }

         /**
          * Given an array with all of the positions of identifiers that should be renamed together, try applying the Rename refactoring to
          * each, and make sure a precondition failure is raised.
          * @throws Exception
          */
         public void test() throws Exception
         {
             if (filename == null || variable == null || newName == null) return; // when JUnit invokes this outside a test suite
             //System.out.println("***** " + variable.getName() + " ==> " + newName + " *****");

             RefactoringStatus status = attemptRename(filename, position, newName, variable.getFiles());
             assertTrue("Attempting to rename " + variable.getName() + " to " + newName + " in " + filename
                            + " (" + position + " - " + variable.getReferences(filename).length + " occurrences) "
                            + "should have failed precondition checking.",
                        status.hasError());
         }

         @Override protected IRenameRefactoring createRefactoring()
         {
             return new RenameRefactoring();
         }
     }
 }
	/*******************************************************************************
	* Copyright (c) 2008 University of Illinois at Urbana-Champaign 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:
	* UIUC - Initial API and implementation
	*******************************************************************************/
	package org.eclipse.photran.internal.tests.refactoring.rename;

	import java.io.IOException;
	import java.net.URISyntaxException;
	import java.util.Set;

	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.jface.text.TextSelection;
	import org.eclipse.ltk.core.refactoring.Change;
	import org.eclipse.ltk.core.refactoring.RefactoringStatus;
	import org.eclipse.photran.internal.core.refactoring.RenameRefactoring;
	import org.eclipse.photran.internal.core.refactoring.interfaces.IRenameRefactoring;
	import org.eclipse.photran.internal.core.util.LineCol;
	import org.eclipse.photran.internal.core.vpg.PhotranVPG;
	import org.eclipse.photran.internal.tests.Activator;
	import org.eclipse.photran.internal.tests.PhotranWorkspaceTestCase;
	import org.eclipse.photran.internal.tests.refactoring.rename.RenameTestSuite.Ident;

	public abstract class RenameTestCase extends PhotranWorkspaceTestCase
	{
	private static final String DIR = "refactoring-test-code/rename";

	private static NullProgressMonitor pm = new NullProgressMonitor();

	protected String filename;
	protected Ident variable;
	protected LineCol position;
	protected String newName;

	public RenameTestCase() {;} // when JUnit invokes a subclass outside a test suite

	public RenameTestCase(String filename, Ident variable, LineCol position, String newName)
	{
	this.filename = filename;
	this.variable = variable;
	this.newName = newName;
	this.position = position;
	this.setName("test");
	}

	// public void testLevenshtein()
	// {
	// assertEquals(0, levenshteinDistance("", ""));
	// assertEquals(0, levenshteinDistance("kitten", "kitten"));
	// assertEquals(6, levenshteinDistance("", "kitten"));
	// assertEquals(6, levenshteinDistance("kitten", ""));
	// assertEquals(3, levenshteinDistance("kitten", "sitting"));
	// assertEquals(3, levenshteinDistance("kitten", "kit"));
	// assertEquals(1, levenshteinDistance("kitten", "kittten"));
	// assertEquals(2, levenshteinDistance("kitten", "kien"));
	// }

	/**
	* Computes the Levenshtein distance between two strings.
	*
	* @return the Levenshtein distance between <code>s</code> and <code>t</code>
	*/
	/*
	* This is a well-known algorithm; see, for example,
	* http://en.wikipedia.org/wiki/Levenshtein_distance
	*/
	protected int levenshteinDistance(String s, String t)
	{
	int m = s.length(), n = t.length();

	int[][] d = new int[m+1][n+1];

	for (int i = 1; i <= m; i++)
	d[i][0] = i;
	for (int j = 1; j <= n; j++)
	d[0][j] = j;

	for (int i = 1; i <= m; i++)
	{
	for (int j = 1; j <= n; j++)
	{
	int cost = s.charAt(i-1) == t.charAt(j-1) ? 0 : 1;
	d[i][j] = min(d[i-1][j] + 1, // deletion
	d[i][j-1] + 1, // insertion
	d[i-1][j-1] + cost); // substitution
	}
	}

	return d[m][n];
	}

	private int min(int a, int b, int c)
	{
	return Math.min(Math.min(a, b), c);
	}

	protected void assertLevDist(String errorMessage, int expected, String s, String t)
	{
	int actual = levenshteinDistance(s, t);

	if (actual != expected)
	{
	// Use assertEquals so that JUnit will pop up a comparison viewer
	assertEquals("Unexpected Levenshtein distance " + actual + " (expected " + expected + ") " + errorMessage,
	s,
	t);
	}
	}

	/**
	* Renames the identifier at the given position in the given workspace file to the given new name. Files in the workspace
	* are updated accordingly.
	*/
	protected void doRename(String filename, LineCol lineCol, String newName, Set<String> allFiles) throws Exception
	{
	String description = "Attempt to rename identifier at " + lineCol;

	IRenameRefactoring refactoring = createRefactoring(filename, lineCol, allFiles);

	RefactoringStatus status = refactoring.checkInitialConditions(pm);
	assertTrue(description + " failed initial precondition check: " + status.toString(), !status.hasError());

	refactoring.setNewNameForIdentifier(newName);

	status = refactoring.checkFinalConditions(pm);
	assertTrue(description + " failed final precondition check: " + status.toString(), !status.hasError());

	Change change = refactoring.createChange(pm);
	assertNotNull(description + " returned null Change object", change);
	assertTrue(description + " returned invalid Change object", change.isValid(pm).isOK());
	change.perform(pm);

	project.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
	}

	/**
	* Attempts to renames the identifier at the given position in the given workspace file to the given new name, with
	* the expectation that at least one precondition will fail. Returns the first failing status. Does not actually
	* perform the refactoring.
	*/
	protected RefactoringStatus attemptRename(String filename, LineCol lineCol, String newName, Set<String> allFiles) throws Exception
	{
	IRenameRefactoring refactoring = createRefactoring(filename, lineCol, allFiles);

	RefactoringStatus status = refactoring.checkInitialConditions(pm);
	if (status.hasError()) return status;

	refactoring.setNewNameForIdentifier(newName);

	status = refactoring.checkFinalConditions(pm);
	return status;
	}

	private IRenameRefactoring createRefactoring(final String filename, final LineCol lineCol, final Set<String> allFiles) throws Exception
	{
	PhotranVPG.getInstance().clearDatabase();

	final IFile thisFile = importFile(Activator.getDefault(), DIR, filename);
	for (String f : allFiles)
	importFile(Activator.getDefault(), DIR, f);

	// Originally, we called acquireTransientAST on each IFile
	PhotranVPG.getInstance().ensureVPGIsUpToDate(new NullProgressMonitor());
	//project.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor()); // Runs in separate thread... grrr...

	// System.out.println(filename);
	// for (String f : allFiles)
	// System.out.println(f);
	// PhotranVPG.getInstance().db.printOn(System.out);

	IRenameRefactoring r = createRefactoring();
	r.initialize(thisFile, new TextSelection(getLineColOffset(filename, lineCol), 0));
	return r;
	}

	protected abstract IRenameRefactoring createRefactoring();

	protected String readTestFile(String filename) throws IOException, URISyntaxException
	{
	return super.readTestFile(Activator.getDefault(), DIR, filename);
	}

	public static class ExpectSuccess extends RenameTestCase
	{
	public ExpectSuccess() {;} // when JUnit invokes this outside a test suite

	public ExpectSuccess(String filename, Ident variable, LineCol position, String newName)
	{
	super(filename, variable, position, newName);
	}

	/**
	* Given an array with all of the positions of identifiers that should be renamed together, try applying the Rename refactoring to
	* each, and make sure all the others change with it.
	*/
	public void test() throws Exception
	{
	if (filename == null \|\| variable == null \|\| newName == null) return; // when JUnit invokes this outside a test suite
	//System.out.println("*** " + variable.getName() + " ==> " + newName + " ***");

	doRename(filename, position, newName, variable.getFiles());
	for (String filename : variable.getFiles())
	{
	int totalLevDist = variable.getReferences(filename).length * levenshteinDistance(variable.getName(), newName);
	assertLevDist("renaming " + variable.getName() + " to " + newName + " (" + position + " - " + variable.getReferences(filename).length + " occurrences)",
	totalLevDist,
	readTestFile(filename), // original file
	readWorkspaceFile(filename)); // refactored file
	}
	}

	@Override protected IRenameRefactoring createRefactoring()
	{
	return new RenameRefactoring();
	}
	}

	public static class ExpectFailure extends RenameTestCase
	{
	public ExpectFailure() {;} // when JUnit invokes this outside a test suite

	public ExpectFailure(String filename, Ident variable, LineCol position, String newName)
	{
	super(filename, variable, position, newName);
	}

	/**
	* Given an array with all of the positions of identifiers that should be renamed together, try applying the Rename refactoring to
	* each, and make sure a precondition failure is raised.
	* @throws Exception
	*/
	public void test() throws Exception
	{
	if (filename == null \|\| variable == null \|\| newName == null) return; // when JUnit invokes this outside a test suite
	//System.out.println("*** " + variable.getName() + " ==> " + newName + " ***");

	RefactoringStatus status = attemptRename(filename, position, newName, variable.getFiles());
	assertTrue("Attempting to rename " + variable.getName() + " to " + newName + " in " + filename
	+ " (" + position + " - " + variable.getReferences(filename).length + " occurrences) "
	+ "should have failed precondition checking.",
	status.hasError());
	}

	@Override protected IRenameRefactoring createRefactoring()
	{
	return new RenameRefactoring();
	}
	}
	}