// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
|
namespace OpenTap
|
{
|
|
/// <summary>
|
/// Converts a macro to its expanded string format.
|
/// </summary>
|
class MacroExpansion
|
{
|
/// <summary>
|
/// Name of macro.
|
/// </summary>
|
public string MacroName { get; set; }
|
/// <summary>
|
/// Description read from attribute.
|
/// </summary>
|
public string Description { get; set; }
|
/// <summary>
|
/// String to identify where the macro comes from.
|
/// </summary>
|
public string Origin { get; set; }
|
}
|
|
/// <summary> a string that can be expanded with macros.</summary>
|
public class MacroString
|
{
|
/// <summary> Optional context for macro strings that refers to a test step. This is used to find additional macro definitions such as TestPlanDir.</summary>
|
public ITestStepParent Context { get; set; }
|
|
string text = "";
|
|
/// <summary> The text that can be expanded. </summary>
|
public string Text
|
{
|
get { return text; }
|
set
|
{
|
if (value == null)
|
throw new ArgumentNullException("value");
|
if (text == value) return;
|
text = value;
|
}
|
}
|
|
/// <summary> Creates a new instance of MacroString with a context. </summary>
|
/// <param name="context"></param>
|
public MacroString(ITestStepParent context)
|
{
|
Context = context;
|
}
|
|
/// <summary> Creates a new MacroString without a context. If a TestStep is used use that as context to get access to TestPlan related macros.</summary>
|
public MacroString()
|
{
|
|
}
|
|
/// <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>
|
/// <returns>The expanded string.</returns>
|
public string Expand(TestPlanRun run = null, DateTime? date = null, string testPlanDir = null)
|
{
|
return Expand(run, date, testPlanDir, null);
|
}
|
|
/// <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> Expands the text.</summary>
|
public override string ToString()
|
{
|
return Expand(date: DateTime.Now);
|
}
|
|
/// <summary> Implicit to string conversion that expands the text of the macroString. This makes it possible to seamlessly switch between string and MacroString in implementation.</summary>
|
public static implicit operator string(MacroString macroString)
|
{
|
return macroString.Expand();
|
}
|
/// <summary>
|
/// Replaces macro strings with the strings in the macroDef dictionary.
|
/// If the macro name does not exist in the expanders dictionary.
|
/// </summary>
|
/// <param name="userString">The string to replace macros in.</param>
|
/// <param name="keyvaluepairs">The macro definitions.</param>
|
/// <param name="macroDefault">Default value if MacroName is not in macroDef.</param>
|
/// <returns>A string with macros expanded.</returns>
|
internal static string ReplaceMacros(string userString, IEnumerable<(string,string)> keyvaluepairs, string macroDefault = "TBD")
|
{
|
var cmp = StringComparer.OrdinalIgnoreCase;
|
Dictionary<string, string> cache = new Dictionary<string, string>(cmp);
|
IEnumerator<(string, string)> valueiterator = keyvaluepairs.GetEnumerator();
|
string getMacroDef(string key)
|
{
|
if (cache.TryGetValue(key, out string val))
|
return val;
|
while(valueiterator != null)
|
{
|
if (valueiterator.MoveNext() == false)
|
return macroDefault;
|
var kv = valueiterator.Current;
|
|
if (kv.Item1 == null) continue;
|
if (cache.ContainsKey(kv.Item1))
|
continue;
|
cache[kv.Item1] = kv.Item2;
|
if (cmp.Compare(kv.Item1, key) == 0)
|
return kv.Item2;
|
}
|
return macroDefault;
|
}
|
List<macroLocation> macroLocations = macroLocation.GetMacroLocations(userString);
|
int removed = 0;
|
foreach (var mloc in macroLocations)
|
{
|
|
int taglen = mloc.MacroTagLength;
|
string inserted = getMacroDef(mloc.MacroName);
|
|
userString = userString.Remove(mloc.MacroTagBegin - removed, mloc.MacroTagLength);
|
userString = userString.Insert(mloc.MacroTagBegin - removed, inserted);
|
removed += taglen - inserted.Length;
|
}
|
if(userString.Contains('%'))
|
userString = Environment.ExpandEnvironmentVariables(userString);
|
|
return userString;
|
}
|
|
/// <summary>
|
/// To keep track of a macro in the user string.
|
/// </summary>
|
class macroLocation
|
{
|
/// <summary>
|
/// Name of the macro.
|
/// </summary>
|
public readonly string MacroName;
|
|
/// <summary>
|
/// Index of the first character of the macro.
|
/// </summary>
|
public readonly int MacroBegin;
|
|
/// <summary>
|
/// The location of the first macro delimiter.
|
/// </summary>
|
public int MacroTagBegin
|
{
|
get
|
{
|
return MacroBegin - 1;
|
}
|
}
|
|
/// <summary>
|
/// Location of the last macro delimiter.
|
/// </summary>
|
public readonly int MacroEnd;
|
|
public int MacroTagEnd
|
{
|
get { return MacroEnd + 1; }
|
}
|
|
/// <summary>
|
/// Length from delimiter to delimiter.
|
/// </summary>
|
public int MacroTagLength
|
{
|
get { return MacroTagEnd - MacroTagBegin + 1; }
|
}
|
|
|
public macroLocation(string macroName, int macroStart, int macroStop)
|
{
|
MacroName = macroName;
|
MacroBegin = macroStart;
|
MacroEnd = macroStop;
|
}
|
|
/// <summary>
|
/// Extract macro information from a string.
|
/// </summary>
|
/// <param name="suppliedString"></param>
|
/// <returns></returns>
|
public static List<macroLocation> GetMacroLocations(string suppliedString)
|
{
|
List<macroLocation> locations = new List<macroLocation>();
|
|
// search for things delimited by '<' and '>'.
|
for(int i = 0; i < suppliedString.Length; i++)
|
{
|
if(suppliedString[i] == '<')
|
{
|
i += 1; // skip to first char.
|
int start = i;
|
for (; i < suppliedString.Length; i++)
|
{
|
if(suppliedString[i] == '>')
|
{
|
int stop = i - 1; // last char thats not a '>'.
|
locations.Add(new macroLocation(suppliedString.Substring(start, stop - start + 1).Trim(), start, stop));
|
break;
|
}
|
}
|
}
|
}
|
return locations;
|
}
|
}
|
}
|
}
|
