playtest-unity/playtest/Library/PackageCache/com.unity.testtools.codecov.../Editor/Utils/CoverageUtils.cs

380 lines
14 KiB
C#

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using UnityEditor.Networking.PlayerConnection;
using UnityEngine;
using UnityEngine.TestTools;
namespace UnityEditor.TestTools.CodeCoverage.Utils
{
internal static class CoverageUtils
{
public static bool IsConnectedToPlayer
{
get
{
return EditorConnection.instance.ConnectedPlayers.Count > 0;
}
}
public static string NormaliseFolderSeparators(string folderPath, bool stripTrailingSlash = false)
{
if (folderPath != null)
{
folderPath = folderPath.Replace('\\', '/');
if (stripTrailingSlash)
{
folderPath = folderPath.TrimEnd('/');
}
}
return folderPath;
}
public static bool EnsureFolderExists(string folderPath)
{
if (string.IsNullOrEmpty(folderPath))
return false;
if (!Directory.Exists(folderPath))
{
try
{
Directory.CreateDirectory(folderPath);
}
catch (Exception)
{
return false;
}
}
return true;
}
public static string GetProjectFolderName()
{
string[] projectPathArray = GetProjectPath().Split('/');
Debug.Assert(projectPathArray.Length > 0);
string folderName = projectPathArray[projectPathArray.Length - 1];
char[] invalidChars = Path.GetInvalidPathChars();
StringBuilder folderNameStringBuilder = new StringBuilder();
foreach (char c in folderName)
{
if (invalidChars.Contains(c))
{
folderNameStringBuilder.Append('_');
}
else
{
folderNameStringBuilder.Append(c);
}
}
return folderNameStringBuilder.ToString();
}
public static string StripAssetsFolderIfExists(string folderPath)
{
if (folderPath != null)
{
string toTrim = "Assets";
folderPath = folderPath.TrimEnd(toTrim.ToCharArray());
}
return folderPath;
}
public static string GetProjectPath()
{
return NormaliseFolderSeparators(StripAssetsFolderIfExists(Application.dataPath), true);
}
public static string GetRootFolderPath(CoverageSettings coverageSettings)
{
string rootFolderPath = string.Empty;
string coverageFolderPath = string.Empty;
if (CommandLineManager.instance.batchmode && !CommandLineManager.instance.useProjectSettings)
{
if (coverageSettings.resultsPathFromCommandLine.Length > 0)
{
coverageFolderPath = coverageSettings.resultsPathFromCommandLine;
EnsureFolderExists(coverageFolderPath);
}
}
else
{
if (CommandLineManager.instance.runFromCommandLine && coverageSettings.resultsPathFromCommandLine.Length > 0)
{
coverageFolderPath = coverageSettings.resultsPathFromCommandLine;
EnsureFolderExists(coverageFolderPath);
}
else
{
coverageFolderPath = CoveragePreferences.instance.GetStringForPaths("Path", string.Empty);
}
}
string projectPath = GetProjectPath();
if (EnsureFolderExists(coverageFolderPath))
{
coverageFolderPath = NormaliseFolderSeparators(coverageFolderPath, true);
// Add 'CodeCoverage' directory if coverageFolderPath is projectPath
if (string.Equals(coverageFolderPath, projectPath, StringComparison.InvariantCultureIgnoreCase))
rootFolderPath = JoinPaths(coverageFolderPath, coverageSettings.rootFolderName);
// else user coverageFolderPath as the root folder
else
rootFolderPath = coverageFolderPath;
}
else
{
// Add 'CodeCoverage' directory to projectPath if coverageFolderPath is not valid
rootFolderPath = JoinPaths(projectPath, coverageSettings.rootFolderName);
}
return rootFolderPath;
}
public static string GetHistoryFolderPath(CoverageSettings coverageSettings)
{
string historyFolderPath = string.Empty;
string rootFolderPath = coverageSettings.rootFolderPath;
if (CommandLineManager.instance.batchmode && !CommandLineManager.instance.useProjectSettings)
{
if (coverageSettings.historyPathFromCommandLine.Length > 0)
{
historyFolderPath = coverageSettings.historyPathFromCommandLine;
EnsureFolderExists(historyFolderPath);
}
}
else
{
if (CommandLineManager.instance.runFromCommandLine && coverageSettings.historyPathFromCommandLine.Length > 0)
{
historyFolderPath = coverageSettings.historyPathFromCommandLine;
EnsureFolderExists(historyFolderPath);
}
else
{
historyFolderPath = CoveragePreferences.instance.GetStringForPaths("HistoryPath", string.Empty);
}
}
bool addHistorySubDir = false;
string projectPath = GetProjectPath();
if (EnsureFolderExists(historyFolderPath))
{
historyFolderPath = NormaliseFolderSeparators(historyFolderPath, true);
// If historyFolderPath == rootFolderPath, add 'Report-history' sub directory in rootFolderPath
if (string.Equals(historyFolderPath, rootFolderPath, StringComparison.InvariantCultureIgnoreCase))
{
addHistorySubDir = true;
}
// If historyFolderPath == projectPath, add 'CodeCoverage' directory to projectPath
// and add 'Report-history' sub directory in rootFolderPath
else if (string.Equals(historyFolderPath, projectPath, StringComparison.InvariantCultureIgnoreCase))
{
rootFolderPath = JoinPaths(projectPath, coverageSettings.rootFolderName);
addHistorySubDir = true;
}
// otherwise keep the original historyFolderPath
}
else
{
// If historyFolderPath is not valid, add 'CodeCoverage' directory to projectPath
// and add 'Report-history' sub directory in rootFolderPath
rootFolderPath = JoinPaths(projectPath, coverageSettings.rootFolderName);
addHistorySubDir = true;
}
if (addHistorySubDir)
{
historyFolderPath = JoinPaths(rootFolderPath, CoverageSettings.ReportHistoryFolderName);
}
return historyFolderPath;
}
public static string JoinPaths(string pathLeft, string pathRight)
{
string[] pathsToJoin = new string[] { pathLeft, pathRight };
return string.Join("/", pathsToJoin);
}
public static int GetNumberOfFilesInFolder(string folderPath, string filePattern, SearchOption searchOption)
{
if (folderPath != null && Directory.Exists(folderPath))
{
string[] files = Directory.GetFiles(folderPath, filePattern, searchOption);
return files.Length;
}
return 0;
}
public static void ClearFolderIfExists(string folderPath, string filePattern)
{
if (folderPath != null && Directory.Exists(folderPath))
{
DirectoryInfo dirInfo = new DirectoryInfo(folderPath);
foreach (FileInfo file in dirInfo.GetFiles(filePattern))
{
try
{
file.Delete();
}
catch (Exception)
{
ResultsLogger.Log(ResultID.Warning_FailedToDeleteFile, file.FullName);
}
}
foreach (DirectoryInfo dir in dirInfo.GetDirectories())
{
try
{
dir.Delete(true);
}
catch (Exception)
{
ResultsLogger.Log(ResultID.Warning_FailedToDeleteDir, dir.FullName);
}
}
}
}
public static bool IsValidFolder(string folderPath)
{
return !string.IsNullOrEmpty(folderPath) && Directory.Exists(folderPath);
}
public static bool IsValidFile(string filePath)
{
return !string.IsNullOrEmpty(filePath) && File.Exists(filePath);
}
private static HashSet<char> regexSpecialChars = new HashSet<char>(new[] { '[', '\\', '^', '$', '.', '|', '?', '*', '+', '(', ')' });
public static string GlobToRegex(string glob, bool startEndConstrains = true)
{
var regex = new StringBuilder();
var characterClass = false;
char prevChar = Char.MinValue;
if (startEndConstrains)
regex.Append("^");
foreach (var c in glob)
{
if (characterClass)
{
if (c == ']')
{
characterClass = false;
}
regex.Append(c);
continue;
}
switch (c)
{
case '*':
if (prevChar == '*')
regex.Append(".*"); //if it's double * pattern then don't stop at folder separator
else
regex.Append("[^\\n\\r/]*"); //else match everything except folder separator (and new line)
break;
case '?':
regex.Append("[^\\n\\r/]");
break;
case '[':
characterClass = true;
regex.Append(c);
break;
default:
if (regexSpecialChars.Contains(c))
{
regex.Append('\\');
}
regex.Append(c);
break;
}
prevChar = c;
}
if (startEndConstrains)
regex.Append("$");
return regex.ToString();
}
public static string[] GetFilteringLogParams(AssemblyFiltering assemblyFiltering, PathFiltering pathFiltering, string[] otherParams = null)
{
string[] logParams = { assemblyFiltering != null && assemblyFiltering.includedAssemblies.Length > 0 ? assemblyFiltering.includedAssemblies : "<Not specified>",
assemblyFiltering != null && assemblyFiltering.excludedAssembliesNoDefault.Length > 0 ? assemblyFiltering.excludedAssembliesNoDefault : "<Not specified>",
pathFiltering != null && pathFiltering.includedPaths.Length > 0 ? pathFiltering.includedPaths : "<Not specified>",
pathFiltering != null && pathFiltering.excludedPaths.Length > 0 ? pathFiltering.excludedPaths : "<Not specified>" };
if (otherParams != null && otherParams.Length > 0)
logParams = otherParams.Concat(logParams).ToArray();
return logParams;
}
[ExcludeFromCoverage]
public static string BrowseForDir(string directory, string title)
{
if (string.IsNullOrEmpty(directory))
{
string variable = "ProgramFiles";
#if UNITY_EDITOR_OSX
variable = "HOME";
#endif
string candidateDirectory = Environment.GetEnvironmentVariable(variable);
if (IsValidFolder(candidateDirectory))
directory = candidateDirectory;
}
directory = EditorUtility.OpenFolderPanel(title, directory, string.Empty);
EditorWindow.FocusWindowIfItsOpen(typeof(CodeCoverageWindow));
if (!IsValidFolder(directory))
return string.Empty;
return directory;
}
[ExcludeFromCoverage]
public static string BrowseForFile(string directory, string title)
{
if (string.IsNullOrEmpty(directory))
{
string variable = "ProgramFiles";
#if UNITY_EDITOR_OSX
variable = "HOME";
#endif
string candidateDirectory = Environment.GetEnvironmentVariable(variable);
if (IsValidFolder(candidateDirectory))
directory = candidateDirectory;
}
string file = EditorUtility.OpenFilePanel(title, directory, "cs");
EditorWindow.FocusWindowIfItsOpen(typeof(CodeCoverageWindow));
if (!IsValidFile(file))
return string.Empty;
return file;
}
}
}