public override List <string> GetColumns(string tableName)
{
// Somewhat heavy, this could be improved, right now I simply
// read the table in then check the columns...
try
{
DataTable table = this.ReadTable(tableName, null);
if (table != null)
{
List <string> columnNames = new List <string>();
foreach (DataColumn column in table.Columns)
{
columnNames.Add(column.ColumnName);
}
return(columnNames);
}
}
catch (Exception exception)
{
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, exception.Message + " for CSV data source " + this.fileName);
}
return(null);
}
/// <summary>
/// Sets context required for running tests.
/// </summary>
/// <param name="source">
/// source parameter used for setting context
/// </param>
private void SetContext(string source)
{
if (string.IsNullOrEmpty(source))
{
return;
}
Exception setWorkingDirectoryException = null;
this.currentDirectory = Environment.CurrentDirectory;
try
{
Environment.CurrentDirectory = Path.GetDirectoryName(source);
EqtTrace.InfoIf(EqtTrace.IsInfoEnabled, "MSTestExecutor: Changed the working directory to {0}", Environment.CurrentDirectory);
}
catch (IOException ex)
{
setWorkingDirectoryException = ex;
}
catch (System.Security.SecurityException ex)
{
setWorkingDirectoryException = ex;
}
if (setWorkingDirectoryException != null)
{
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, "MSTestExecutor.SetWorkingDirectory: Failed to set the working directory to '{0}'. {1}", Path.GetDirectoryName(source), setWorkingDirectoryException);
}
}
private DataSet LoadDataSet(bool schemaOnly)
{
try
{
DataSet dataSet = new DataSet();
dataSet.Locale = CultureInfo.CurrentCulture;
string path = this.FixPath(this.fileName) ?? Path.GetFullPath(this.fileName);
if (schemaOnly)
{
dataSet.ReadXmlSchema(path);
}
else
{
dataSet.ReadXml(path);
}
return(dataSet);
}
catch (SecurityException securityException)
{
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, securityException.Message + " for XML data source " + this.fileName);
}
catch (XmlException xmlException)
{
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, xmlException.Message + " for XML data source " + this.fileName);
}
catch (Exception exception)
{
// Yes, we get other exceptions too!
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, exception.Message + " for XML data source " + this.fileName);
}
return(null);
}
/// <summary>
/// Returns satellite assemblies. Returns full canonicalized paths.
/// If the file is not an assembly returns empty list.
/// </summary>
/// <param name="assemblyPath"> The assembly to get satellites for. </param>
/// <returns> List of satellite assemblies. </returns>
internal virtual List <string> GetSatelliteAssemblies(string assemblyPath)
{
if (!this.IsAssemblyExtension(Path.GetExtension(assemblyPath)) || !this.IsAssembly(assemblyPath))
{
EqtTrace.ErrorIf(
EqtTrace.IsErrorEnabled,
"AssemblyUtilities.GetSatelliteAssemblies: the specified file '{0}' is not managed assembly.",
assemblyPath);
Debug.Fail("AssemblyUtilities.GetSatelliteAssemblies: the file '" + assemblyPath + "' is not an assembly.");
// If e.g. this is unmanaged dll, we don't care about the satellites.
return(new List <string>());
}
assemblyPath = Path.GetFullPath(assemblyPath);
var assemblyDir = Path.GetDirectoryName(assemblyPath);
var satellites = new List <string>();
// Directory.Exists for 266 dirs takes 9ms while Path.GetDirectories can take up to 80ms on 10k dirs.
foreach (string dir in Cultures.Keys)
{
var dirPath = Path.Combine(assemblyDir, dir);
if (!Directory.Exists(dirPath))
{
continue;
}
// Check if the satellite exists in this dir.
// We check filenames like: MyAssembly.dll -> MyAssembly.resources.dll.
// Suprisingly, but both DLL and EXE are found by resource manager.
foreach (var extension in this.assemblyExtensions)
{
// extension contains leading dot.
string satellite = Path.ChangeExtension(Path.GetFileName(assemblyPath), "resources" + extension);
string satellitePath = Path.Combine(assemblyDir, Path.Combine(dir, satellite));
// We don't use Assembly.LoadFrom/Assembly.GetSatelliteAssebmlies because this is rather slow
// (1620ms for 266 cultures when directories do not exist).
if (File.Exists(satellitePath))
{
// If the satellite found is not a managed assembly we do not report it as a reference.
if (!this.IsAssembly(satellitePath))
{
EqtTrace.ErrorIf(
EqtTrace.IsErrorEnabled,
"AssemblyUtilities.GetSatelliteAssemblies: found assembly '{0}' installed as satellite but it's not managed assembly.",
satellitePath);
continue;
}
// If both .exe and .dll exist we return both silently.
satellites.Add(satellitePath);
}
}
}
return(satellites);
}
/// <summary>
/// Opens the image and reads information about the symbols file, associated
/// to this image.
/// </summary>
/// <param name="imagePath">The full path to executable or DLL.</param>
/// <returns>Full path to corresponding symbols file or null if the image does
/// not contain symbols file information.</returns>
public static string GetSymbolsFileName(string imagePath)
{
Debug.Assert(!string.IsNullOrEmpty(imagePath), "imagePath");
IDiaDataSource source;
try
{
source = (IDiaDataSource) new DiaSourceClass();
}
catch (COMException ex)
{
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, "DIA initialization threw:\n" + ex.ToString());
// Let things go fine if we can find a local file, return
// null if we can't. This is needed to support xcopy deployment.
string pdbFile = Path.ChangeExtension(imagePath, ".pdb");
if (File.Exists(pdbFile))
{
return(pdbFile);
}
return(null);
}
IDiaSession session = null;
IDiaSymbol global = null;
try
{
// Load the image:
source.loadDataForExe(imagePath, null, null);
// Extract the main symbol via session:
source.openSession(out session);
global = session.globalScope;
Debug.Assert(global != null, "globalScope Symbol");
return(global.symbolsFileName);
}
catch (COMException ex)
{
// If exception is thrown the image does not contain symbols or the symbols found
// are not correct.
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, "DIA thew in retrieving symbols: " + ex.ToString());
return(null);
}
finally
{
// Ensure that the resources allocated by DIA get cleaned up.
// In particular, after loadDataForExe, the PDB will be locked
// until CDiaDataSource::~CDiaDataSource is called.
ReleaseComObject(global);
ReleaseComObject(session);
ReleaseComObject(source);
}
}
public virtual void DeleteDirectories(string filePath)
{
Validate.IsFalse(string.IsNullOrWhiteSpace(filePath), "Invalid filePath provided");
try
{
var root = new DirectoryInfo(filePath);
root.Delete(true);
}
catch (Exception ex)
{
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, "DeploymentManager.DeleteDirectories failed for the directory '{0}': {1}", filePath, ex);
}
}
internal virtual void DeleteDirectories(string filePath)
{
Debug.Assert(filePath != null, "filePath");
try
{
var root = new DirectoryInfo(filePath);
root.Delete(true);
}
catch (Exception ex)
{
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, "DeploymentManager.DeleteDirectories failed for the directory '{0}': {1}", filePath, ex);
}
}
private static object SafeInvoke <T>(Func <T> action, string messageFormatOnException = null)
{
try
{
return(action.Invoke());
}
catch (Exception exception)
{
if (string.IsNullOrEmpty(messageFormatOnException))
{
messageFormatOnException = "{0}";
}
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, messageFormatOnException, exception.Message);
}
return(null);
}
/// <summary>
/// Log an error in a given format.
/// </summary>
/// <param name="format"> The format. </param>
/// <param name="args"> The args. </param>
public void LogError(string format, params object[] args)
{
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, format, args);
}
/// <summary>
/// Run a data driven test. Test case is executed once for each data row.
/// </summary>
/// <param name="testContext">
/// The test Context.
/// </param>
/// <param name="testMethodInfo">
/// The test Method Info.
/// </param>
/// <param name="testMethod">
/// The test Method.
/// </param>
/// <param name="executor">
/// The default test method executor.
/// </param>
/// <returns>
/// The results after running all the data driven tests.
/// </returns>
public UTF.TestResult[] RunDataDrivenTest(UTF.TestContext testContext, UTF.ITestMethod testMethodInfo, ITestMethod testMethod, UTF.TestMethodAttribute executor)
{
Stopwatch watch = new Stopwatch();
watch.Start();
// Figure out where (as well as the current directory) we could look for data files
// for unit tests this means looking at the the location of the test itself
List <string> dataFolders = new List <string>();
dataFolders.Add(Path.GetDirectoryName(new Uri(testMethodInfo.MethodInfo.Module.Assembly.CodeBase).LocalPath));
List <UTF.TestResult> dataRowResults = new List <UTF.TestResult>();
// Connect to data source.
TestDataConnectionFactory factory = new TestDataConnectionFactory();
string providerNameInvariant;
string connectionString;
string tableName;
UTF.DataAccessMethod dataAccessMethod;
try
{
this.GetConnectionProperties(testMethodInfo.GetAttributes <UTF.DataSourceAttribute>(false)[0], out providerNameInvariant, out connectionString, out tableName, out dataAccessMethod);
}
catch (Exception ex)
{
watch.Stop();
var result = new UTF.TestResult();
result.Outcome = UTF.UnitTestOutcome.Failed;
result.TestFailureException = ex;
result.Duration = watch.Elapsed;
return(new UTF.TestResult[] { result });
}
try
{
using (TestDataConnection connection = factory.Create(providerNameInvariant, connectionString, dataFolders))
{
DataTable table = connection.ReadTable(tableName, null);
DataRow[] rows = table.Select();
Debug.Assert(rows != null, "rows should not be null.");
if (rows.Length == 0)
{
watch.Stop();
var inconclusiveResult = new UTF.TestResult();
inconclusiveResult.Outcome = UTF.UnitTestOutcome.Inconclusive;
inconclusiveResult.Duration = watch.Elapsed;
return(new UTF.TestResult[] { inconclusiveResult });
}
IEnumerable <int> permutation = this.GetPermutation(dataAccessMethod, rows.Length);
TestContextImplementation testContextImpl = testContext as TestContextImplementation;
try
{
testContextImpl.SetDataConnection(connection.Connection);
// For each data row...
foreach (int rowIndex in permutation)
{
watch.Reset();
watch.Start();
testContextImpl.SetDataRow(rows[rowIndex]);
UTF.TestResult[] currentResult = new UTF.TestResult[1];
try
{
currentResult = executor.Execute(testMethodInfo);
}
catch (Exception ex)
{
currentResult[0].Outcome = UTF.UnitTestOutcome.Failed;
// Trace whole exception but do not show call stack to the user, only show message.
EqtTrace.ErrorIf(EqtTrace.IsErrorEnabled, "Unit Test Adapter threw exception: {0}", ex);
}
currentResult[0].DatarowIndex = rowIndex;
watch.Stop();
currentResult[0].Duration = watch.Elapsed;
Debug.Assert(currentResult[0] != null, "current result should not be null.");
dataRowResults.Add(currentResult[0]);
// Clear the testContext's internal string writer to start afresh for the next datarow iteration
testContextImpl.ClearMessages();
}
}
finally
{
testContextImpl.SetDataConnection(null);
testContextImpl.SetDataRow(null);
}
}
}
catch (Exception ex)
{
string message = ExceptionExtensions.GetExceptionMessage(ex);
UTF.TestResult failedResult = new UTF.TestResult();
failedResult.Outcome = UTF.UnitTestOutcome.Error;
failedResult.TestFailureException = new Exception(string.Format(CultureInfo.CurrentCulture, Resource.UTA_ErrorDataConnectionFailed, ex.Message), ex);
return(new UTF.TestResult[] { failedResult });
}
return(dataRowResults.ToArray());
}
