private static string GetFilePathAbsoluteFrom(string baseAbsolutePath, string relativePath)
{
var absoluteBase = new FilePathAbsolute(baseAbsolutePath).ParentDirectoryPath;
var relativeFilePath = new FilePathRelative(relativePath);
return(relativeFilePath.GetAbsolutePathFrom(absoluteBase).Path);
}
public ProjectFilesClone(IFileSystem fs, FilePathAbsolute path)
{
_fs = fs;
Assemblies = new List <FilePathAbsolute>();
Referenced = new List <FilePathAbsolute>();
ParentPath = path;
}
/// <summary>
/// Compares two directory strings
/// </summary>
/// <param name="rootDir"></param>
/// <param name="searchItem"></param>
/// <returns></returns>
public static bool CompareDirectories(string rootDir, string searchItem)
{
var root = new FilePathAbsolute(Path.GetFullPath(rootDir));
var search = new FilePathAbsolute(Path.GetFullPath(searchItem));
return(root == search);
}
protected string PrepareNunitArgs(string inputFile, string outputFile)
{
var listpath = new FilePathAbsolute(inputFile)
.GetBrotherFileWithName(
Path.GetFileNameWithoutExtension(inputFile) + "-Runlist.txt").Path;
string testToRun = "";
if (!_testsSelector.AllowAll)
{
using (var file = File.CreateText(listpath))
{
foreach (var str in _testsSelector.MinimalSelectionList)
{
file.WriteLine(str.Trim());
}
}
testToRun = " --testlist=" + listpath.InQuotes() + " ";
}
string arg = inputFile.InQuotes()
+ testToRun
+ " --result=\"" + outputFile + "\";format=nunit2 --noheader --nocolor --dispose-runners --skipnontestassemblies";
if (_options?.ParsedParams.NUnitNetVersion.Length != 0)
{
arg += (" --framework=" + _options.OtherParams);
}
return(arg);
}
public ProjectFilesClone(IFileSystem fs, FilePathAbsolute path)
{
_fs = fs;
Assemblies = new List<FilePathAbsolute>();
Referenced = new List<FilePathAbsolute>();
ParentPath = path;
}
private void Run()
{
DirectoryPathAbsolute dp = new DirectoryPathAbsolute(Path.GetDirectoryName(models.First().DisplayName));
ScenariosToRun = new ConcurrentStack <ScenarioRun>(Runs.Where(var => var.RunThis));
foreach (var v in models)
{
v.ResultFileNames.Clear();
DirectoryPathAbsolute dp2 = new DirectoryPathAbsolute(Path.GetDirectoryName(v.DisplayName));
foreach (var file in FileNamesToCopy)
{
FilePathAbsolute fp = new FilePathAbsolute(file);
var rp = fp.GetPathRelativeFrom(dp);
v.ResultFileNames.Add(rp.GetAbsolutePathFrom(dp2).Path);
}
if (v is PestModel)
{
((PestModel)v).MsheFileName = mikeSheFileName.GetAbsolutePathFrom(dp2).Path;
((PestModel)v).PostProcessBatFile = postProcessBat.GetAbsolutePathFrom(dp2).Path;
}
Thread.Sleep(TimeSpan.FromMinutes(1));
RunNext(v);
}
}
public async Task <ProjectFilesClone> CreateCloneAsync(string name)
{
FilePathAbsolute tmp = CreateTmpDir("VisualMutator-" + name + "-");
ProjectFilesClone clone = await _filesManager.CreateProjectClone(_mainClone.Referenced, _mainClone.Assemblies, tmp);
clone.IsIncomplete |= _mainClone.IsIncomplete;
return(clone);
}
public string GetRelativePath(string absoluteFilePath, string absoluteDirectoryPath)
{
FilePathAbsolute filePathAbsolute1 = new FilePathAbsolute(absoluteFilePath);
DirectoryPathAbsolute directoryPathAbsolute1 = new DirectoryPathAbsolute(absoluteDirectoryPath);
FilePathRelative filePathRelative1 = filePathAbsolute1.GetPathRelativeFrom(directoryPathAbsolute1);
return(filePathRelative1.Path);
}
public async Task<MutantTestResults> RunTests()
{
string name = string.Format("muttest-{0}.xml", Path.GetFileName(_assemblyPath));
string outputFilePath = new FilePathAbsolute(_assemblyPath).GetBrotherFileWithName(name).ToString();
if (_testsSelector.IsEmpty)
{
_testResults = new MutantTestResults();
return TestResults;
}
_testResults = await RunTests(_assemblyPath,
outputFilePath);
return TestResults;
}
private void GetMshe()
{
Microsoft.Win32.OpenFileDialog openFileDialog2 = new Microsoft.Win32.OpenFileDialog();
openFileDialog2.Filter = "Known file types (*.she)|*.she";
openFileDialog2.Title = "Select the Mike She file corresponding to the first .pst-file";
if (openFileDialog2.ShowDialog().Value)
{
DirectoryPathAbsolute dp = new DirectoryPathAbsolute(Path.GetDirectoryName(models.First().DisplayName));
FilePathAbsolute fp = new FilePathAbsolute(openFileDialog2.FileName);
mikeSheFileName = fp.GetPathRelativeFrom(dp);
RaisePropertyChanged("MikeSheFileName");
}
}
private void GetBat()
{
Microsoft.Win32.OpenFileDialog openFileDialog2 = new Microsoft.Win32.OpenFileDialog();
openFileDialog2.Filter = "Known file types (*.bat)|*.bat";
openFileDialog2.Title = "Select a batch file that will be run after completion of the model run";
if (openFileDialog2.ShowDialog().Value)
{
DirectoryPathAbsolute dp = new DirectoryPathAbsolute(Path.GetDirectoryName(models.First().DisplayName));
FilePathAbsolute fp = new FilePathAbsolute(openFileDialog2.FileName);
postProcessBat = fp.GetPathRelativeFrom(dp);
RaisePropertyChanged("PostProcessBat");
}
}
public async Task <MutantTestResults> RunTests()
{
string name = string.Format("muttest-{0}.xml", Path.GetFileName(_assemblyPath));
string outputFilePath = new FilePathAbsolute(_assemblyPath).GetBrotherFileWithName(name).ToString();
if (_testsSelector.IsEmpty)
{
_testResults = new MutantTestResults();
return(TestResults);
}
_testResults = await RunTests(_assemblyPath,
outputFilePath);
return(TestResults);
}
/// <summary>
/// Returns a relative path string from a full path.
/// </summary>
/// <returns></returns>
public static string GetRelativePath(string rootDir, string filePath)
{
if (rootDir == null || filePath == null)
{
return(filePath);
}
if (IsSubdirectory(rootDir, filePath))
{
var filePathAbsolute = new FilePathAbsolute(filePath);
var directoryPathAbsolute = new DirectoryPathAbsolute(rootDir);
FilePathRelative filePathRelative = filePathAbsolute.GetPathRelativeFrom(directoryPathAbsolute);
return(filePathRelative.Path);
}
return(filePath);
}
public ProjectClonesManager(
IHostEnviromentConnection hostEnviroment,
FilesManager filesManager,
IFileSystem fs)
{
_hostEnviroment = hostEnviroment;
_filesManager = filesManager;
_fs = fs;
List <FilePathAbsolute> originalProjectFiles = _hostEnviroment.GetProjectAssemblyPaths().ToList();
IEnumerable <FilePathAbsolute> referencedFiles = GetReferencedAssemblyPaths(originalProjectFiles).Select(s => s.ToFilePathAbs());
FilePathAbsolute tmp = CreateTmpDir("VisualMutator-MainClone-");
_mainClone = _filesManager.CreateProjectClone(referencedFiles, originalProjectFiles, tmp).Result;
}
public Task <ProcessResults> RunNUnitConsole(string nunitConsolePath,
string inputFile, string outputFile)
{
var listpath = new FilePathAbsolute(inputFile)
.GetBrotherFileWithName(
Path.GetFileNameWithoutExtension(inputFile) + "-Runlist.txt").Path;
string testToRun = "";
if (!_testsSelector.AllowAll)
{
using (var file = File.CreateText(listpath))
{
foreach (var str in _testsSelector.MinimalSelectionList)
{
file.WriteLine(str.Trim());
}
}
testToRun = " /runlist:" + listpath.InQuotes() + " ";
}
string arg = inputFile.InQuotes()
+ testToRun
+ " /xml \"" + outputFile + "\" /nologo -trace=Verbose /noshadow /nothread";
if (_options.ParsedParams.NUnitNetVersion.Length != 0)
{
arg += (" /framework:" + _options.OtherParams);
}
_log.Info("Running \"" + nunitConsolePath + "\" " + arg);
var startInfo = new ProcessStartInfo
{
Arguments = arg,
CreateNoWindow = true,
ErrorDialog = true,
RedirectStandardOutput = false,
FileName = nunitConsolePath,
UseShellExecute = false,
};
return(_processes.RunAsync(startInfo, _cancellationTokenSource));
}
/// <summary>
/// Returns a relative path string from a full path.
/// </summary>
/// <returns></returns>
public static string GetRelativePath(string rootDir, string filePath)
{
if (rootDir == null || filePath == null)
{
return(filePath);
}
if (IsSubdirectory(rootDir, filePath))
{
if (rootDir.StartsWith("\\")) //network disk?
{
return("." + filePath.Substring(rootDir.Length));
}
else
{
var filePathAbsolute = new FilePathAbsolute(filePath);
var directoryPathAbsolute = new DirectoryPathAbsolute(rootDir);
FilePathRelative filePathRelative = filePathAbsolute.GetPathRelativeFrom(directoryPathAbsolute);
return(filePathRelative.Path);
}
}
return(filePath);
}
static void Main(string[] args)
{
FilePathAbsolute filePathAbsolute1, filePathAbsolute2;
FilePathRelative filePathRelative1;
DirectoryPathAbsolute directoryPathAbsolute1;
DirectoryPathRelative directoryPathRelative1;
// Path normalization
filePathAbsolute1 = new FilePathAbsolute(@"C:/Dir1\\File.txt");
Debug.Assert(filePathAbsolute1.Path == @"C:\Dir1\File.txt");
directoryPathAbsolute1 = new DirectoryPathAbsolute(@"C:/Dir1\\Dir2\");
Debug.Assert(directoryPathAbsolute1.Path == @"C:\Dir1\Dir2");
directoryPathAbsolute1 = new DirectoryPathAbsolute(@"C:\Dir1\..\Dir2\.");
Debug.Assert(directoryPathAbsolute1.Path == @"C:\Dir2");
// Path comparison
filePathAbsolute1 = new FilePathAbsolute(@"C:/Dir1\\File.txt");
filePathAbsolute2 = new FilePathAbsolute(@"C:\DIR1\FILE.TXT");
Debug.Assert(filePathAbsolute1.Equals(filePathAbsolute2));
Debug.Assert(filePathAbsolute1 == filePathAbsolute2);
// Relative -> Absolute path conversion
filePathRelative1 = new FilePathRelative(@"..\..\Dir1\File.txt");
directoryPathAbsolute1 = new DirectoryPathAbsolute(@"C:\Dir2\Dir3\Dir4");
filePathAbsolute1 = filePathRelative1.GetAbsolutePathFrom(directoryPathAbsolute1);
Debug.Assert(filePathAbsolute1.Path == @"C:\Dir2\Dir1\File.txt");
// Absolute -> Relative path conversion
filePathAbsolute1 = new FilePathAbsolute(@"C:\Dir1\File.txt");
directoryPathAbsolute1 = new DirectoryPathAbsolute(@"C:\Dir2\Dir3\Dir4");
filePathRelative1 = filePathAbsolute1.GetPathRelativeFrom(directoryPathAbsolute1);
Debug.Assert(filePathRelative1.Path == @"..\..\..\Dir1\File.txt");
// Path string validation
string reason;
Debug.Assert(PathHelper.IsValidAbsolutePath(@"C:\Dir2\Dir1", out reason));
Debug.Assert(!PathHelper.IsValidAbsolutePath(@"C:\..\Dir1", out reason));
Debug.Assert(!PathHelper.IsValidAbsolutePath(@".\Dir1", out reason));
Debug.Assert(!PathHelper.IsValidAbsolutePath(@"1:\Dir1", out reason));
Debug.Assert(PathHelper.IsValidRelativePath(@".\Dir1\Dir2", out reason));
Debug.Assert(PathHelper.IsValidRelativePath(@"..\Dir1\Dir2", out reason));
Debug.Assert(PathHelper.IsValidRelativePath(@".\Dir1\..\Dir2", out reason));
Debug.Assert(!PathHelper.IsValidRelativePath(@".\Dir1\..\..\Dir2", out reason));
Debug.Assert(!PathHelper.IsValidRelativePath(@"C:\Dir1\Dir2", out reason));
// File name & extension
filePathAbsolute1 = new FilePathAbsolute(@"C:\Dir1\File.cs.Txt");
Debug.Assert(filePathAbsolute1.FileName == "File.cs.Txt");
Debug.Assert(filePathAbsolute1.FileNameWithoutExtension == "File.cs");
Debug.Assert(filePathAbsolute1.FileExtension == ".Txt");
Debug.Assert(filePathAbsolute1.HasExtension(".txt"));
// Path browsing
filePathAbsolute1 = new FilePathAbsolute(@"C:\Dir1\File.cs.Txt");
Debug.Assert(filePathAbsolute1.ParentDirectoryPath.Path == @"C:\Dir1");
Debug.Assert(filePathAbsolute1.GetBrotherFileWithName("File.xml").Path == @"C:\Dir1\File.xml");
Debug.Assert(filePathAbsolute1.ParentDirectoryPath.GetChildDirectoryWithName("Dir2").Path == @"C:\Dir1\Dir2");
Debug.Assert(filePathAbsolute1.ParentDirectoryPath.GetChildDirectoryWithName("..").Path == @"C:");
directoryPathRelative1 = new DirectoryPathRelative(@"..\Dir1\Dir2");
Debug.Assert(directoryPathRelative1.ParentDirectoryPath.Path == @"..\Dir1");
// Path rebasing
directoryPathAbsolute1 = new DirectoryPathAbsolute(@"C:\Dir1\Dir2\Dir3");
DirectoryPathAbsolute directoryPathAbsolute2 = new DirectoryPathAbsolute(@"E:\Dir4\Dir1");
DirectoryPathAbsolute rebasedPath;
PathHelper.TryRebasePath(directoryPathAbsolute1, directoryPathAbsolute2, out rebasedPath);
Debug.Assert(rebasedPath.Path == @"E:\Dir4\Dir1\Dir2\Dir3");
// List of path ListOfPathsEquals \ Contains \ TryGetCommonRootDirectory
List <DirectoryPathAbsolute> list1 = new List <DirectoryPathAbsolute>();
List <DirectoryPathAbsolute> list2 = new List <DirectoryPathAbsolute>();
list1.Add(new DirectoryPathAbsolute(@"C:\Dir1\Dir2"));
list2.Add(new DirectoryPathAbsolute(@"c:\dir1\dir2"));
list1.Add(new DirectoryPathAbsolute(@"C:\Dir1\Dir3\Dir4"));
list2.Add(new DirectoryPathAbsolute(@"c:\dir1\dir3\dir4"));
Debug.Assert(ListOfPathHelper.ListOfPathsEquals(list1, list2));
Debug.Assert(ListOfPathHelper.Contains(list1, new DirectoryPathAbsolute(@"C:\Dir1\dir2")));
ListOfPathHelper.TryGetCommonRootDirectory(list1, out directoryPathAbsolute1);
Debug.Assert(directoryPathAbsolute1.Path == @"C:\Dir1");
// List of path GetListOfUniqueDirsAndUniqueFileNames
List <FilePathAbsolute> list = new List <FilePathAbsolute>();
list.Add(new FilePathAbsolute(@"E:\Dir1\Dir2\File1.txt"));
list.Add(new FilePathAbsolute(@"E:\dir1\dir2\File2.txt"));
list.Add(new FilePathAbsolute(@"E:\Dir1\Dir2\Dir3\file2.txt"));
List <DirectoryPathAbsolute> listOfUniqueDirs;
List <string> listOfUniqueFileNames;
ListOfPathHelper.GetListOfUniqueDirsAndUniqueFileNames(list, out listOfUniqueDirs, out listOfUniqueFileNames);
Debug.Assert(listOfUniqueDirs.Count == 2);
Debug.Assert(listOfUniqueDirs[0].Path == @"E:\Dir1\Dir2");
Debug.Assert(listOfUniqueDirs[1].Path == @"E:\Dir1\Dir2\Dir3");
Debug.Assert(listOfUniqueFileNames.Count == 2);
Debug.Assert(listOfUniqueFileNames[0] == "File1.txt");
Debug.Assert(listOfUniqueFileNames[1] == "File2.txt");
// Interaction with System.IO API
filePathAbsolute1 = new FilePathAbsolute(
System.Reflection.Assembly.GetExecutingAssembly().Location);
Debug.Assert(filePathAbsolute1.Exists);
System.IO.FileInfo fileInfo = filePathAbsolute1.FileInfo;
directoryPathAbsolute1 = filePathAbsolute1.ParentDirectoryPath as DirectoryPathAbsolute;
Debug.Assert(directoryPathAbsolute1.Exists);
System.IO.DirectoryInfo directoryInfo = directoryPathAbsolute1.DirectoryInfo;
List <DirectoryPathAbsolute> listSubDir = directoryPathAbsolute1.ChildrenDirectoriesPath;
List <FilePathAbsolute> listSubFile = directoryPathAbsolute1.ChildrenFilesPath;
}
public async Task <ProjectFilesClone> CreateProjectClone(IEnumerable <FilePathAbsolute> referencedFiles,
IEnumerable <FilePathAbsolute> projectFiles, FilePathAbsolute tmp)
{
var clone = _clonesFactory.CreateWithParams(tmp);
foreach (var referenced in referencedFiles)
{
try
{
var destination = (FilePathAbsolute)tmp.AsChild(referenced);
await CopyOverwriteAsync(referenced, destination);
clone.Referenced.Add(destination);
}
catch (Exception e)
{
_log.Warn("Could not copy file : " + e.Message);
clone.IsIncomplete = true;
}
}
foreach (var projFile in projectFiles)
{
try
{
var destination = (FilePathAbsolute)tmp.AsChild(projFile);
await CopyOverwriteAsync(projFile, destination);
clone.Assemblies.Add(destination);
}
catch (Exception e)
{
_log.Warn("Could not copy file : " + e.Message);
clone.IsIncomplete = true;
}
}
return(clone);
}
public Task<ProcessResults> RunNUnitConsole(string nunitConsolePath,
string inputFile, string outputFile)
{
var listpath = new FilePathAbsolute(inputFile)
.GetBrotherFileWithName(
Path.GetFileNameWithoutExtension(inputFile) + "-Runlist.txt").Path;
string testToRun = "";
if(!_testsSelector.AllowAll)
{
using (var file = File.CreateText(listpath))
{
foreach (var str in _testsSelector.MinimalSelectionList)
{
file.WriteLine(str.Trim());
}
}
testToRun = " /runlist:" + listpath.InQuotes() + " ";
}
string arg = inputFile.InQuotes()
+ testToRun
+ " /xml \"" + outputFile + "\" /nologo -trace=Verbose /noshadow /nothread";
if (_options.ParsedParams.NUnitNetVersion.Length != 0)
{
arg += (" /framework:" + _options.OtherParams);
}
_log.Info("Running \"" + nunitConsolePath+"\" " + arg);
var startInfo = new ProcessStartInfo
{
Arguments = arg,
CreateNoWindow = true,
ErrorDialog = true,
RedirectStandardOutput = false,
FileName = nunitConsolePath,
UseShellExecute = false,
};
return _processes.RunAsync(startInfo, _cancellationTokenSource);
}
private static string GetFilePathRelativeFrom(string baseAbsolutePath, string absolutePath)
{
var currentAbsoluteDirectoryPath = new FilePathAbsolute(baseAbsolutePath).ParentDirectoryPath;
return(new FilePathAbsolute(absolutePath).GetPathRelativeFrom(currentAbsoluteDirectoryPath).Path);
}
