private void ReadAssemblyResolutionPath(XmlReader reader)
{
ValidateArg.NotNull <XmlReader>(reader, "reader");
// Expected format of the xml is: -
//
// <AssemblyResolution>
// <Directory path= "% HOMEDRIVE %\direvtory "includeSubDirectories = "true" />
// <Directory path= "C:\windows" includeSubDirectories = "false" />
// <Directory path= ".\DirectoryName" /> ...// by default includeSubDirectories is false
// </AssemblyResolution>
bool empty = reader.IsEmptyElement;
reader.Read();
if (!empty)
{
while (reader.NodeType == XmlNodeType.Element)
{
if (string.Compare("Directory", reader.Name, StringComparison.OrdinalIgnoreCase) == 0)
{
string recursiveAttribute = reader.GetAttribute("includeSubDirectories");
// read the path specified
string path = reader.GetAttribute("path");
if (!string.IsNullOrEmpty(path))
{
// Do we have to look in sub directory for dependent dll.
var includeSubDirectories = string.Compare(recursiveAttribute, "true", StringComparison.OrdinalIgnoreCase) == 0;
this.SearchDirectories.Add(new RecursiveDirectoryPath(path, includeSubDirectories));
}
}
else
{
string message = string.Format(CultureInfo.CurrentCulture, Resource.InvalidSettingsXmlElement, reader.Name, "AssemblyResolution");
throw new SettingsException(message);
}
// Move to the next element under tag AssemblyResolution
reader.Read();
}
}
// go to the end of the element.
reader.ReadEndElement();
}
/// <summary>
/// Sends the event to all data collectors and fires a callback on the sender, letting it
/// know when all plugins have completed processing the event
/// </summary>
/// <param name="args">The context information for the event</param>
private void SendEvent(DataCollectionEventArgs args)
{
ValidateArg.NotNull(args, nameof(args));
if (!this.isDataCollectionEnabled)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("DataCollectionManger:SendEvent: SendEvent called when no collection is enabled.");
}
return;
}
// do not send events multiple times
this.events.RaiseEvent(args);
}
/// <summary>
/// Initializes a new instance of the <see cref="GenericAmmo"/> class.
/// </summary>
/// <param name="defName"> Def Name. </param>
/// <param name="description"> Description for this def. </param>
/// <param name="label"> Label to display. </param>
/// <param name="thingClass"> Type of Thing that this def defines. </param>
/// <param name="ammoDefs"> A list of ammo defs. </param>
public GenericAmmo(string defName, string description, string label, Type thingClass, IEnumerable <AmmoDef> ammoDefs)
: base(defName, description, label, thingClass, ammoDefs.SelectMany(t => t.thingCategories).Distinct(), null)
{
ValidateArg.NotNull(ammoDefs, nameof(ammoDefs));
this.statBases = new List <StatModifier>()
{
new StatModifier()
{
stat = StatDefOf.Mass, value = ammoDefs.Average(t => t.GetStatValueAbstract(StatDefOf.Mass)),
},
new StatModifier()
{
stat = CE_StatDefOf.Bulk, value = ammoDefs.Average(t => t.GetStatValueAbstract(CE_StatDefOf.Bulk)),
},
};
}
private void OnTestCaseEnd(object sender, TestCaseEndEventArgs e)
{
ValidateArg.NotNull(e, "TestCaseEndEventArgs");
Debug.Assert(e.Context != null, "Context is null");
Debug.Assert(e.Context.HasTestCase, "Context is not for a test case");
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose(
"EventLogDataCollector: TestCaseEnd received for test '{0}' with Test Outcome: {1}.",
e.TestCaseName,
e.TestOutcome);
}
this.WriteCollectedEventLogEntries(e.Context, false, TimeSpan.MaxValue, DateTime.Now);
}
/// <summary>
/// Match test case with filter criteria.
/// </summary>
public bool MatchTestCase(TestCase testCase, Func <string, Object> propertyValueProvider)
{
ValidateArg.NotNull(testCase, "testCase");
ValidateArg.NotNull(propertyValueProvider, "propertyValueProvider");
if (!this.validForMatch)
{
return(false);
}
if (null == this.filterWrapper)
{
// can be null when parsing error occurs. Invalid filter results in no match.
return(false);
}
return(this.filterWrapper.Evaluate(propertyValueProvider));
}
/// <summary>
/// Initializes a new instance of the <see cref="ThingGroupSelector"/> class.
/// </summary>
/// <param name="other"> Copy <paramref name="other"/> to this selector. </param>
public ThingGroupSelector(ThingGroupSelector other)
{
ValidateArg.NotNull(other, nameof(other));
this.GroupID = LoadoutManager.ThingGroupSelectorID;
this.AllowedStackCount = other.AllowedStackCount;
this.AllowedThing = other.AllowedThing;
_bottomThresholdCount = other._bottomThresholdCount;
_useBottomThreshold = other._useBottomThreshold;
foreach (ThingSelector thingSelector in other._selectors)
{
Type selectorType = thingSelector.GetType();
ThingSelector newSelector = (ThingSelector)Activator.CreateInstance(selectorType, new object[] { thingSelector });
this.Add(newSelector);
}
}
/// <summary>
/// Registers to receive events from the provided test run request.
/// These events will then be broadcast to any registered loggers.
/// </summary>
/// <param name="testRunRequest">The run request to register for events on.</param>
public void RegisterTestRunEvents(ITestRunRequest testRunRequest)
{
ValidateArg.NotNull <ITestRunRequest>(testRunRequest, "testRunRequest");
this.CheckDisposed();
// Keep track of the run requests so we can unregister for the
// events when disposed.
this.runRequest = testRunRequest;
// Redirect the events to the InternalTestLoggerEvents
testRunRequest.TestRunMessage += this.TestRunMessageHandler;
testRunRequest.OnRunStart += this.TestRunStartHandler;
testRunRequest.OnRunStatsChange += this.TestRunStatsChangedHandler;
testRunRequest.OnRunCompletion += this.TestRunCompleteHandler;
testRunRequest.DataCollectionMessage += this.DataCollectionMessageHandler;
}
/// <summary>
/// Returns whether the parameter project is a test project or not.
/// </summary>
public static bool IsTestProject(this IVsProject project, Guid projectGuid)
{
// Overload IsTestProject method to check if we should use this test adapter
// at all. This is much less error prone than adding this check to all locations
// where this method is called.
if (!IsTestAdapaterEnabled())
{
return(false);
}
ValidateArg.NotNull(project, "project");
var projectTypeGuids = project.GetAggregateProjectTypeGuids();
// Currently we assume that all matching projects are test projects.
return(projectTypeGuids.IndexOf(projectGuid.ToString(), StringComparison.OrdinalIgnoreCase) >= 0);
}
/// <summary>
/// Initializes a new instance of the <see cref="AwesomeInventoryLoadout"/> class.
/// </summary>
/// <param name="pawn"> Initialize <see cref="AwesomeInventoryLoadout"/> with items on this <paramref name="pawn"/>. </param>
public AwesomeInventoryLoadout(Pawn pawn)
{
ValidateArg.NotNull(pawn, nameof(pawn));
this.AddItems(pawn.equipment?.AllEquipmentListForReading);
this.AddItems(pawn.apparel?.WornApparel);
this.AddItems(pawn.inventory?.innerContainer);
this.uniqueId = Current.Game.outfitDatabase.AllOutfits.Max(o => o.uniqueId) + 1;
CompAwesomeInventoryLoadout compLoadout = pawn.TryGetComp <CompAwesomeInventoryLoadout>();
this.label = compLoadout?.Loadout == null
? AwesomeInventoryLoadout.GetDefaultLoadoutName(pawn)
: LoadoutManager.GetIncrementalLabel(compLoadout.Loadout.label);
pawn.SetLoadout(this);
}
/// <inheritdoc />
public override void Update(StatEntryModel model)
{
ValidateArg.NotNull(model, nameof(model));
if (model == _lastModel)
{
return;
}
if (model.StatDef == _lastModel.StatDef && model.Selected == _lastModel.Selected)
{
return;
}
_lastModel = new StatEntryModel(model);
this.NeedBuild = true;
}
/// <summary>
/// Add pickup option to context menu when right-click on items on map.
/// </summary>
/// <param name="clickPos"> Position of the mouse when right-click. </param>
/// <param name="pawn"> Currently focused pawn. </param>
/// <param name="opts"> Options displayed in context menu. </param>
public static void Postfix(Vector3 clickPos, Pawn pawn, List <FloatMenuOption> opts)
{
ValidateArg.NotNull(pawn, nameof(pawn));
ValidateArg.NotNull(opts, nameof(opts));
if (pawn.IsQuestLodger())
{
return;
}
IntVec3 position = IntVec3.FromVector3(clickPos);
List <Thing> items = position.GetThingList(pawn.Map);
if (!PickUpAndHaulUtility.IsActive)
{
foreach (Thing item in items)
{
if (item.def.category == ThingCategory.Item)
{
int count = MassUtility.CountToPickUpUntilOverEncumbered(pawn, item);
if (count == 0)
{
continue;
}
count = Math.Min(count, item.stackCount);
string displayText = UIText.Pickup.Translate(item.LabelNoCount + " x" + count);
var option = FloatMenuUtility.DecoratePrioritizedTask(
new FloatMenuOption(
displayText
, () =>
{
Job job = JobMaker.MakeJob(JobDefOf.TakeInventory, item);
job.count = count;
job.checkEncumbrance = true;
pawn.jobs.TryTakeOrderedJob(job);
})
, pawn
, item);
opts.Add(option);
}
}
}
}
/// <summary>
/// Runs only the tests specified by parameter 'tests'.
/// </summary>
/// <param name="tests">Tests to be run.</param>
/// <param name="runContext">Context to use when executing the tests.</param>
/// <param name="frameworkHandle">Handle to the framework to record results and to do framework operations.</param>
public void RunTests(IEnumerable <TestCase> tests, IRunContext runContext, IFrameworkHandle frameworkHandle)
{
ValidateArg.NotNull(tests, nameof(tests));
ValidateArg.NotNull(frameworkHandle, nameof(frameworkHandle));
ICollection <Guid> runningTests = tests.Select(t => t.Id).ToList();
if (!Client.Connected)
{
Client.Start();
}
List <string> sources = tests.Select(t => t.Source).ToList();
sources.ForEach((source) => { bool result = Client.CheckAssemblyHash(source, out _, out _); });
Client.DiscoverTests(sources);
this.RunTestsInternal(runningTests, frameworkHandle);
}
/// <summary>
/// Creates singleton instance of DataCollectionRequestHandler.
/// </summary>
/// <param name="communicationManager">
/// Handles socket communication.
/// </param>
/// <param name="messageSink">
/// Message sink for sending messages to execution process.
/// </param>
/// <returns>
/// The instance of <see cref="DataCollectionRequestHandler"/>.
/// </returns>
public static DataCollectionRequestHandler Create(ICommunicationManager communicationManager, IMessageSink messageSink)
{
if (Instance == null)
{
ValidateArg.NotNull(communicationManager, nameof(communicationManager));
ValidateArg.NotNull(messageSink, nameof(messageSink));
lock (syncObject)
{
if (Instance == null)
{
Instance = new DataCollectionRequestHandler(communicationManager, messageSink, DataCollectionManager.Create(messageSink), new DataCollectionTestCaseEventHandler());
}
}
}
return(Instance);
}
/// <summary>
/// This is the equivalent of "RunAll" functionality
/// </summary>
/// <param name="sources">Refers to the list of test sources passed to the test adapter from the client. (Client could be VS or command line)</param>
public void RunTests(IEnumerable <string> sources, ITestDiscoverer discoverer)
{
ValidateArg.NotNull(sources, nameof(sources));
ValidateArg.NotNull(discoverer, nameof(discoverer));
this.cancelRequested.Reset();
var receiver = new TestReceiver();
discoverer.DiscoverTests(sources, this.runContext, this.frameworkHandle, receiver);
if (this.cancelRequested.WaitOne(0))
{
return;
}
this.RunTests(receiver.Tests);
}
private void OnTestCaseStart(object sender, TestCaseStartEventArgs e)
{
ValidateArg.NotNull(e, "TestCaseStartEventArgs");
ValidateArg.NotNull(e.Context, "TestCaseStartEventArgs.Context");
if (!e.Context.HasTestCase)
{
Debug.Fail("Context is not for a test case");
throw new ArgumentNullException("TestCaseStartEventArgs.Context.HasTestCase");
}
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose("EventLogDataCollector: TestCaseStart received for test '{0}'.", e.TestCaseName);
}
this.StartCollectionForContext(e.Context, false);
}
/// <summary>
/// This is the equivalent of "Run Selected Tests" functionality.
/// </summary>
/// <param name="tests">The list of TestCases selected to run</param>
public void RunTests(IEnumerable <TestCase> tests)
{
ValidateArg.NotNull(tests, nameof(tests));
this.cancelRequested.Reset();
var testFramework = tests.First().GetPropertyValue(JavaScriptTestCaseProperties.TestFramework, defaultValue: TestFrameworkDirectories.ExportRunnerFrameworkName);
if (string.Equals(testFramework, TestFrameworkDirectories.AngularFrameworkName, StringComparison.OrdinalIgnoreCase))
{
// Every angular run initializes karma, browser, caching, etc,
// so is preferable to let the test adapter handle any optimization.
RunAllTests(tests);
}
else
{
RunTestsByFile(tests);
}
}
public static IXPathNavigable Import(string settingsFile, IXPathNavigable defaultRunSettings, Architecture architecture, FrameworkVersion frameworkVersion)
{
ValidateArg.NotNull(settingsFile, "settingsFile");
ValidateArg.NotNull(defaultRunSettings, "defaultRunSettings");
if (IsLegacyTestSettingsFile(settingsFile) == false)
{
throw new XmlException(string.Format(CultureInfo.CurrentCulture, UtilitiesResources.UnExpectedSettingsFile));
}
var navigator = defaultRunSettings.CreateNavigator();
if (!navigator.MoveToChild(Constants.RunSettingsName, string.Empty))
{
throw new XmlException(UtilitiesResources.NoRunSettingsNodeFound);
}
var settingsNode = GenerateMSTestXml(settingsFile);
settingsNode.MoveToRoot();
navigator.PrependChild(settingsNode);
// Adding RunConfig
if (!navigator.MoveToChild(Constants.RunConfigurationSettingsName, string.Empty))
{
var doc = new XmlDocument();
var runConfigurationNode = doc.CreateElement(Constants.RunConfigurationSettingsName);
var targetPlatformNode = doc.CreateElement("TargetPlatform");
targetPlatformNode.InnerXml = architecture.ToString();
runConfigurationNode.AppendChild(targetPlatformNode);
var targetFrameworkVersionNode = doc.CreateElement("TargetFrameworkVersion");
targetFrameworkVersionNode.InnerXml = frameworkVersion.ToString();
runConfigurationNode.AppendChild(targetFrameworkVersionNode);
var runConfigNodeNavigator = runConfigurationNode.CreateNavigator();
runConfigNodeNavigator.MoveToRoot();
navigator.PrependChild(runConfigNodeNavigator);
}
navigator.MoveToRoot();
return(navigator);
}
/// <summary>
/// Called when a test result is received.
/// </summary>
private void TestResultHandler(object sender, TestResultEventArgs e)
{
ValidateArg.NotNull <object>(sender, "sender");
ValidateArg.NotNull <TestResultEventArgs>(e, "e");
// Update the test count statistics based on the result of the test.
this.testsTotal++;
string name = null;
name = !string.IsNullOrEmpty(e.Result.DisplayName) ? e.Result.DisplayName : e.Result.TestCase.FullyQualifiedName;
if (e.Result.Outcome == TestOutcome.Skipped)
{
this.testsSkipped++;
string output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.SkippedTestIndicator, name);
Output.WriteLine(output, OutputLevel.Information);
DisplayFullInformation(e.Result);
}
else if (e.Result.Outcome == TestOutcome.Failed)
{
this.testOutcome = TestOutcome.Failed;
this.testsFailed++;
string output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.FailedTestIndicator, name);
Output.WriteLine(output, OutputLevel.Information);
DisplayFullInformation(e.Result);
}
else if (e.Result.Outcome == TestOutcome.Passed)
{
if (!this.verbosityLevel.Equals(Verbosity.Minimal))
{
string output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.PassedTestIndicator, name);
Output.WriteLine(output, OutputLevel.Information);
}
this.testsPassed++;
}
else
{
string output = string.Format(CultureInfo.CurrentCulture, CommandLineResources.NotRunTestIndicator, name);
Output.WriteLine(output, OutputLevel.Information);
DisplayFullInformation(e.Result);
}
}
/// <inheritdoc />
public override Rect Draw(StatPanelModel model, Vector2 position)
{
ValidateArg.NotNull(model, nameof(model));
_title.Draw(model, position);
Rect outRect = new Rect(_statList.Offset + position, new Vector2(this.Size.x, _statList.Size.y + GenUI.ScrollBarWidth));
Rect viewRect = new Rect(_statList.Offset + position, _statList.Size);
Widgets.ScrollHorizontal(outRect, ref _listScrollPos, viewRect);
Widgets.BeginScrollView(outRect, ref _listScrollPos, viewRect);
_statList.Draw(model.StatCacheKeys.Keys, position);
Widgets.EndScrollView();
_statButton.Draw(model, position);
return(new Rect(position, this.Size));
}
public void RemoveWatch(string path)
{
ValidateArg.NotNull(path, "path");
if (!String.IsNullOrEmpty(path))
{
FileSystemWatcher watcher;
if (_fileWatchers.TryGetValue(path, out watcher))
{
watcher.EnableRaisingEvents = false;
_fileWatchers.Remove(path);
watcher.Changed -= OnChanged;
watcher.Dispose();
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Dialog_ManageLoadouts"/> class.
/// </summary>
/// <param name="loadout"> Selected loadout. </param>
/// <param name="pawn"> Selected pawn. </param>
public Dialog_ManageLoadouts(AwesomeInventoryLoadout loadout, Pawn pawn)
{
ValidateArg.NotNull(loadout, nameof(loadout));
_pawn = pawn ?? throw new ArgumentNullException(nameof(pawn));
float width = GenUI.GetWidthCached(UIText.TenCharsString.Times(11));
_initialSize = new Vector2(width, Verse.UI.screenHeight / 2f);
_currentLoadout = loadout;
_resettables.Add(this);
_resettables.Add(new WhiteBlacklistView());
doCloseX = true;
forcePause = true;
absorbInputAroundWindow = false;
closeOnClickedOutside = false;
closeOnAccept = false;
}
public void RunTests(IEnumerable <string> sources, IRunContext runContext, IFrameworkHandle frameworkHandle)
{
ValidateArg.NotNull(sources, "sources");
ValidateArg.NotNull(runContext, "runContext");
ValidateArg.NotNull(frameworkHandle, "frameworkHandle");
_cancelRequested.Reset();
var receiver = new TestReceiver();
TestDiscoverer.DiscoverTests(sources, frameworkHandle, receiver, runContext.RunSettings);
if (_cancelRequested.WaitOne(0))
{
return;
}
RunTestCases(receiver.Tests, runContext, frameworkHandle);
}
public TestContainerDiscoverer(IServiceProvider serviceProvider,
SolutionEventsListener solutionListener,
IOperationState operationState)
{
ValidateArg.NotNull(serviceProvider, "serviceProvider");
ValidateArg.NotNull(solutionListener, "solutionListener");
ValidateArg.NotNull(operationState, "operationState");
_projectInfo = new Dictionary <PythonProject, ProjectInfo>();
_serviceProvider = serviceProvider;
_solutionListener = solutionListener;
_solutionListener.ProjectLoaded += OnProjectLoaded;
_solutionListener.ProjectUnloading += OnProjectUnloaded;
_solutionListener.ProjectClosing += OnProjectUnloaded;
_firstLoad = true;
}
/// <summary>
/// Updates with code coverage settings if not configured.
/// </summary>
/// <param name="runSettingsDocument"> The run settings document. </param>
public static void UpdateWithCodeCoverageSettingsIfNotConfigured(IXPathNavigable runSettingsDocument)
{
ValidateArg.NotNull <IXPathNavigable>(runSettingsDocument, "runSettingsDocument");
var runSettingsNavigator = runSettingsDocument.CreateNavigator();
bool codeCoverageConfigured = XmlRunSettingsUtilities.ContainsDataCollector(runSettingsNavigator, DynamicCodeCoverageDataDiagnosticAdaterUriString) ||
XmlRunSettingsUtilities.ContainsDataCollector(runSettingsNavigator, StaticCodeCoverageDataDiagnosticAdaterUriString);
if (codeCoverageConfigured == false)
{
var existingPath = string.Empty;
var xpaths = new string[]
{
string.Join(xPathSeperator, nodeNames, 0, 1),
string.Join(xPathSeperator, nodeNames, 0, 2),
string.Join(xPathSeperator, nodeNames, 0, 3)
};
foreach (var xpath in xpaths)
{
if (runSettingsNavigator.SelectSingleNode(xpath) != null)
{
existingPath = xpath;
}
else
{
break;
}
}
// If any nodes are missing to add code coverage deafult settings, add the missing xml nodes.
XPathNavigator dataCollectorsNavigator;
if (existingPath.Equals(xpaths[2]) == false)
{
dataCollectorsNavigator = runSettingsNavigator.SelectSingleNode(existingPath);
var missingNodesText = GetMissingNodesTextIfAny(existingPath, xpaths[2]);
dataCollectorsNavigator.AppendChild(missingNodesText);
}
dataCollectorsNavigator = runSettingsNavigator.SelectSingleNode(xpaths[2]);
dataCollectorsNavigator.AppendChild(codeCoverageCollectorSettingsTemplate);
}
}
public static void Postfix(bool value, Pawn_DraftController __instance)
{
ValidateArg.NotNull(__instance, nameof(__instance));
if (!value)
{
CompAwesomeInventoryLoadout comp = __instance.pawn.TryGetComp <CompAwesomeInventoryLoadout>();
if (comp != null && comp.HotswapState != CompAwesomeInventoryLoadout.HotSwapState.Inactive && comp.HotSwapCostume != null && comp.Loadout == comp.HotSwapCostume)
{
if (comp.LoadoutBeforeHotSwap != null && comp.LoadoutBeforeHotSwap != comp.HotSwapCostume)
{
ApparelOptionUtility.StopDressingJobs(__instance.pawn);
__instance.pawn.SetLoadout(comp.LoadoutBeforeHotSwap);
comp.LoadoutBeforeHotSwap = null;
comp.HotswapState = CompAwesomeInventoryLoadout.HotSwapState.Inactive;
}
}
}
}
/// <summary>
/// Stop an unload job.
/// </summary>
/// <param name="pawn"> Looks for unload jobs on this pawn. </param>
/// <param name="thing"> Thing that is assigned to an unload job. </param>
/// <remarks> Safe to call if thing is null or thing is not assigned an unload job. </remarks>
public static void StopJob(Pawn pawn, Thing thing)
{
ValidateArg.NotNull(pawn, nameof(pawn));
if (pawn.CurJob.def == AwesomeInventory_JobDefOf.AwesomeInventory_Unload && pawn.CurJob.targetA.Thing == thing)
{
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced);
}
else
{
Job job = pawn.jobs.jobQueue.FirstOrDefault(
j => j.job.def == AwesomeInventory_JobDefOf.AwesomeInventory_Unload &&
j.job.targetA == thing).job;
if (job != null)
{
pawn.jobs.EndCurrentOrQueuedJob(job, JobCondition.InterruptForced);
}
}
}
/// <summary>
/// Check if conditions are met to take actions.
/// </summary>
/// <param name="pawn"> Pawn to check. </param>
/// <returns> Returns true if <paramref name="pawn"/>'s inventory needs to restock. </returns>
protected override bool Satisfied(Pawn pawn)
{
ValidateArg.NotNull(pawn, nameof(pawn));
bool needRestock = base.Satisfied(pawn) &&
((pawn.TryGetComp <CompAwesomeInventoryLoadout>()?.NeedRestock ?? false)
||
(pawn.equipment.Primary == null && AwesomeInventoryMod.Settings.AutoEquipWeapon));
#if DEBUG
Log.Message(
string.Format(
System.Globalization.CultureInfo.InvariantCulture,
"[{0}] {1}:: Need restock: {2}",
DateTime.Now.ToLongTimeString(),
nameof(ThinkNode_AwesomeInventory_Core),
needRestock));
#endif
return(needRestock);
}
/// <summary>
/// If test run parameter exists already it will override with new value otherwise this will add new test run parameter.
/// </summary>
/// <param name="runSettingsProvider"></param>
/// <param name="match"></param>
public static void UpdateTestRunParameterSettingsNode(this IRunSettingsProvider runSettingsProvider, Match match)
{
ValidateArg.NotNull(runSettingsProvider, nameof(runSettingsProvider));
var xmlDocument = runSettingsProvider.GetRunSettingXmlDocument();
XmlNode testRunParameterNode = GetXmlNode(xmlDocument, Constants.TestRunParametersName) ?? xmlDocument.CreateElement(Constants.TestRunParametersName);
var attrName = match.Groups[AttributeNameString].Value;
var attrValue = match.Groups[AttributeValueString].Value;
if (!TryOverrideAttributeValue(testRunParameterNode, attrName, attrValue))
{
XmlElement element = xmlDocument.CreateElement(ParameterString);
element.SetAttribute(NameString, attrName);
element.SetAttribute(ValueString, attrValue);
testRunParameterNode.AppendChild(element);
xmlDocument.DocumentElement.AppendChild(testRunParameterNode);
}
runSettingsProvider.UpdateRunSettings(xmlDocument.OuterXml);
}
public IXPathNavigable AddRunSettings(IXPathNavigable inputRunSettingDocument, IRunSettingsConfigurationInfo configurationInfo, ILogger log)
{
ValidateArg.NotNull(inputRunSettingDocument, "inputRunSettingDocument");
ValidateArg.NotNull(configurationInfo, "configurationInfo");
var navigator = inputRunSettingDocument.CreateNavigator();
if (navigator.MoveToChild("RunSettings", ""))
{
if (navigator.MoveToChild(AdapterConstants.SettingsName, ""))
{
navigator.DeleteSelf();
}
navigator.AppendChild(SerializeSettings());
}
navigator.MoveToRoot();
return(navigator);
}
private bool Deploy(string source, IRunContext runContext, ITestExecutionRecorder testExecutionRecorder, IList <DeploymentItem> deploymentItems, TestRunDirectories runDirectories)
{
ValidateArg.NotNull(runDirectories, "runDirectories");
if (EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("MSTestExecutor: Found that deployment items for source {0} are: ", source);
foreach (var item in deploymentItems)
{
EqtTrace.Info("MSTestExecutor: SourcePath: - {0}", item.SourcePath);
}
}
// Do the deployment.
EqtTrace.InfoIf(EqtTrace.IsInfoEnabled, "MSTestExecutor: Using deployment directory {0} for source {1}.", runDirectories.OutDirectory, source);
var warnings = this.Deploy(new List <DeploymentItem>(deploymentItems), source, runDirectories.OutDirectory, this.GetTestResultsDirectory(runContext));
// Log warnings
LogWarnings(testExecutionRecorder, warnings);
return(deploymentItems != null && deploymentItems.Count > 0);
}
