/// <summary>
/// Load test cases
/// </summary>
/// <param name="testcasePath">Test case location</param>
/// <param name="number">Test case index</param>
/// <param name="filePath">Location of C++ file related to the conflict</param>
/// <returns>Returns a merge conflict object containing the conflict related information</returns>
public static MergeConflict LoadTestInput(string testcasePath, string number, string filePath)
{
string conflict = testcasePath + number + "_Conflict.txt";
string content = testcasePath + number + "_FileName.txt";
string fileContent = null;
int type = conflictType(conflict);
if (File.Exists(content))
{
content = System.IO.File.ReadAllText(@content);
fileContent = filePath + content;
}
if (File.Exists(fileContent))
{
fileContent = System.IO.File.ReadAllText(@fileContent);
}
else
{
fileContent = null;
}
conflict = System.IO.File.ReadAllText(@conflict);
MergeConflict input = new MergeConflict(conflict, fileContent, "", type);
return(input);
}
public static MergeConflict ToMergeConflict(JProperty prop)
{
var res = new MergeConflict();
res.fieldName = prop.Name;
if (prop.Value is JObject o)
{
var properties = o.Properties();
if (IsArray(properties.First()))
{
res.specialType = MergeConflict.SPECIAL_TYPE_ARRAY;
properties = properties.Skip(1);
}
res.conflicts = properties.Map(ToMergeConflict);
}
else if (prop.Value is JArray oldAndNewValue)
{
AssertV2.AreEqual(2, oldAndNewValue.Count);
res.oldValue = oldAndNewValue[0];
res.newValue = oldAndNewValue[1];
}
else
{
throw new NotImplementedException("Unhandled type " + prop.Value.GetType() + ":\n" + prop.Value.ToPrettyString());
}
return(res);
}
/// <summary>
/// Read the conflict resolution done by the user
/// </summary>
/// <param name="Path">Location of the resolved path</param>
/// <param name="type">1=include, 2=macro related conflicts</param>
/// <returns>List of nodes of resolved conflicts</returns>
public static IReadOnlyList <Node> readResolvedConflicts(string Path, int type)
{
string resolvedConflict = System.IO.File.ReadAllText(@Path);
if (type == 1)
{
string[] includePaths = resolvedConflict.Split(',');
List <string> path = new List <string>();
foreach (string includePath in includePaths)
{
string temp;
temp = includePath.NormalizeInclude();
path.Add(temp);
}
return(MergeConflict.PathToNode(path));
}
else
{
string temp;
List <string> path = new List <string>();
temp = resolvedConflict.NormalizeInclude();
path.Add(temp);
return(MergeConflict.PathToNode(path));
}
}
/// <summary>
/// Execute all synthesized codes on the merge conflict
/// </summary>
/// <param name="input">Merge conflict</param>
/// <param name="programList">List of synthesized programs</param>
/// <param name="type">1=include, 2= macro related conflicts</param>
/// <returns>List of all matched resolutions</returns>
internal static List <IReadOnlyList <Node> > LoadAllSynthesizedCode(MergeConflict input, List <Program> programList, int type)
{
List <IReadOnlyList <Node> > outputQueue = new List <IReadOnlyList <Node> >();
if (type == 1)
{
outputQueue.Add(programList[0].Run(input));
outputQueue.Add(programList[1].Run(input));
outputQueue.Add(programList[2].Run(input));
outputQueue.Add(programList[3].Run(input));
if (Semantics.NodeValue(input.Upstream[0], "path") != "")
{
outputQueue.Add(programList[4].Run(input));
}
outputQueue.Add(programList[5].Run(input));
outputQueue.Add(programList[6].Run(input));
outputQueue.Add(programList[7].Run(input));
outputQueue.Add(programList[8].Run(input));
}
else
{
outputQueue.Add(programList[9].Run(input));
outputQueue.Add(programList[10].Run(input));
}
return(outputQueue);
}
protected void OnMergeConflict(WordList set, MergeConflict conflict)
{
var h = MergeConflict;
if (h != null)
{
SynchronizationContext.Current.Post(x => h(this, set, conflict), null);
}
}
/// <summary>
/// Load the output after running all the testcases. If there is no pattern returned then the default behavior is concatenating the main and the
/// for branch. Since we only concentrate on the structural conflicts, the order of the conflicts do not matter. So, we validate the solution
/// with the resolved conflict by main followed by fork and fork followed by main.
/// </summary>
/// <param name="input">Merge conflict</param>
/// <param name="programList">List of synthesized programs</param>
/// <param name="testcasePath">Location of the testcase</param>
/// <param name="number">Test case index</param>
/// <returns>True if matches with the resolution provided by user, false otherwise</returns>
public static bool ValidOutput(MergeConflict input, List <Program> programList, string testcasePath, string number)
{
string resolvedFilename = testcasePath + number + "_Resolved.txt";
string conflict = testcasePath + number + "_Conflict.txt";
int typeOfConflict = conflictType(conflict);
IReadOnlyList <Node> output = readResolvedConflicts(resolvedFilename, typeOfConflict);
List <bool> checkOutput = new List <bool>();
List <IReadOnlyList <Node> > outputQueue = LoadAllSynthesizedCode(input, programList, typeOfConflict);
bool flagStart = false;
bool flagValid = false;
foreach (IReadOnlyList <Node> n in outputQueue)
{
if (n != null)
{
if (n.Count > 0)
{
flagStart = true;
if (Equal(n, output))
{
flagValid = true;
}
}
}
}
if (flagValid)
{
checkOutput.Add(true);
}
else if (flagStart == false)
{
if (Equal(Semantics.Concat(input.Downstream, input.Upstream), output) == true || Equal(Semantics.Concat(input.Upstream, input.Downstream), output) == true)
{
checkOutput.Add(true);
}
else if (Semantics.NodeValue(input.Upstream[0], "path") == "")
{
if (Equal(input.Downstream, output) == true)
{
checkOutput.Add(true);
}
else
{
checkOutput.Add(false);
}
}
else
{
checkOutput.Add(false);
}
}
else
{
checkOutput.Add(false);
}
return(checkOutput[0]);
}
/// <summary>
/// Gets the name of the entity that did cause the specified merge conflict.
/// </summary>
/// <param name="mergeConflict"> The merge conflict. </param>
/// <returns> The get entity name. </returns>
private static string GetEntityName(MergeConflict mergeConflict)
{
var element = mergeConflict.SourceElement ?? mergeConflict.TargetElement ?? mergeConflict.BaselineElement;
var type = element.GetType().Name;
switch (type)
{
case "StdContact":
return(((StdContact)element).GetFullName());
default:
return(element.ToSortSimple());
}
}
private PathStatus OnMergeConflict(string path, PathStatus status)
{
if (Options.PerPathNotificationCallback != null)
{
if (status == null)
{
status = new PathStatus(Repository, path);
}
status.IndexPathStatus = IndexPathStatus.MergeConflict;
}
MergeConflict.Add(path);
AnyDifferences = true;
return(status);
}
public void MacroTest()
{
List <bool> checkOutput = new List <bool>();
List <Program> programList = TestUtils.LoadProgram();
string testcasePath = @"..\..\..\..\..\Dataset\MacroSuite";
string filePath = @"..\..\..\..\..\Dataset\Files\";
List <string> countTestCase = TestUtils.TestCaseLoad(testcasePath);
foreach (string number in countTestCase)
{
MergeConflict input = TestUtils.LoadTestInput(testcasePath, number, filePath);
Assert.IsTrue(TestUtils.ValidOutput(input, programList, testcasePath, number));
}
}
static void Main(string[] args)
{
// Two examples of conflicts and resolutions
string conflict1 = @"<<<<<<< HEAD
#include ""base/command_line.h""
#include ""base/logging.h""
=======
#include ""base/check_op.h""
>>>>>>>";
string resolution1 = @"#include ""base/command_line.h""
#include ""base/check_op.h""";
string conflict2 = @"<<<<<<< HEAD
#include ""base/logging.h""
#include ""base/scoped_native_library.h""
=======
#include ""base/notreached.h""
>>>>>>>";
string resolution2 = @"#include ""base/scoped_native_library.h""
#include ""base/notreached.h""";
MergeConflict input1 = new MergeConflict(conflict1);
MergeConflict input2 = new MergeConflict(conflict2);
List <ResolutionExample> examples = new List <ResolutionExample>
{
new ResolutionExample(input1, resolution1),
new ResolutionExample(input2, resolution2)
};
// Learn with two examples
Program program = Learner.Instance.Learn(examples);
// Execute the program on new, unseen input to get the resolution
string newConflict = @"<<<<<<< HEAD
#include ""ui/base/anonymous_ui_base_features.h""
#include ""base/logging.h""
=======
#include ""ui/base/cursor/mojom/cursor_type.mojom-blink.h""
>>>>>>>";
MergeConflict newInput = new MergeConflict(newConflict);
string resolution = program.RunString(newInput);
Console.WriteLine(resolution);
}
protected void OnMergeConflict(WordList set, MergeConflict conflict) {
var h = MergeConflict;
if (h != null)
SynchronizationContext.Current.Post(x => h(this, set, conflict), null);
}
/// <summary>
/// Run the diff operation. Until this is called, all lists will be empty
/// </summary>
/// <returns>true if anything is different between index, tree, and workdir</returns>
private void UpdateDirectory(IEnumerable <string> paths, bool recursive)
{
RevWalk rw = new RevWalk(Repository);
ObjectId id = Repository.Resolve(Constants.HEAD);
var commit = id != null?rw.ParseCommit(id) : null;
TreeWalk treeWalk = new TreeWalk(Repository);
treeWalk.Reset();
treeWalk.Recursive = false;
if (commit != null)
{
treeWalk.AddTree(commit.Tree);
}
else
{
treeWalk.AddTree(new EmptyTreeIterator());
}
DirCache dc = Repository.ReadDirCache();
treeWalk.AddTree(new DirCacheIterator(dc));
FileTreeIterator workTree = new FileTreeIterator(Repository.WorkTree, Repository.FileSystem, WorkingTreeOptions.KEY.Parse(Repository.GetConfig()));
treeWalk.AddTree(workTree);
List <TreeFilter> filters = new List <TreeFilter> ();
filters.Add(new SkipWorkTreeFilter(1));
var pathFilters = paths.Where(p => p != ".").Select(p => PathFilter.Create(p)).ToArray();
if (pathFilters.Length > 1)
{
filters.Add(OrTreeFilter.Create(pathFilters)); // Use an OR to join all path filters
}
else if (pathFilters.Length == 1)
{
filters.Add(pathFilters[0]);
}
if (filters.Count > 1)
{
treeWalk.Filter = AndTreeFilter.Create(filters);
}
else
{
treeWalk.Filter = filters[0];
}
while (treeWalk.Next())
{
AbstractTreeIterator treeIterator = treeWalk.GetTree <AbstractTreeIterator>(0);
DirCacheIterator dirCacheIterator = treeWalk.GetTree <DirCacheIterator>(1);
WorkingTreeIterator workingTreeIterator = treeWalk.GetTree <WorkingTreeIterator>(2);
NGit.FileMode fileModeTree = treeWalk.GetFileMode(0);
if (treeWalk.IsSubtree)
{
treeWalk.EnterSubtree();
continue;
}
int stage = dirCacheIterator != null?dirCacheIterator.GetDirCacheEntry().Stage : 0;
if (stage > 1)
{
continue;
}
else if (stage == 1)
{
MergeConflict.Add(dirCacheIterator.EntryPathString);
changesExist = true;
continue;
}
if (treeIterator != null)
{
if (dirCacheIterator != null)
{
if (!treeIterator.EntryObjectId.Equals(dirCacheIterator.EntryObjectId))
{
// in repo, in index, content diff => changed
Modified.Add(dirCacheIterator.EntryPathString);
changesExist = true;
}
}
else
{
// in repo, not in index => removed
if (!fileModeTree.Equals(NGit.FileMode.TYPE_TREE))
{
Removed.Add(treeIterator.EntryPathString);
changesExist = true;
}
}
}
else
{
if (dirCacheIterator != null)
{
// not in repo, in index => added
Added.Add(dirCacheIterator.EntryPathString);
changesExist = true;
}
else
{
// not in repo, not in index => untracked
if (workingTreeIterator != null && !workingTreeIterator.IsEntryIgnored())
{
Untracked.Add(workingTreeIterator.EntryPathString);
changesExist = true;
}
}
}
if (dirCacheIterator != null)
{
if (workingTreeIterator == null)
{
// in index, not in workdir => missing
Missing.Add(dirCacheIterator.EntryPathString);
changesExist = true;
}
else
{
// Workaround to file time resolution issues
long itime = dirCacheIterator.GetDirCacheEntry().LastModified;
long ftime = workingTreeIterator.GetEntryLastModified();
if (itime / 1000 != ftime / 1000)
{
if (!dirCacheIterator.IdEqual(workingTreeIterator))
{
// in index, in workdir, content differs => modified
Modified.Add(dirCacheIterator.EntryPathString);
changesExist = true;
}
}
}
}
}
}
/// <summary>
/// Run the diff operation. Until this is called, all lists will be empty
/// </summary>
/// <returns>true if anything is different between index, tree, and workdir</returns>
public bool Diff()
{
DirectoryInfo root = _index.Repository.WorkingDirectory;
var visitor = new AbstractIndexTreeVisitor
{
VisitEntry = delegate(TreeEntry treeEntry, GitIndex.Entry indexEntry, FileInfo file)
{
if (treeEntry == null)
{
Added.Add(indexEntry.Name);
_anyChanges = true;
}
else if (indexEntry == null)
{
if (!(treeEntry is Tree))
{
Removed.Add(treeEntry.FullName);
}
_anyChanges = true;
}
else
{
if (!treeEntry.Id.Equals(indexEntry.ObjectId))
{
Changed.Add(indexEntry.Name);
_anyChanges = true;
}
}
if (indexEntry != null)
{
if (!file.Exists)
{
Missing.Add(indexEntry.Name);
_anyChanges = true;
}
else
{
if (indexEntry.IsModified(root, true))
{
Modified.Add(indexEntry.Name);
_anyChanges = true;
}
}
}
if (indexEntry != null)
{
if (indexEntry.Stage != 0)
{
MergeConflict.Add(indexEntry.Name);
_anyChanges = true;
}
}
}
};
new IndexTreeWalker(_index, _tree, root, visitor).Walk();
CheckUntrackedDirectory(root.FullName, string.Empty);
return(_anyChanges);
}
