private static string GetPopularRoutes(Area area, ResultParameters parameters)
{
string result = "Popular routes:\n";
List <Route> popularRoutes = new List <Route>();
if (area.PopularRouteUrls.Count == 0) //MountainProject doesn't list any popular routes. Figure out some ourselves
{
popularRoutes = area.GetPopularRoutes(3);
}
else
{
List <MPObject> itemsToSearch = new List <MPObject>();
itemsToSearch.AddRange(area.SubAreas);
itemsToSearch.AddRange(area.Routes);
area.PopularRouteUrls.ForEach(p => popularRoutes.Add(MountainProjectDataSearch.GetItemWithMatchingUrl(p, itemsToSearch) as Route));
}
foreach (Route popularRoute in popularRoutes)
{
result += $"\n- {Markdown.Link(popularRoute.Name, popularRoute.URL)} {GetRouteAdditionalInfo(popularRoute, parameters)}";
}
if (string.IsNullOrEmpty(result))
{
return("");
}
result += Markdown.NewLine;
return(result);
}
private static string GetRouteAdditionalInfo(Route route, ResultParameters parameters, bool showGrade = true, bool showHeight = true)
{
List <string> parts = new List <string>();
if (showGrade)
{
parts.Add(GetRouteGrade(route, parameters).ToString());
}
if (showHeight && route.Height != null && route.Height.Value != 0)
{
parts.Add($"{Math.Round(route.Height.GetValue(Dimension.Units.Feet), 1)} ft/" +
$"{Math.Round(route.Height.GetValue(Dimension.Units.Meters), 1)} m");
}
if (!string.IsNullOrEmpty(route.AdditionalInfo))
{
parts.Add(route.AdditionalInfo);
}
if (parts.Count > 0)
{
return($"[{string.Join(", ", parts)}]");
}
else
{
return("");
}
}
public bool UpdateResponseLog(MainLogDTO log, MyLogDBEntities logContext)
{
MainLog dbLog = logContext.MainLog.FirstOrDefault(x => x.ID == log.ID);
if (dbLog != null)
{
dbLog.Succeed = log.Succeed;
dbLog.Exception = log.Exception;
if (dbLog.Exception == true)
{
dbLog.ExceptionDetail = new MyLogManager.ExceptionDetail();
dbLog.ExceptionDetail.Description = log.ExceptionDesc;
}
dbLog.Duration = (int)(DateTime.Now.TimeOfDay - dbLog.Time).TotalSeconds;
foreach (var parameter in log.ResultParameters)
{
var dbparameter = new ResultParameters()
{
Name = parameter.Name, Value = parameter.Value
};
dbLog.ResultParameters.Add(dbparameter);
}
logContext.SaveChanges();
return(true);
}
return(false);
}
public void TestSearch()
{
InitMPData();
for (int i = 0; i < testCriteria_search.GetLength(0); i++)
{
string query = testCriteria_search[i, 0];
string expectedUrl = testCriteria_search[i, 1];
_ = ResultParameters.ParseParameters(ref query); //This is here just to filter out any query items (not to be used)
SearchParameters searchParameters = SearchParameters.ParseParameters(ref query);
SearchResult searchResult = MountainProjectDataSearch.Search(query, searchParameters);
if (string.IsNullOrEmpty(expectedUrl))
{
Assert.IsNull(searchResult.FilteredResult, "Failed for " + testCriteria_search[i, 0]);
}
else
{
Assert.AreEqual(Utilities.GetSimpleURL(Utilities.MPBASEURL + expectedUrl),
searchResult.FilteredResult.URL, "Failed for " + testCriteria_search[i, 0]);
}
Assert.IsTrue(searchResult.TimeSpanTaken().TotalSeconds < 5, $"{query} took too long ({searchResult.TimeTakenMS} ms)");
}
}
public ResultParameters CalculateStockPrice(decimal StartEarningPerShare, decimal EarningPerShareTTM, int IntervalYears, double MinimalAcceptableGrowthRate = 0.15)
{
InputParameters inputParameters = new InputParameters(StartEarningPerShare, EarningPerShareTTM, IntervalYears, MinimalAcceptableGrowthRate);
ResultParameters result = _stickerPriceCalculator.CalculateStickPrice(inputParameters);
return(result);
}
private static string GetPopularRoutes(Area area, ResultParameters parameters)
{
string result = "";
List <Route> popularRoutes = new List <Route>();
if (area.PopularRouteIDs.Count == 0) //MountainProject doesn't list any popular routes. Figure out some ourselves
{
popularRoutes = area.GetPopularRoutes(3);
}
else
{
area.PopularRouteIDs.ForEach(id => popularRoutes.Add(MountainProjectDataSearch.GetItemWithMatchingID(id, MountainProjectDataSearch.DestAreas) as Route));
}
foreach (Route popularRoute in popularRoutes)
{
result += $"\n- {Markdown.Link(popularRoute.Name, popularRoute.URL)} {GetRouteAdditionalInfo(popularRoute, parameters)}";
}
if (string.IsNullOrEmpty(result))
{
return("");
}
return("Popular routes:" + Markdown.NewLine + result + Markdown.NewLine);
}
private async Task UpdateResultAsync(ResultParameters parameters, Result result)
{
using (var context = this.factory.GetContext())
{
var entity = await context.Results.AsTracking()
.Where(x => x.Id == parameters.Id)
.SingleAsync();
try
{
entity.Ends = result.Ends;
entity.IsClosed = result.Closed;
entity.IsSold = result.Sold;
entity.BidPrice = result.BidPrice ?? entity.BidPrice;
entity.PurchasePrice = result.PurchasePrice ?? entity.PurchasePrice;
entity.FinalPrice = result.FinalPrice ?? entity.FinalPrice;
}
catch
{
// todo add log
// we assume the result does no longer exist
entity.IsClosed = true;
}
await context.SaveChangesAsync();
}
}
private ResultParameters CalculateIntermediateVariable(IntermediateVariable intermediateVariable)
{
ResultParameters resultParameter = new ResultParameters();
resultParameter.StickerPrice = (decimal)Financial.PV(intermediateVariable.FutureGrowthRate, 10, 0, -(double)intermediateVariable.FutureStockPrice);
resultParameter.MarginOfSafety = resultParameter.StickerPrice / 2.0m;
return(resultParameter);
}
public static string GetFormattedString(SearchResult searchResult, ResultParameters parameters = null, bool includeUrl = true)
{
if (searchResult.IsEmpty())
{
return(null);
}
string result = "";
if (searchResult.FilteredResult is Area)
{
Area inputArea = searchResult.FilteredResult as Area;
if (!string.IsNullOrEmpty(inputArea.Statistics.ToString()))
{
result += $"{Markdown.Bold(inputArea.Name)} [{inputArea.Statistics}]" + Markdown.NewLine;
}
else
{
result += $"{Markdown.Bold(inputArea.Name)}" + Markdown.NewLine;
}
result += $"{Markdown.Bold(inputArea.Name)} [{inputArea.Statistics}]" + Markdown.NewLine;
result += GetLocationString(inputArea, searchResult.RelatedLocation);
result += GetPopularRoutes(inputArea, parameters);
if (includeUrl)
{
result += inputArea.URL;
}
}
else if (searchResult.FilteredResult is Route)
{
Route inputRoute = searchResult.FilteredResult as Route;
result += $"{Markdown.Bold(inputRoute.Name)} {GetRouteAdditionalInfo(inputRoute, parameters, showGrade: false, showHeight: false)}";
result += Markdown.NewLine;
result += $"Type: {string.Join(", ", inputRoute.Types)}" + Markdown.NewLine;
result += $"Grade: {inputRoute.GetRouteGrade(parameters)}" + Markdown.NewLine;
if (inputRoute.Height != null && inputRoute.Height.Value != 0)
{
result += $"Height: {Math.Round(inputRoute.Height.GetValue(Dimension.Units.Feet), 1)} ft/" +
$"{Math.Round(inputRoute.Height.GetValue(Dimension.Units.Meters), 1)} m" +
Markdown.NewLine;
}
result += $"Rating: {inputRoute.Rating}/4" + Markdown.NewLine;
result += GetLocationString(inputRoute, searchResult.RelatedLocation);
if (includeUrl)
{
result += inputRoute.URL;
}
}
return(result);
}
public ResultParameters CalculateStickPrice(InputParameters inputParameter)
{
IntermediateVariable intermediateVariable = new IntermediateVariable();
intermediateVariable = CalculateIntermediateVariable(inputParameter);
ResultParameters resultParameters = CalculateIntermediateVariable(intermediateVariable);
return(resultParameters);
}
public static async Task <Result> ResultFromSourceAsync(ResultParameters parameters)
{
var url = Url.FromResultParameters(parameters);
var response = await WebRequest.Create(url).GetResponseAsync();
var document = new HtmlDocument();
document.Load(response.GetResponseStream());
return(new Result(document.DocumentNode));
}
/// <summary>
/// Gets the name and value for each metadata property in this object that is not null.
/// </summary>
/// <returns>Name and value for each metadata property in this
/// object that is not null as a MetaDataParameter object.</returns>
public static List <MetaDataParameter> GetMetaDataParameters(object obj)
{
if (obj == null)
{
throw new ArgumentNullException("obj");
}
var metadata = ResultParameters.GetMetadataFromObject(obj);
return(metadata.Select(meta => new MetaDataParameter(meta.Name, meta.Value)).ToList());
}
public override void Run()
{
Param1 = 5;
var param = ResultParameters.GetParams(this);
var dict = param.ToDictionary();
Assert.IsTrue((double)dict["Param1"] == Param1);
Assert.IsTrue(dict.ContainsKey("sub/Index"));
Assert.IsTrue(dict.ContainsKey("sub/Index2") == false);
Console.WriteLine(param);
}
public static string GetRouteGrade(Route route, ResultParameters parameters)
{
if (parameters != null)
{
return(route.GetRouteGrade(parameters.GradeSystem).ToString());
}
else
{
List <Grade> grades = new List <Grade>();
//Add "American" grades
grades.AddRange(route.Grades.Where(g => g.System == GradeSystem.YDS || g.System == GradeSystem.Hueco));
//Add ice grade (if necessary)
Grade iceGrade = route.Grades.Find(g => g.System == GradeSystem.Ice);
if ((route.Types.Contains(Route.RouteType.Ice) || route.Types.Contains(Route.RouteType.Snow) || route.Types.Contains(Route.RouteType.Alpine)) &&
iceGrade != null)
{
grades.Add(iceGrade);
}
//Add international grades
grades.AddRange(route.Grades.Where(g => g.System == GradeSystem.French || g.System == GradeSystem.UIAA || g.System == GradeSystem.Fontainebleau));
if (grades.Count > 0)
{
//Convert grades to strings, but "inject" Aid grade if it exists
Grade aidGrade = route.Grades.Find(g => g.System == GradeSystem.Aid);
List <string> gradeStrings = grades.Select(g =>
{
if (g.System == GradeSystem.YDS && aidGrade != null)
{
return($"{g.ToString(false)} ({aidGrade.ToString(false)})");
}
else
{
return(g.ToString(false));
}
}).ToList();
return(string.Join(" | ", gradeStrings));
}
else if (route.Grades.Count == 1)
{
return(route.Grades.First().ToString(false));
}
else
{
return("");
}
}
}
private async Task UnloadResultAsync(ResultParameters parameters)
{
using (var context = this.factory.GetContext())
{
var entity = await context.Results.AsTracking()
.Where(x => x.Id == parameters.Id)
.SingleAsync();
entity.Updated = DateTimeOffset.Now;
entity.IsLocked = false;
await context.SaveChangesAsync();
}
}
public static string GetReplyForRequest(string commentBody)
{
//Get everything AFTER the keyword, but on the same line
string queryText = Regex.Match(commentBody, BOTKEYWORDREGEX).Groups[1].Value.Trim();
if (string.IsNullOrWhiteSpace(queryText))
{
return("I didn't understand what you were looking for. Please use the Feedback button below if you think this is a bug");
}
ResultParameters resultParameters = ResultParameters.ParseParameters(ref queryText);
SearchParameters searchParameters = SearchParameters.ParseParameters(ref queryText);
SearchResult searchResult = MountainProjectDataSearch.Search(queryText, searchParameters);
return(GetResponse(queryText, searchParameters?.SpecificLocation, searchResult, resultParameters));
}
public ResultParameters Report()
{
SubmitParameters submits = this._submits;
if (submits != null && submits.Valid())
{
if (General.IsNullable(submits.ClientIP))
submits.ClientIP = HttpContext.Current.Request.GetUserIP();
if (General.IsNullable(submits.Sign))
submits.Sign = submits.MakeSign();
string response = submits.Post(this.url);
this._results = ResultParameters.Pares(response);
}
return this._results;
}
public void TestMethod1()
{
IStickerPriceCalculator iStickerPriceCalculator = new StickerPriceCalculator.BLL.StickerPriceCalculator();
var controller = new StickerPriceCalculatorController(iStickerPriceCalculator);
decimal startEPS = -1.36m; // for example, RH has EPS=-1.36 in 2013
decimal EPSTTM = 2.16m; // for example , RH has trailing twelve month EPS for 2.16 in 2017 June
int years = 3; //2013,2014,2015,2016 , that's N(4) - 1 = 3 years.
double MinimalAcceptableGrowthRate = 0.15; // that means MinimalAcceptableGrowthRate=15%;
ResultParameters testedResult = controller.CalculateStockPrice(startEPS, EPSTTM, years, MinimalAcceptableGrowthRate);
ResultParameters targetResultParameter = new ResultParameters();
targetResultParameter.StickerPrice = 64.80m;
targetResultParameter.MarginOfSafety = 32.40m;
Assert.AreEqual(testedResult.MarginOfSafety, targetResultParameter.MarginOfSafety);
Assert.AreEqual(testedResult.StickerPrice, targetResultParameter.StickerPrice);
}
public static string FromResultParameters(ResultParameters parameters)
{
return(string.Format(ResultUrlPattern, parameters.ExternalId));
}
/// <summary> Expands the text. Macros are harvested from the optional TestPlanRun or the test step.</summary>
/// <param name="run">A place to find additional metadata for macro expansion.</param>
/// <param name="date">If no date was found in the metadata, this date will be used. If date is not supplied, DateTime.Now will be used.</param>
/// <param name="testPlanDir">If no TestPlanDir was found in the metata, this TestPlanDir will be used.</param>
/// <param name="replacements">Overrides other macro parameters.</param>
/// <returns>The expanded string.</returns>
public string Expand(TestPlanRun run, DateTime?date, string testPlanDir, Dictionary <string, object> replacements)
{
ITestStepParent context = Context;
IEnumerable <(string, object)> getMacro()
{
// note: macros are case-insensitive.
if (testPlanDir != null)
{
yield return("TestPlanDir", testPlanDir);
}
if (date != null)
{
yield return("date", date);
}
if (replacements != null)
{
foreach (var elem in replacements)
{
yield return(elem.Key, elem.Value);
}
}
if (run != null)
{
var runparams = run.Parameters.Concat(ResultParameters.GetMetadataFromObject(run)).Where(y => y.IsMetaData);
foreach (var v in runparams)
{
var path = v.Value;
yield return(v.Name, path);
yield return(v.MacroName, path);
}
}
ITestStepParent ctx = context;
while (ctx != null)
{
var p = ResultParameters.GetMetadataFromObject(ctx);
foreach (var v in p)
{
if (v.IsMetaData == false)
{
continue;
}
var path = v.Value;
yield return(v.Name, path);
yield return(v.MacroName, path);
}
ctx = ctx.Parent;
}
yield return("date", DateTime.Now);
yield return("Verdict", Verdict.NotSet);
var met = ResultParameters.GetComponentSettingsMetadataLazy(false);
foreach (var ps in met)
{
foreach (var v in ps)
{
if (v.IsMetaData == false)
{
continue;
}
var path = v.Value;
yield return(v.Name, path);
yield return(v.MacroName, path);
}
}
}
return(ReplaceMacros(Text, getMacro().Select(x => (x.Item1, StringConvertProvider.GetString(x.Item2)))));
}
/// <summary> Creates a new TestRun </summary>
public TestRun()
{
Id = Guid.NewGuid();
Parameters = new ResultParameters();
}
failState execTestPlan(TestPlanRun execStage, IList <ITestStep> steps)
{
WaitHandle.WaitAny(new[] { execStage.PromptWaitHandle, TapThread.Current.AbortToken.WaitHandle });
bool resultListenerError = false;
execStage.ScheduleInResultProcessingThread <IResultListener>(resultListener =>
{
try
{
using (TimeoutOperation.Create(() => PrintWaitingMessage(new List <IResource>()
{
resultListener
})))
execStage.ResourceManager.WaitUntilResourcesOpened(TapThread.Current.AbortToken, resultListener);
try
{
// some resources might set metadata in the Open methods.
// this information needs to be propagated to result listeners as well.
// this returns quickly if its a lazy resource manager.
using (TimeoutOperation.Create(
() => PrintWaitingMessage(new List <IResource>()
{
resultListener
})))
execStage.ResourceManager.WaitUntilAllResourcesOpened(TapThread.Current.AbortToken);
}
catch // this error will also be handled somewhere else.
{
}
execStage.WaitForSerialization();
foreach (var res in execStage.PromptedResources)
{
execStage.Parameters.AddRange(ResultParameters.GetMetadataFromObject(res));
}
resultListener.OnTestPlanRunStart(execStage);
}
catch (OperationCanceledException) when(execStage.MainThread.AbortToken.IsCancellationRequested)
{
// test plan thread was aborted, this is OK.
}
catch (Exception ex)
{
Log.Error("Error in OnTestPlanRunStart for '{0}': '{1}'", resultListener, ex.Message);
Log.Debug(ex);
resultListenerError = true;
}
}, true);
if (resultListenerError)
{
return(failState.StartFail);
}
var sw = Stopwatch.StartNew();
try
{
execStage.StepsWithPrePlanRun.Clear();
if (!runPrePlanRunMethods(steps, execStage))
{
return(failState.StartFail);
}
}
catch (Exception e)
{
Log.Error(e.GetInnerMostExceptionMessage());
Log.Debug(e);
return(failState.StartFail);
}
finally{
{
Log.Debug(sw, "PrePlanRun Methods completed");
}
}
Stopwatch planRunOnlyTimer = Stopwatch.StartNew();
var runs = new List <TestStepRun>();
try
{
for (int i = 0; i < steps.Count; i++)
{
var step = steps[i];
if (step.Enabled == false)
{
continue;
}
var run = step.DoRun(execStage, execStage);
if (!run.Skipped)
{
runs.Add(run);
}
run.CheckBreakCondition();
// note: The following is copied inside TestStep.cs
if (run.SuggestedNextStep is Guid id)
{
int nextindex = steps.IndexWhen(x => x.Id == id);
if (nextindex >= 0)
{
i = nextindex - 1;
}
// if skip to next step, dont add it to the wait queue.
}
}
}
catch (TestStepBreakException breakEx)
{
Log.Info("{0}", breakEx.Message);
}
finally
{
// Now wait for them to actually complete. They might defer internally.
foreach (var run in runs)
{
run.WaitForCompletion();
execStage.UpgradeVerdict(run.Verdict);
}
}
Log.Debug(planRunOnlyTimer, "Test step runs finished.");
return(failState.Ok);
}
public static string GetFormattedString(SearchResult searchResult, ResultParameters parameters = null, bool includeUrl = true)
{
if (searchResult.IsEmpty())
{
return(null);
}
string result = "";
if (searchResult.FilteredResult is Area)
{
Area inputArea = searchResult.FilteredResult as Area;
Area latestAreaData = new Area {
ID = inputArea.ID
};
Parsers.ParseAreaAsync(latestAreaData, false, false).Wait(); //Get most updated data (straight from MountainProject page)
if (!string.IsNullOrEmpty(latestAreaData.Statistics.ToString()))
{
result += $"{Markdown.Bold(latestAreaData.Name)} [{latestAreaData.Statistics}]" + Markdown.NewLine;
}
else
{
result += $"{Markdown.Bold(latestAreaData.Name)}" + Markdown.NewLine;
}
result += GetLocationString(latestAreaData, searchResult.RelatedLocation);
result += GetPopularRoutes(latestAreaData, parameters);
if (includeUrl)
{
result += latestAreaData.URL;
}
}
else if (searchResult.FilteredResult is Route)
{
Route inputRoute = searchResult.FilteredResult as Route;
Route latestRouteData = new Route {
ID = inputRoute.ID
};
Parsers.ParseRouteAsync(latestRouteData, false).Wait(); //Get most updated data (straight from MountainProject page)
result += $"{Markdown.Bold(latestRouteData.Name)} {GetRouteAdditionalInfo(latestRouteData, parameters, showGrade: false, showHeight: false)}";
result += Markdown.NewLine;
result += $"Type: {string.Join(", ", latestRouteData.Types)}" + Markdown.NewLine;
result += $"Grade: {GetRouteGrade(latestRouteData, parameters)}" + Markdown.NewLine;
if (latestRouteData.Height != null && latestRouteData.Height.Value != 0)
{
result += $"Height: {Math.Round(latestRouteData.Height.GetValue(Dimension.Units.Feet), 1)} ft/" +
$"{Math.Round(latestRouteData.Height.GetValue(Dimension.Units.Meters), 1)} m" +
Markdown.NewLine;
}
result += $"Rating: {latestRouteData.Rating}/4" + Markdown.NewLine;
result += GetLocationString(latestRouteData, searchResult.RelatedLocation);
if (includeUrl)
{
result += latestRouteData.URL;
}
}
return(result);
}
public static string GetFormattedString(MPObject finalResult, ResultParameters parameters = null, bool includeUrl = true)
{
return(GetFormattedString(new SearchResult(finalResult), parameters, includeUrl));
}
private static string GetResponse(string queryText, string queryLocation, SearchResult searchResult, ResultParameters resultParameters)
{
if (searchResult.IsEmpty())
{
if (!string.IsNullOrEmpty(queryLocation))
{
return($"I could not find anything for \"{queryText}\" in \"{queryLocation}\". Please use the Feedback button below if you think this is a bug");
}
else
{
return($"I could not find anything for \"{queryText}\". Please use the Feedback button below if you think this is a bug");
}
}
else if (searchResult.AllResults.Count > 1)
{
return($"I found the following info (out of {searchResult.AllResults.Count} total results):" + Markdown.HRule + GetFormattedString(searchResult, resultParameters));
}
else
{
return($"I found the following info:" + Markdown.HRule + GetFormattedString(searchResult, resultParameters));
}
}
private static void ParseInputString()
{
MountainProjectDataSearch.InitMountainProjectData(serializationPath);
if (MountainProjectDataSearch.DestAreas.Count() == 0)
{
Console.WriteLine("The xml either doesn't exist or is empty");
Environment.Exit(0);
}
Console.WriteLine("File read.");
bool keepSearching = true;
while (keepSearching)
{
Console.WriteLine("\n\nPlease input the string you would like to parse: ");
string input = Console.ReadLine();
SearchParameters searchParameters = SearchParameters.ParseParameters(ref input);
ResultParameters resultParameters = ResultParameters.ParseParameters(ref input);
bool allResults = input.Contains("-all");
if (allResults)
{
input = input.Replace("-all", "").Trim();
}
Stopwatch stopwatch = Stopwatch.StartNew();
SearchResult searchResult = MountainProjectDataSearch.Search(input, searchParameters);
stopwatch.Stop();
if (searchResult.IsEmpty())
{
Console.WriteLine("Nothing found matching \"" + input + "\"");
}
else if (allResults)
{
List <MPObject> matchedObjectsByPopularity = searchResult.AllResults.OrderByDescending(p => p.Popularity).ToList();
Console.WriteLine($"Found {matchedObjectsByPopularity.Count} items match that search query (found in {stopwatch.ElapsedMilliseconds} ms):");
foreach (MPObject result in matchedObjectsByPopularity)
{
string url = result.URL.Replace(Utilities.MPBASEURL, "");
if (result is Route)
{
Console.WriteLine($" Route: {result.Name} (Pop: {result.Popularity}) | Location: {GetLocationString(result)} | {url}");
}
else if (result is Area)
{
Console.WriteLine($" Area: {result.Name} (Pop: {result.Popularity}) | Location: {GetLocationString(result)} | {url}");
}
}
}
else
{
string resultStr = "";
MPObject result = searchResult.FilteredResult;
if (result is Area)
{
resultStr = (result as Area).ToString();
}
else if (result is Route)
{
resultStr = (result as Route).ToString(resultParameters);
}
Console.WriteLine($"The following was found (found in {stopwatch.ElapsedMilliseconds} ms):");
Console.WriteLine(" " + resultStr);
Console.WriteLine($" Location: {GetLocationString(result, searchResult.RelatedLocation)}");
Console.WriteLine("\nOpen result? (y/n) ");
if (Console.ReadLine().ToLower() == "y")
{
Process.Start(result.URL);
}
}
Console.WriteLine("\nSearch something else? (y/n) ");
keepSearching = Console.ReadLine().ToLower() == "y";
}
}
private TestPlanRun DoExecute(IEnumerable <IResultListener> resultListeners, IEnumerable <ResultParameter> metaDataParameters, HashSet <ITestStep> stepsOverride)
{
if (resultListeners == null)
{
throw new ArgumentNullException("resultListeners");
}
if (PrintTestPlanRunSummary && !resultListeners.Contains(summaryListener))
{
resultListeners = resultListeners.Concat(new IResultListener[] { summaryListener });
}
resultListeners = resultListeners.Where(r => r is IEnabledResource ? ((IEnabledResource)r).IsEnabled : true);
IList <ITestStep> steps;
if (stepsOverride == null)
{
steps = Steps;
}
else
{
// Remove steps that are already included via their parent steps.
foreach (var step in stepsOverride)
{
if (step == null)
{
throw new ArgumentException("stepsOverride may not contain null", "stepsOverride");
}
var p = step.GetParent <ITestStep>();
while (p != null)
{
if (stepsOverride.Contains(p))
{
throw new ArgumentException("stepsOverride may not contain steps and their parents.", "stepsOverride");
}
p = p.GetParent <ITestStep>();
}
}
steps = Utils.FlattenHeirarchy(Steps, step => step.ChildTestSteps).Where(stepsOverride.Contains).ToList();
}
long initTimeStamp = Stopwatch.GetTimestamp();
var initTime = DateTime.Now;
Log.Info("-----------------------------------------------------------------");
var fileStreamFile = FileSystemHelper.CreateTempFile();
var logStream = new HybridStream(fileStreamFile, 1024 * 1024);
var planRunLog = new FileTraceListener(logStream)
{
IsRelative = true
};
OpenTap.Log.AddListener(planRunLog);
var allSteps = Utils.FlattenHeirarchy(steps, step => step.ChildTestSteps);
var allEnabledSteps = Utils.FlattenHeirarchy(steps.Where(x => x.Enabled), step => step.GetEnabledChildSteps());
var enabledSinks = new HashSet <IResultSink>();
TestStepExtensions.GetObjectSettings <IResultSink, ITestStep, IResultSink>(allEnabledSteps, true, null, enabledSinks);
if (enabledSinks.Count > 0)
{
var sinkListener = new ResultSinkListener(enabledSinks);
resultListeners = resultListeners.Append(sinkListener);
}
Log.Info("Starting TestPlan '{0}' on {1}, {2} of {3} TestSteps enabled.", Name, initTime, allEnabledSteps.Count, allSteps.Count);
// Reset step verdict.
foreach (var step in allSteps)
{
if (step.Verdict != Verdict.NotSet)
{
step.Verdict = Verdict.NotSet;
step.OnPropertyChanged("Verdict");
}
}
if (currentExecutionState != null)
{
// load result listeners that are _not_ used in the previous runs.
// otherwise they wont get opened later.
foreach (var rl in resultListeners)
{
if (!currentExecutionState.ResultListeners.Contains(rl))
{
currentExecutionState.ResultListeners.Add(rl);
}
}
}
var currentListeners = currentExecutionState != null ? currentExecutionState.ResultListeners : resultListeners;
TestPlanRun execStage;
bool continuedExecutionState = false;
if (currentExecutionState != null)
{
execStage = new TestPlanRun(currentExecutionState, initTime, initTimeStamp);
continuedExecutionState = true;
}
else
{
execStage = new TestPlanRun(this, resultListeners.ToList(), initTime, initTimeStamp);
execStage.Parameters.AddRange(PluginManager.GetPluginVersions(allEnabledSteps));
execStage.ResourceManager.ResourceOpened += r =>
{
execStage.Parameters.AddRange(PluginManager.GetPluginVersions(new List <object> {
r
}));
};
}
if (metaDataParameters != null)
{
execStage.Parameters.AddRange(metaDataParameters);
}
var prevExecutingPlanRun = executingPlanRun.LocalValue;
executingPlanRun.LocalValue = execStage;
CurrentRun = execStage;
failState runWentOk = failState.StartFail;
// ReSharper disable once InconsistentNaming
var preRun_Run_PostRunTimer = Stopwatch.StartNew();
try
{
execStage.FailedToStart = true; // Set it here in case OpenInternal throws an exception. Could happen if a step is missing an instrument
OpenInternal(execStage, continuedExecutionState, currentListeners.Cast <IResource>().ToList(), allEnabledSteps);
execStage.WaitForSerialization();
execStage.ResourceManager.BeginStep(execStage, this, TestPlanExecutionStage.Execute, TapThread.Current.AbortToken);
if (continuedExecutionState)
{ // Since resources are not opened, getting metadata cannot be done in the wait for resources continuation
// like shown in TestPlanRun. Instead we do it here.
foreach (var res in execStage.ResourceManager.Resources)
{
execStage.Parameters.AddRange(ResultParameters.GetMetadataFromObject(res));
}
}
runWentOk = failState.ExecFail; //important if test plan is aborted and runWentOk is never returned.
runWentOk = execTestPlan(execStage, steps);
}
catch (Exception e)
{
if (e is OperationCanceledException && execStage.MainThread.AbortToken.IsCancellationRequested)
{
Log.Warning(String.Format("TestPlan aborted. ({0})", e.Message));
execStage.UpgradeVerdict(Verdict.Aborted);
}
else if (e is ThreadAbortException)
{
// It seems this actually never happens.
Log.Warning("TestPlan aborted.");
execStage.UpgradeVerdict(Verdict.Aborted);
//Avoid entering the finally clause.
Thread.Sleep(500);
}
else if (e is System.ComponentModel.LicenseException)
{
Log.Error(e.Message);
execStage.UpgradeVerdict(Verdict.Error);
}
else
{
Log.Warning("TestPlan aborted.");
Log.Error(e.Message);
Log.Debug(e);
execStage.UpgradeVerdict(Verdict.Error);
}
}
finally
{
execStage.FailedToStart = (runWentOk == failState.StartFail);
try
{
finishTestPlanRun(execStage, preRun_Run_PostRunTimer, runWentOk, planRunLog, logStream);
}
catch (Exception ex)
{
Log.Error("Error while finishing TestPlan.");
Log.Debug(ex);
}
OpenTap.Log.RemoveListener(planRunLog);
planRunLog.Dispose();
logStream.Dispose();
File.Delete(fileStreamFile);
// Clean all test steps StepRun, otherwise the next test plan execution will be stuck at TestStep.DoRun at steps that does not have a cleared StepRun.
foreach (var step in allSteps)
{
step.StepRun = null;
}
executingPlanRun.LocalValue = prevExecutingPlanRun;
CurrentRun = prevExecutingPlanRun;
}
return(execStage);
}
public override void Run()
{
base.Run();
var selected = SelectedMembers.ToArray();
var originalValues = selected.Select(set => set.GetValue(this)).ToArray();
IEnumerable <decimal> range = LinearRange(SweepStart, SweepStop, (int)SweepPoints);
if (SweepBehavior == SweepBehavior.Exponential)
{
range = ExponentialRange(SweepStart, SweepStop, (int)SweepPoints);
}
var disps = selected.Select(x => x.GetDisplayAttribute()).ToList();
string names = string.Join(", ", disps.Select(x => x.Name));
if (disps.Count > 1)
{
names = string.Format("{{{0}}}", names);
}
foreach (var Value in range)
{
var val = StringConvertProvider.GetString(Value, CultureInfo.InvariantCulture);
foreach (var set in selected)
{
try
{
var value = StringConvertProvider.FromString(val, set.TypeDescriptor, this, CultureInfo.InvariantCulture);
set.SetValue(this, value);
}
catch (TargetInvocationException ex)
{
Log.Error("Unable to set '{0}' to value '{2}': {1}", set.GetDisplayAttribute().Name, ex.InnerException.Message, Value);
Log.Debug(ex.InnerException);
}
}
// Notify that values might have changes
OnPropertyChanged("");
var AdditionalParams = new ResultParameters();
foreach (var disp in disps)
{
AdditionalParams.Add(new ResultParameter(disp.Group.FirstOrDefault() ?? "", disp.Name, Value));
}
Log.Info("Running child steps with {0} = {1} ", names, Value);
var runs = RunChildSteps(AdditionalParams, BreakLoopRequested).ToList();
if (BreakLoopRequested.IsCancellationRequested)
{
break;
}
runs.ForEach(r => r.WaitForCompletion());
}
for (int i = 0; i < selected.Length; i++)
{
selected[i].SetValue(this, originalValues[i]);
}
}
/// <summary>
/// 根据微信服务器响应的XML文本构建测速上报返回数据的对象
/// </summary>
/// <param name="xml">设置微信服务器响应的XML文本</param>
/// <returns>返回构建成功的测速上报返回数据的对象</returns>
public static ResultParameters Pares(string xml)
{
ResultParameters result = null;
if (!General.IsNullable(xml))
{
result = new ResultParameters();
result.FromXml(xml);
}
return result;
}
