public CategoryList(TestCase testCase, IAdapterSettings adapterSettings)
{
settings = adapterSettings;
showInternalProperties = settings.ShowInternalProperties;
this.testCase = testCase;
// MsTestCategoryProperty = TestProperty.Register(MSTestCategoryName, VsTestCategoryLabel, typeof(string[]), TestPropertyAttributes.Hidden | TestPropertyAttributes.Trait, typeof(TestCase));
}
public static void OnPostprocessBuild(BuildTarget buildTarget, string buildPath)
{
if (buildTarget == BuildTarget.iOS)
{
string projectPath = buildPath + "/Unity-iPhone.xcodeproj/project.pbxproj";
string dirpath = Application.dataPath + "/IronSource/Editor/";
string currentNamespace = MethodBase.GetCurrentMethod().DeclaringType.Namespace;
updateProject(buildTarget, projectPath);
if (Directory.Exists(dirpath))
{
//Match the classes that has "Settings" in their name, and don't start with "I"
var files = Directory.GetFiles(dirpath, "*.cs", SearchOption.TopDirectoryOnly).Where(file => Regex.IsMatch(Path.GetFileName(file), "^(?!I).+Settings.*$"));
//Go over all the adapter settings classes, and call their updateProject method
foreach (string file in files)
{
string classname = Path.GetFileNameWithoutExtension(file);
if (!String.IsNullOrEmpty(classname))
{
IAdapterSettings adapter = (IAdapterSettings)Activator.CreateInstance(Type.GetType(currentNamespace + "." + classname));
adapter.updateProject(buildTarget, projectPath);
}
}
}
}
Debug.Log("IronSource build postprocessor finished");
}
public void SetUp()
{
var testLogger = new TestLogger(new MessageLoggerStub());
_settings = new AdapterSettings(testLogger);
testLogger.InitSettings(_settings);
}
public NUnitEventListener(ITestConverterCommon testConverter, INUnit3TestExecutor executor)
{
this.executor = executor;
dumpXml = executor.Dump;
_settings = executor.Settings;
_recorder = executor.FrameworkHandle;
_testConverter = testConverter;
}
public NUnitEventListener(ITestExecutionRecorder recorder, ITestConverter testConverter, INUnit3TestExecutor executor)
{
this.executor = executor;
dumpXml = executor.Dump;
_settings = executor.Settings;
_recorder = recorder;
_testConverter = testConverter;
}
public virtual void before_each()
{
autoSubstitute = new AutoSubstitute();
messageLogger = autoSubstitute.Resolve <IMessageLogger>();
settings = autoSubstitute.Resolve <IAdapterSettings>();
}
public void Setup()
{
recorder = Substitute.For <IFrameworkHandle>();
converter = Substitute.For <ITestConverterCommon>();
settings = Substitute.For <IAdapterSettings>();
executor = Substitute.For <INUnit3TestExecutor>();
executor.Settings.Returns(settings);
executor.FrameworkHandle.Returns(recorder);
}
public void Setup()
{
recorder = Substitute.For <ITestExecutionRecorder>();
converter = Substitute.For <ITestConverter>();
dumpxml = Substitute.For <IDumpXml>();
settings = Substitute.For <IAdapterSettings>();
executor = Substitute.For <INUnit3TestExecutor>();
executor.Settings.Returns(settings);
}
public TimingLogger(IAdapterSettings settings, ITestLogger logger)
{
this.settings = settings;
this.logger = logger;
if (settings.Verbosity < 5)
{
return;
}
Stopwatch = Stopwatch.StartNew();
}
public static VsTestFilter CreateVsTestFilter(IAdapterSettings settings, IRunContext context)
{
if (settings.DiscoveryMethod == DiscoveryMethod.Legacy)
{
return(new VsTestFilterLegacy(context));
}
if (settings.DesignMode)
{
return(new VsTestFilterIde(context));
}
return(new VsTestFilterNonIde(context));
}
public TestConverterForXml(ITestLogger logger, string sourceAssembly, IAdapterSettings settings)
{
adapterSettings = settings;
_logger = logger;
_sourceAssembly = sourceAssembly;
_vsTestCaseMap = new Dictionary <string, TestCase>();
TraitsCache = new Dictionary <string, TraitsFeature.CachedTestCaseInfo>();
if (CollectSourceInformation)
{
_navigationDataProvider = new NavigationDataProvider(sourceAssembly, logger);
}
}
public void SetUp()
{
testLog = new FakeFrameworkHandle();
settings = Substitute.For <IAdapterSettings>();
executor = Substitute.For <INUnit3TestExecutor>();
executor.Settings.Returns(settings);
executor.FrameworkHandle.Returns(testLog);
settings.CollectSourceInformation.Returns(true);
using var testConverter = new TestConverterForXml(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, settings);
fakeTestNode = new NUnitEventTestCase(FakeTestData.GetTestNode());
// Ensure that the converted testcase is cached
testConverter.ConvertTestCase(fakeTestNode);
Assert.That(testConverter.GetCachedTestCase("123"), Is.Not.Null);
listener = new NUnitEventListener(testConverter, executor);
}
public OutputLogger(IMessageLogger messageLogger, IAdapterInfo adapterInfo, IAdapterSettings settings)
{
this.MessageLogger = messageLogger;
adapterPrefix = String.Format("{0} {1}", adapterInfo.Name, adapterInfo.Version);
var settingsToLogLevelMap = new Dictionary <string, int>()
{
{ "trace", traceLogLevel },
{ "debug", debugLogLevel },
{ "info", infoLogLevel },
{ "warning", warningLogLevel },
{ "error", errorLogLevel },
};
const string defaultSetting = "info";
string textLogLevel = (settings.LogLevel != null ? settings.LogLevel.ToLower() : defaultSetting);
minLogLevel = settingsToLogLevelMap.ContainsKey(textLogLevel) ?
settingsToLogLevelMap[textLogLevel] :
settingsToLogLevelMap[defaultSetting];
}
public static IDumpXml CreateDump(string path, IGrouping <string, TestCase> testCases, IAdapterSettings settings)
{
if (!settings.DumpXmlTestResults)
{
return(null);
}
var executionDumpXml = new DumpXml(path);
string runningBy = testCases == null
? "<RunningBy>Sources</RunningBy>"
: "<RunningBy>TestCases</RunningBy>";
executionDumpXml.AddString($"\n{runningBy}\n");
return(executionDumpXml);
}
public void InitializeSettingsAndLogging(IAdapterSettings setting, ITestLogger testLog)
{
logger = testLog;
settings = setting;
}
public IList <TestCase> Convert(NUnitResults discoveryResults, ITestLogger logger, string assemblyPath, IAdapterSettings settings)
{
var nunitTestCases = discoveryResults.TestCases();
TestConverter = new TestConverter(logger, assemblyPath, settings);
var loadedTestCases = new List <TestCase>();
// As a side effect of calling TestConverter.ConvertTestCase,
// the converter's cache of all test cases is populated as well.
// All future calls to convert a test case may now use the cache.
foreach (XmlNode testNode in nunitTestCases)
{
loadedTestCases.Add(TestConverter.ConvertTestCase(new NUnitTestCase(testNode)));
}
logger.Info($" NUnit3TestExecutor discovered {loadedTestCases.Count} of {nunitTestCases.Count} NUnit test cases");
return(loadedTestCases);
}
public IOutputLogger CreateOutput(IMessageLogger messageLogger, IAdapterSettings settings)
{
return(new OutputLogger(messageLogger, adapterInfo, settings));
}
public DiscoveryConverter(ITestLogger logger, IAdapterSettings settings)
{
Settings = settings;
TestLog = logger;
}
public TestLogger InitSettings(IAdapterSettings settings)
{
adapterSettings = settings;
Verbosity = adapterSettings.Verbosity;
return(this);
}
public static void AddTraitsFromTestNode(this TestCase testCase, NUnitTestCase testNCase,
IDictionary <string, CachedTestCaseInfo> traitsCache, ITestLogger logger, IAdapterSettings adapterSettings)
{
var ancestor = testNCase.Parent;
var key = ancestor?.Id;
var categoryList = new CategoryList(testCase, adapterSettings);
// Reading ancestor properties of a test-case node. And adding to the cache.
while (ancestor != null && key != null)
{
if (traitsCache.ContainsKey(key))
{
categoryList.AddRange(traitsCache[key].Traits.Where(o => o.Name == NunitTestCategoryLabel).Select(prop => prop.Value).ToList());
if (traitsCache[key].Explicit)
{
testCase.SetPropertyValue(CategoryList.NUnitExplicitProperty, true);
}
var traitsList = traitsCache[key].Traits.Where(o => o.Name != NunitTestCategoryLabel).ToList();
if (traitsList.Count > 0)
{
testCase.Traits.AddRange(traitsList);
}
}
else
{
categoryList.ProcessTestCaseProperties(ancestor, true, key, traitsCache);
// Adding entry to dictionary, so that we will not make SelectNodes call again.
if (categoryList.LastNodeListCount == 0 && !traitsCache.ContainsKey(key))
{
traitsCache[key] = new CachedTestCaseInfo();
}
}
ancestor = ancestor.Parent;
key = ancestor?.Id;
}
// No Need to store test-case properties in cache.
categoryList.ProcessTestCaseProperties(testNCase, false);
categoryList.UpdateCategoriesToVs();
}
public void Setup()
{
settings = Substitute.For <IAdapterSettings>();
settings.DiscoveryMethod.Returns(DiscoveryMethod.Legacy);
}
public static VsTestFilter CreateVsTestFilter(IAdapterSettings settings, IRunContext context) =>
settings.DiscoveryMethod == DiscoveryMethod.Legacy
? new VsTestFilterLegacy(context) :
settings.DesignMode
? new VsTestFilterIde(context)
: new VsTestFilterNonIde(context);
public static void AddTraitsFromTestNode(this TestCase testCase, NUnitDiscoveryTestCase testNCase,
IDictionary <string, CachedTestCaseInfo> traitsCache, ITestLogger logger, IAdapterSettings adapterSettings)
{
var ancestor = testNCase.Parent;
var key = ancestor?.Id;
var categoryList = new CategoryList(testCase, adapterSettings);
// Reading ancestor properties of a test-case node. And adding to the cache.
while (ancestor != null && !string.IsNullOrEmpty(key))
{
AddingToCache(testCase, traitsCache, key, categoryList, ancestor, categoryList.ProcessTestCaseProperties);
ancestor = ancestor.Parent;
key = ancestor?.Id;
}
// No Need to store test-case properties in cache.
categoryList.ProcessTestCaseProperties(testNCase, false);
categoryList.UpdateCategoriesToVs();
}
public NUnitTestFilterBuilder(ITestFilterService filterService, IAdapterSettings settings)
{
this.settings = settings;
_filterService = filterService ?? throw new NUnitEngineException("TestFilterService is not available. Engine in use is incorrect version.");
}