/// <summary>
/// Rename the specified input, using the relativeCount.
/// </summary>
/// <param name="input">Input String to rename.</param>
/// <param name="relativeCount">Relative count. This can be used for enumeration.</param>
/// <returns>A new string renamed according to the rename operation's rules.</returns>
public RenameResult Rename(string input, int relativeCount)
{
var renameResult = new RenameResult();
if (!string.IsNullOrEmpty(input) && !this.Prepend)
{
renameResult.Add(new Diff(input, DiffOperation.Equal));
}
if (!string.IsNullOrEmpty(this.CountFormat))
{
var currentCount = this.StartingCount + (relativeCount * this.Increment);
try
{
var currentCountAsString = currentCount.ToString(this.CountFormat);
renameResult.Add(new Diff(currentCountAsString, DiffOperation.Insertion));
}
catch (System.FormatException)
{
// Can't append anything if format is bad.
}
}
if (this.Prepend)
{
renameResult.Add(new Diff(input, DiffOperation.Equal));
}
return(renameResult);
}
/// <summary>
/// Rename the specified input, using the relativeCount.
/// </summary>
/// <param name="input">Input String to rename.</param>
/// <param name="relativeCount">Relative count. This can be used for enumeration.</param>
/// <returns>A new string renamed according to the rename operation's rules.</returns>
public override RenameResult Rename(string input, int relativeCount)
{
if (string.IsNullOrEmpty(input))
{
return(RenameResult.Empty);
}
var numCharactersFromFront = Mathf.Clamp(this.NumFrontDeleteChars, 0, input.Length);
var numCharactersNotTrimmedFromFront = input.Length - numCharactersFromFront;
var numCharactersFromBack = Mathf.Clamp(this.NumBackDeleteChars, 0, numCharactersNotTrimmedFromFront);
var numUntrimmedChars = Mathf.Max(input.Length - (numCharactersFromFront + numCharactersFromBack), 0);
var result = new RenameResult();
if (numCharactersFromFront > 0)
{
var trimmedSubstring = input.Substring(0, numCharactersFromFront);
result.Add(new Diff(trimmedSubstring, DiffOperation.Deletion));
}
if (numUntrimmedChars > 0)
{
var trimmedSubstring = input.Substring(numCharactersFromFront, numUntrimmedChars);
result.Add(new Diff(trimmedSubstring, DiffOperation.Equal));
}
if (numCharactersFromBack > 0)
{
var trimmedSubstring = input.Substring(input.Length - numCharactersFromBack, numCharactersFromBack);
result.Add(new Diff(trimmedSubstring, DiffOperation.Deletion));
}
return(result);
}
private RenameResult GetDiffResultFromStrings(string stringA, string stringB)
{
var renameResult = new RenameResult();
var consecutiveEqualChars = string.Empty;
for (int i = 0; i < stringA.Length; ++i)
{
string oldLetter = stringA.Substring(i, 1);
string newLetter = stringB.Substring(i, 1);
if (oldLetter.Equals(newLetter))
{
consecutiveEqualChars = string.Concat(consecutiveEqualChars, oldLetter);
}
else
{
if (!string.IsNullOrEmpty(consecutiveEqualChars))
{
renameResult.Add(new Diff(consecutiveEqualChars, DiffOperation.Equal));
consecutiveEqualChars = string.Empty;
}
renameResult.Add(new Diff(oldLetter, DiffOperation.Deletion));
renameResult.Add(new Diff(newLetter, DiffOperation.Insertion));
}
}
if (!string.IsNullOrEmpty(consecutiveEqualChars))
{
renameResult.Add(new Diff(consecutiveEqualChars, DiffOperation.Equal));
}
return(renameResult);
}
public void RenameToUpper_ValidLowerCharacters_AreUppered()
{
// Arrange
var name = "this is all lower";
var changeCaseOp = new ChangeCaseOperation();
changeCaseOp.Casing = ChangeCaseOperation.CasingChange.Uppercase;
var expectedName = "THIS IS ALL LOWER";
var expected = new RenameResult();
for (int i = 0; i < name.Length; ++i)
{
var expectedNameChar = expectedName.Substring(i, 1);
var nameChar = name.Substring(i, 1);
if (nameChar == expectedNameChar)
{
expected.Add(new Diff(nameChar, DiffOperation.Equal));
continue;
}
expected.Add(new Diff(nameChar, DiffOperation.Deletion));
expected.Add(new Diff(expectedNameChar, DiffOperation.Insertion));
}
// Act
var result = changeCaseOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
public void RenameToLower_ValidUpperCharacters_AreLowered()
{
// Arrange
var name = "SOME UPPER";
var changeCaseOp = new ChangeCaseOperation();
var expectedName = "some upper";
var expected = new RenameResult();
for (int i = 0; i < name.Length; ++i)
{
var expectedNameChar = expectedName.Substring(i, 1);
var nameChar = name.Substring(i, 1);
if (nameChar == expectedNameChar)
{
expected.Add(new Diff(nameChar, DiffOperation.Equal));
continue;
}
expected.Add(new Diff(nameChar, DiffOperation.Deletion));
expected.Add(new Diff(expectedNameChar, DiffOperation.Insertion));
}
// Act
var result = changeCaseOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
private RenameResult CreateDiffFromMatches(string originalName, string replacementRegex, MatchCollection matches)
{
var renameResult = new RenameResult();
var nextMatchStartingIndex = 0;
foreach (System.Text.RegularExpressions.Match match in matches)
{
// Grab the substring before the match
if (nextMatchStartingIndex < match.Index)
{
string before = originalName.Substring(nextMatchStartingIndex, match.Index - nextMatchStartingIndex);
renameResult.Add(new Diff(before, DiffOperation.Equal));
}
// Add the match as a deletion
renameResult.Add(new Diff(match.Value, DiffOperation.Deletion));
// Add the result as an insertion
var result = match.Result(replacementRegex);
if (!string.IsNullOrEmpty(result))
{
renameResult.Add(new Diff(result, DiffOperation.Insertion));
}
nextMatchStartingIndex = match.Index + match.Length;
}
if (nextMatchStartingIndex < originalName.Length)
{
var lastSubstring = originalName.Substring(nextMatchStartingIndex, originalName.Length - nextMatchStartingIndex);
renameResult.Add(new Diff(lastSubstring, DiffOperation.Equal));
}
return(renameResult);
}
/// <summary>
/// Rename the specified input, using the relativeCount.
/// </summary>
/// <param name="input">Input String to rename.</param>
/// <param name="relativeCount">Relative count. This can be used for enumeration.</param>
/// <returns>A new string renamed according to the rename operation's rules.</returns>
public RenameResult Rename(string input, int relativeCount)
{
if (string.IsNullOrEmpty(input))
{
return(RenameResult.Empty);
}
var inputCaseChanged = input;
switch (this.Casing)
{
case CasingChange.Lowercase:
inputCaseChanged = input.ToLower();
break;
case CasingChange.Uppercase:
inputCaseChanged = input.ToUpper();
break;
default:
var message = string.Format(
"CaseOperation received unknown CasingOption {0}",
this.Casing);
throw new System.ArgumentOutOfRangeException(message);
}
var renameResult = new RenameResult();
var consecutiveEqualChars = string.Empty;
for (int i = 0; i < input.Length; ++i)
{
string oldLetter = input.Substring(i, 1);
string newLetter = inputCaseChanged.Substring(i, 1);
if (oldLetter.Equals(newLetter))
{
consecutiveEqualChars = string.Concat(consecutiveEqualChars, oldLetter);
}
else
{
if (!string.IsNullOrEmpty(consecutiveEqualChars))
{
renameResult.Add(new Diff(consecutiveEqualChars, DiffOperation.Equal));
consecutiveEqualChars = string.Empty;
}
renameResult.Add(new Diff(oldLetter, DiffOperation.Deletion));
renameResult.Add(new Diff(newLetter, DiffOperation.Insertion));
}
}
if (!string.IsNullOrEmpty(consecutiveEqualChars))
{
renameResult.Add(new Diff(consecutiveEqualChars, DiffOperation.Equal));
}
return(renameResult);
}
/// <summary>
/// Compares two strings and constructs a diff based on their differences. It simply compares character by character,
/// no analysis is done to see if a character could have moved.
/// </summary>
/// <param name="originalString">The original string. Letters in here that aren't in the new string will be deletions.</param>
/// <param name="newString">The new string. Letters in here that aren't in the originalString will be insertions.</param>
/// <returns>A diff sequence representing changes between the two strings</returns>
public static RenameResult GetDiffResultFromStrings(string originalString, string newString)
{
var renameResult = new RenameResult();
var consecutiveEqualChars = string.Empty;
var longestLength = Mathf.Max(originalString.Length, newString.Length);
for (int i = 0; i < longestLength; ++i)
{
if (i >= newString.Length)
{
// Consolidate the diff with the remainder of the string so that we get a cleaner diff
// (ex: ABC => ABDog comes back as [AB=],[C-],[Dog+] instead of [AB=],[C-],[D+],[og+])
ConsolidateRemainderOfStringIntoRenameResult(renameResult, originalString, i, DiffOperation.Deletion);
break;
}
else if (i >= originalString.Length)
{
// Consolidate the diff with the remainder of the string so that we get a cleaner diff
// (ex: ABC => ABDog comes back as [AB=],[C-],[Dog+] instead of [AB=],[C-],[D+],[og+])
ConsolidateRemainderOfStringIntoRenameResult(renameResult, newString, i, DiffOperation.Insertion);
break;
}
else
{
string oldLetter = originalString.Substring(i, 1);
string newLetter = newString.Substring(i, 1);
if (oldLetter.Equals(newLetter))
{
consecutiveEqualChars = string.Concat(consecutiveEqualChars, oldLetter);
}
else
{
if (!string.IsNullOrEmpty(consecutiveEqualChars))
{
renameResult.Add(new Diff(consecutiveEqualChars, DiffOperation.Equal));
consecutiveEqualChars = string.Empty;
}
renameResult.Add(new Diff(oldLetter, DiffOperation.Deletion));
renameResult.Add(new Diff(newLetter, DiffOperation.Insertion));
}
}
}
if (!string.IsNullOrEmpty(consecutiveEqualChars))
{
renameResult.Add(new Diff(consecutiveEqualChars, DiffOperation.Equal));
}
return(renameResult);
}
private static RenameResult CreateSampleTextForDiffOp(string[] keys, DiffOperation diffOp)
{
var renameResult = new RenameResult();
string translatedText = LocalizationManager.Instance.GetTranslation("exampleTextWithInsertedWords");
Regex regex = new Regex(@"{+\d+}+");
MatchCollection matches = regex.Matches(translatedText);
List <Diff> subStrings = new List <Diff>();
for (int i = 0; i < matches.Count; i++)
{
var match = matches[i];
subStrings.Add(new Diff(translatedText.Substring(0, translatedText.IndexOf(match.Value)), DiffOperation.Equal));
var stringToInsert = i >= 0 && i < keys.Length ? LocalizationManager.Instance.GetTranslation(keys[i]) : "modified";
subStrings.Add(new Diff(stringToInsert, diffOp));
translatedText = translatedText.Remove(0, translatedText.IndexOf(match.Value) + match.Value.Length);
}
foreach (Diff currentString in subStrings)
{
renameResult.Add(currentString);
}
return(renameResult);
}
/// <summary>
/// Rename the specified input, using the relativeCount.
/// </summary>
/// <param name="input">Input String to rename.</param>
/// <param name="relativeCount">Relative count. This can be used for enumeration.</param>
/// <returns>A new string renamed according to the rename operation's rules.</returns>
public RenameResult Rename(string input, int relativeCount)
{
if (string.IsNullOrEmpty(input))
{
return(new RenameResult());
}
RenameResult renameResult;
if (string.IsNullOrEmpty(this.SearchString))
{
renameResult = new RenameResult();
renameResult.Add(new Diff(input, DiffOperation.Equal));
return(renameResult);
}
MatchCollection matches;
try
{
// Regex gives us case sensitivity, even when not searching with regex.
var regexOptions = this.SearchIsCaseSensitive ? default(RegexOptions) : RegexOptions.IgnoreCase;
matches = Regex.Matches(input, this.SearchStringAsRegex, regexOptions);
}
catch (System.ArgumentException)
{
renameResult = new RenameResult();
renameResult.Add(new Diff(input, DiffOperation.Equal));
return(renameResult);
}
renameResult = RenameResultUtilities.CreateDiffFromReplacedMatches(input, this.ReplaceMatch, matches);
return(renameResult);
}
public RenameResult Rename(string input, int relativeCount)
{
var result = new RenameResult();
result.Add(new Diff(input, DiffOperation.Equal));
return(result);
}
/// <summary>
/// Rename the specified input, using the relativeCount.
/// </summary>
/// <param name="input">Input String to rename.</param>
/// <param name="relativeCount">Relative count. This can be used for enumeration.</param>
/// <returns>A new string renamed according to the rename operation's rules.</returns>
public override RenameResult Rename(string input, int relativeCount)
{
var renameResult = new RenameResult();
if (!string.IsNullOrEmpty(input))
{
renameResult.Add(new Diff(input, DiffOperation.Deletion));
}
if (!string.IsNullOrEmpty(this.NewName))
{
renameResult.Add(new Diff(this.NewName, DiffOperation.Insertion));
}
return(renameResult);
}
public void SearchRegex_MultipleMatches_AllAreReplaced()
{
// Arrange
var name = "StoolDoodad";
var replaceStringOp = new ReplaceStringOperation();
replaceStringOp.UseRegex = true;
replaceStringOp.SearchString = "o";
var expected = new RenameResult();
expected.Add(new Diff("St", DiffOperation.Equal));
expected.Add(new Diff("o", DiffOperation.Deletion));
expected.Add(new Diff("o", DiffOperation.Deletion));
expected.Add(new Diff("lD", DiffOperation.Equal));
expected.Add(new Diff("o", DiffOperation.Deletion));
expected.Add(new Diff("o", DiffOperation.Deletion));
expected.Add(new Diff("dad", DiffOperation.Equal));
// Act
var result = replaceStringOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
public void SearchRegex_EscapeCharactersInSearch_Replaces()
{
// Arrange
var name = "Char.Hero.Woot";
var replaceStringOp = new ReplaceStringOperation();
replaceStringOp.UseRegex = true;
replaceStringOp.SearchString = "\\.";
replaceStringOp.ReplacementString = "_";
var expected = new RenameResult();
expected.Add(new Diff("Char", DiffOperation.Equal));
expected.Add(new Diff(".", DiffOperation.Deletion));
expected.Add(new Diff("_", DiffOperation.Insertion));
expected.Add(new Diff("Hero", DiffOperation.Equal));
expected.Add(new Diff(".", DiffOperation.Deletion));
expected.Add(new Diff("_", DiffOperation.Insertion));
expected.Add(new Diff("Woot", DiffOperation.Equal));
// Act
var result = replaceStringOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
private static void DrawSampleDeletionLabel(Rect rect, MulliganUserPreferences preferences)
{
var diffLabelStyle = new MulliganEditorGUIUtilities.DiffLabelStyle()
{
HideDiff = false,
OperationToShow = DiffOperation.Deletion,
DiffBackgroundColor = preferences.DeletionBackgroundColor,
DiffTextColor = preferences.DeletionTextColor,
};
var renameResult = new RenameResult();
renameResult.Add(new Diff(LocalizationManager.Instance.GetTranslation("exampleThisIs") + " ", DiffOperation.Equal));
renameResult.Add(new Diff(LocalizationManager.Instance.GetTranslation("exampleSampleText"), DiffOperation.Deletion));
renameResult.Add(new Diff(" " + LocalizationManager.Instance.GetTranslation("exampleWithWords") + " ", DiffOperation.Equal));
renameResult.Add(new Diff(LocalizationManager.Instance.GetTranslation("exampleDeleted"), DiffOperation.Deletion));
MulliganEditorGUIUtilities.DrawDiffLabel(rect, renameResult, true, diffLabelStyle, SampleDiffLabelStyle);
}
public void SearchStringCaseSensitive_MatchesCase_Replaces()
{
// Arrange
var name = "ZeldA";
var replaceStringOp = new ReplaceStringOperation();
replaceStringOp.SearchIsCaseSensitive = true;
replaceStringOp.SearchString = "ZeldA";
replaceStringOp.ReplacementString = "blah";
var expected = new RenameResult();
expected.Add(new Diff("ZeldA", DiffOperation.Deletion));
expected.Add(new Diff("blah", DiffOperation.Insertion));
// Act
var result = replaceStringOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
/// <summary>
/// Rename the specified input, using the relativeCount.
/// </summary>
/// <param name="input">Input String to rename.</param>
/// <param name="relativeCount">Relative count. This can be used for enumeration.</param>
/// <returns>A new string renamed according to the rename operation's rules.</returns>
public RenameResult Rename(string input, int relativeCount)
{
var renameResult = new RenameResult();
if (!string.IsNullOrEmpty(this.Prefix))
{
renameResult.Add(new Diff(this.Prefix, DiffOperation.Insertion));
}
if (!string.IsNullOrEmpty(input))
{
renameResult.Add(new Diff(input, DiffOperation.Equal));
}
if (!string.IsNullOrEmpty(this.Suffix))
{
renameResult.Add(new Diff(this.Suffix, DiffOperation.Insertion));
}
return(renameResult);
}
public void SearchString_OneMatch_IsReplaced()
{
// Arrange
var name = "CHAR_Hero_Spawn";
var replaceStringOp = new ReplaceStringOperation();
replaceStringOp.SearchString = "Hero";
replaceStringOp.ReplacementString = "A";
var expected = new RenameResult();
expected.Add(new Diff("CHAR_", DiffOperation.Equal));
expected.Add(new Diff("Hero", DiffOperation.Deletion));
expected.Add(new Diff("A", DiffOperation.Insertion));
expected.Add(new Diff("_Spawn", DiffOperation.Equal));
// Act
var result = replaceStringOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
public void SearchString_ReplaceSeparatedMatches_SubstitutesMultiple()
{
// Arrange
var name = "You do you";
var replaceStringOp = new ReplaceStringOperation();
replaceStringOp.UseRegex = true;
replaceStringOp.SearchString = "you";
replaceStringOp.ReplacementString = "Me";
var expected = new RenameResult();
expected.Add(new Diff("You", DiffOperation.Deletion));
expected.Add(new Diff("Me", DiffOperation.Insertion));
expected.Add(new Diff(" do ", DiffOperation.Equal));
expected.Add(new Diff("you", DiffOperation.Deletion));
expected.Add(new Diff("Me", DiffOperation.Insertion));
// Act
var result = replaceStringOp.Rename(name, 0);
Assert.AreEqual(expected, result);
}
public void SearchString_NotCaseSensitiveAndDoesNotMatchCase_StillReplaces()
{
// Arrange
var name = "ZELDAzelda";
var replaceStringOp = new ReplaceStringOperation();
replaceStringOp.SearchIsCaseSensitive = false;
replaceStringOp.SearchString = "ZelDa";
replaceStringOp.ReplacementString = "blah";
var expected = new RenameResult();
expected.Add(new Diff("ZELDA", DiffOperation.Deletion));
expected.Add(new Diff("blah", DiffOperation.Insertion));
expected.Add(new Diff("zelda", DiffOperation.Deletion));
expected.Add(new Diff("blah", DiffOperation.Insertion));
// Act
var result = replaceStringOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
public void SearchRegex_SpecialCharactersInSearch_Replaces()
{
// Arrange
var name = "Char_Hero_Woot";
var replaceStringOp = new ReplaceStringOperation();
replaceStringOp.UseRegex = true;
replaceStringOp.SearchString = "[a-zA-Z]*_";
replaceStringOp.ReplacementString = "Yep";
var expected = new RenameResult();
expected.Add(new Diff("Char_", DiffOperation.Deletion));
expected.Add(new Diff("Yep", DiffOperation.Insertion));
expected.Add(new Diff("Hero_", DiffOperation.Deletion));
expected.Add(new Diff("Yep", DiffOperation.Insertion));
expected.Add(new Diff("Woot", DiffOperation.Equal));
// Act
var result = replaceStringOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
/// <summary>
/// Rename the specified input, using the relativeCount.
/// </summary>
/// <param name="input">Input String to rename.</param>
/// <param name="relativeCount">Relative count. This can be used for enumeration.</param>
/// <returns>A new string renamed according to the rename operation's rules.</returns>
public RenameResult Rename(string input, int relativeCount)
{
var renameResult = new RenameResult();
if (!string.IsNullOrEmpty(input) && !this.Prepend)
{
renameResult.Add(new Diff(input, DiffOperation.Equal));
}
var offsetCount = (relativeCount * this.Increment) + this.StartingCount;
var stringToInsert = this.GetStringFromSequenceForIndex(offsetCount);
if (!string.IsNullOrEmpty(stringToInsert))
{
renameResult.Add(new Diff(stringToInsert, DiffOperation.Insertion));
}
if (this.Prepend)
{
renameResult.Add(new Diff(input, DiffOperation.Equal));
}
return(renameResult);
}
private static void ConsolidateRemainderOfStringIntoRenameResult(
RenameResult renameResult,
string originalString,
int indexToStartFrom,
DiffOperation diffOpIfDifferent)
{
var remainderOfOldString = originalString.Substring(indexToStartFrom, originalString.Length - indexToStartFrom);
if (renameResult.Count > 0 && renameResult[renameResult.Count - 1].Operation == diffOpIfDifferent)
{
// last diff in the sequence matches the desired diff for the remainder of the string. Consolidate them
var previousDiff = renameResult[renameResult.Count - 1];
renameResult[renameResult.Count - 1] = new Diff(
string.Concat(previousDiff.Result, remainderOfOldString),
previousDiff.Operation);
}
else
{
renameResult.Add(new Diff(remainderOfOldString, diffOpIfDifferent));
}
}
public void RemoveWhitespace_AllWhitespace_IsEmpty()
{
// Arrange
var name = " ";
var removeCharactersOp = new RemoveCharactersOperation();
removeCharactersOp.SetOptionPreset(RemoveCharactersOperation.PresetID.Whitespace);
var expected = new RenameResult();
for (int i = 0; i < name.Length; ++i)
{
var substring = name.Substring(i, 1);
expected.Add(new Diff(substring, DiffOperation.Deletion));
}
// Act
var result = removeCharactersOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
public void RemoveSymbols_OnlySymbolsInString_RemovesAllSymbols()
{
// Arrange
var name = "`~!@#$%^&*()+-=[]{}\\|;:'\",<.>/?";
var removeCharactersOp = new RemoveCharactersOperation();
removeCharactersOp.Options = RemoveCharactersOperation.Symbols;
var expected = new RenameResult();
for (int i = 0; i < name.Length; ++i)
{
var substring = name.Substring(i, 1);
expected.Add(new Diff(substring, DiffOperation.Deletion));
}
// Act
var result = removeCharactersOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
public void RemoveNumbers_AllNumbersInString_RemovesAllNumbers()
{
// Arrange
var name = "1234567890";
var removeCharactersOp = new RemoveCharactersOperation();
removeCharactersOp.Options = RemoveCharactersOperation.Numbers;
var expected = new RenameResult();
for (int i = 0; i < name.Length; ++i)
{
var substring = name.Substring(i, 1);
expected.Add(new Diff(substring, DiffOperation.Deletion));
}
// Act
var result = removeCharactersOp.Rename(name, 0);
// Assert
Assert.AreEqual(expected, result);
}
private List <RenameResult> GetRenameSequenceForName(string originalName, int count)
{
var renameResults = new List <RenameResult>();
string modifiedName = originalName;
RenameResult result;
if (this.operationSequence.Count == 0)
{
result = new RenameResult();
result.Add(new Diff(originalName, DiffOperation.Equal));
renameResults.Add(result);
}
else
{
foreach (var op in this.operationSequence)
{
result = op.Rename(modifiedName, count);
renameResults.Add(result);
modifiedName = result.Result;
}
}
return(renameResults);
}
public void SearchString_ReplaceNeighboringMatches_SubstitutesMultiple()
{
// Arrange
var name = "Thisisyours";
var replaceStringOp = new ReplaceStringOperation();
replaceStringOp.UseRegex = true;
replaceStringOp.SearchString = "is";
replaceStringOp.ReplacementString = "e";
var expected = new RenameResult();
expected.Add(new Diff("Th", DiffOperation.Equal));
expected.Add(new Diff("is", DiffOperation.Deletion));
expected.Add(new Diff("e", DiffOperation.Insertion));
expected.Add(new Diff("is", DiffOperation.Deletion));
expected.Add(new Diff("e", DiffOperation.Insertion));
expected.Add(new Diff("yours", DiffOperation.Equal));
// Act
var result = replaceStringOp.Rename(name, 0);
Assert.AreEqual(expected, result);
}