public void NotClosedDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter:$paramter2$ and $literal-opened-delimiter", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter: and $literal-opened-delimiter", ps.ToString());
}
public void LeadingDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter:$paramter2$$$", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter:$$", ps.ToString());
}
public void OnlyDelimiters()
{
ParameterizedString ps = new ParameterizedString("$$$$$$$$$$$$$$$$$", "$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("$$$$$$$$$$$$$$$$$", ps.ToString());
}
public void MultiCharDelimiterOnlyParameters()
{
ParameterizedString ps = new ParameterizedString("D$p1D$D$p2D$D$p3D$", "D$");
Assert.AreEqual(3, ps.Parameters.Count);
Assert.AreEqual(string.Empty, ps.ToString());
}
public void StartsWithDelimiter()
{
ParameterizedString ps = new ParameterizedString("$P1 parameter is at the begging of string", "$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("$P1 parameter is at the begging of string", ps.ToString());
}
/// <summary>
/// Converts a test step title/expected result from html to plain text.
/// </summary>
/// <param name="value">The value produced by the binding source.</param>
/// <param name="targetType">The type of the binding target property.</param>
/// <param name="parameter">The converter parameter to use.</param>
/// <param name="culture">The culture to use in the converter.</param>
/// <returns>
/// A converted value. If the method returns null, the valid null value is used.
/// </returns>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
ParameterizedString currentTestStepProperty = value as ParameterizedString;
string propertyPlainText = currentTestStepProperty.ToPlainText();
return(propertyPlainText);
}
public void MultiCharDelimiterLeadingDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter:D$paramter2D$D$D$", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter:D$D$", ps.ToString());
}
public void MultiCharDelimiterOnlyDelimiters()
{
ParameterizedString ps = new ParameterizedString("D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$", "D$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$", ps.ToString());
}
public void MultiCharDelimiterNotClosedDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter:D$paramter2D$ and D$literal-opened-delimiter", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter: and D$literal-opened-delimiter", ps.ToString());
}
public void NoParameter()
{
ParameterizedString ps = new ParameterizedString("string with no paramter", "$");
Assert.IsNotNull(ps.Parameters);
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("string with no paramter", ps.ToString());
}
public void OnlyParameters()
{
ParameterizedString ps = new ParameterizedString("$p1$$p2$$p3$", "$");
Assert.AreEqual(3, ps.Parameters.Count);
Assert.AreEqual(string.Empty, ps.ToString());
}
public void NoParameter()
{
ParameterizedString ps = new ParameterizedString("string with no paramter", "$");
Assert.IsNotNull(ps.Parameters);
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("string with no paramter", ps.ToString());
}
public void CtorEnumerableNull()
{
List<ParameterizedStringPart> parts;
parts = new List<ParameterizedStringPart>();
parts.Add(new ParameterizedStringPart("string with paramters"));
parts.Add(new ParameterizedStringPart("paramter1"));
ParameterizedString ps = new ParameterizedString(parts, null);
}
public void CtorEnumerableNull()
{
List <ParameterizedStringPart> parts;
parts = new List <ParameterizedStringPart>();
parts.Add(new ParameterizedStringPart("string with paramters"));
parts.Add(new ParameterizedStringPart("paramter1"));
ParameterizedString ps = new ParameterizedString(parts, null);
}
public void Parameters()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter: $paramter2$", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("paramter1", ps.Parameters[0].ParameterName);
Assert.AreEqual("paramter2", ps.Parameters[1].ParameterName);
ps.Parameters[0].LiteralValue = "value1";
ps.Parameters[1].LiteralValue = "value2";
Assert.AreEqual("string with paramter: value1 and parameter: value2", ps.ToString());
}
public void MultiCharDelimiterParameters()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter: D$paramter2D$", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("paramter1", ps.Parameters[0].ParameterName);
Assert.AreEqual("paramter2", ps.Parameters[1].ParameterName);
ps.Parameters[0].LiteralValue = "value1";
ps.Parameters[1].LiteralValue = "value2";
Assert.AreEqual("string with paramter: value1 and parameter: value2", ps.ToString());
}
public void Parameters()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter: $paramter2$", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("paramter1", ps.Parameters[0].ParameterName);
Assert.AreEqual("paramter2", ps.Parameters[1].ParameterName);
ps.Parameters[0].LiteralValue = "value1";
ps.Parameters[1].LiteralValue = "value2";
Assert.AreEqual("string with paramter: value1 and parameter: value2", ps.ToString());
}
/// <summary>
/// Создать нумерованный многоуровневый список Word
/// </summary>
public void CreateMultiLevelList(Word.Paragraph paragraph, Word.ListTemplate listTemplate, List <ITestCase> testCase, int Index)
{
// Добавить название тест кейса на первый уровень нумерованного многоуровневого списка
paragraph.Range.Text = testCase.ElementAt(Index).Title;
paragraph.Range.SetListLevel(1);
paragraph.Range.ListFormat.ApplyListTemplateWithLevel(listTemplate, ContinuePreviousList: true, ApplyTo: WdListApplyTo.wdListApplyToSelection, DefaultListBehavior: WdDefaultListBehavior.wdWord10ListBehavior, ApplyLevel: 1);
paragraph.Range.InsertParagraphAfter();
// Если в тест кейсе нет Actions
if (testCase.ElementAt(Index).Actions.Count == 0)
{
paragraph.Range.Text = "Тест кейс пуст!";
paragraph.Range.SetListLevel(2);
paragraph.Range.ListFormat.ApplyListTemplateWithLevel(listTemplate, ContinuePreviousList: true, ApplyTo: WdListApplyTo.wdListApplyToSelection, DefaultListBehavior: WdDefaultListBehavior.wdWord10ListBehavior, ApplyLevel: 2);
paragraph.Range.InsertParagraphAfter();
}
ISharedStep sharedStep = null;
ISharedStepReference sharedStepReference = null;
for (int i = 0; i < testCase.ElementAt(Index).Actions.Count; i++)
{
sharedStepReference = testCase.ElementAt(Index).Actions.ElementAt(i) as ISharedStepReference;
// Добавить общий шаг
if (sharedStepReference != null)
{
// Добавить текст общего шага на второй уровень нумерованного многоуровневого списка
sharedStep = sharedStepReference.FindSharedStep();
paragraph.Range.Text = sharedStep.Title + "\t(ОБЩИЙ ШАГ)";
paragraph.Range.SetListLevel(2);
paragraph.Range.ListFormat.ApplyListTemplateWithLevel(listTemplate, ContinuePreviousList: true, ApplyTo: WdListApplyTo.wdListApplyToSelection, DefaultListBehavior: WdDefaultListBehavior.wdWord10ListBehavior, ApplyLevel: 2);
paragraph.Range.InsertParagraphAfter();
}
else
{
ParameterizedString parametrizedString = new ParameterizedString(((ITestStep)testCase.ElementAt(Index).Actions[i]).Title.ToPlainText());
// Добавить текст Action на второй уровень нумерованного многоуровневого списка
paragraph.Range.Text = get_ActionWithParameters(testCase.ElementAt(Index), parametrizedString.ToPlainText());
paragraph.Range.SetListLevel(2);
paragraph.Range.ListFormat.ApplyListTemplateWithLevel(listTemplate, ContinuePreviousList: true, ApplyTo: WdListApplyTo.wdListApplyToSelection, DefaultListBehavior: WdDefaultListBehavior.wdWord10ListBehavior, ApplyLevel: 2);
paragraph.Range.InsertParagraphAfter();
}
}
}
/// <summary>
/// Replaces all parameters in a parameterized text.
/// </summary>
/// <param name="parameterizedText">The parameterized text.</param>
/// <param name="parameters">The parameters.</param>
/// <returns>Text where all parameter references have been replaced with expected values</returns>
private static string ReplaceParameters(ParameterizedString parameterizedText, TestResultParameterCollection parameters)
{
if (parameters.Count > 0)
{
SyncServiceTrace.D(Resources.ReplacingParameters, parameterizedText, string.Join(",", parameters.Select(x => x.Name + "=" + x.ExpectedValue)));
foreach (var parameter in parameters)
{
var oldParameterizedText = parameterizedText.ToPlainText();
parameterizedText = parameterizedText.ReplaceParameter(parameter.Name, parameter.ExpectedValue);
// I don't know why this fails sometimes, maybe because of special characters in the string like "foo: @paramter"
if (parameterizedText.ToPlainText().Equals(oldParameterizedText) && parameterizedText.ParameterNames.Contains(parameter.Name))
{
// manually replace parameter
SyncServiceTrace.W(Resources.ParameterizedStringFailed, parameter.Name, parameterizedText.ToPlainText(), parameter.ExpectedValue);
parameterizedText = new ParameterizedString(parameterizedText.ToPlainText().Replace("@" + parameter.Name, parameter.ExpectedValue));
}
}
}
return(parameterizedText.ToPlainText());
}
private void TestCaseInfoForm_Load(object sender, EventArgs e)
{
try
{
label1.Text = testCase.ElementAt(nToolTipIndex).Title;
ISharedStep sharedStep = null;
ISharedStepReference sharedStepReference = null;
List <string> actionsList = new List <string>();
if (testCase.ElementAt(nToolTipIndex).Actions.Count == 0)
{
actionsList.Add("Тест кейс пуст");
}
for (int i = 0; i < testCase.ElementAt(nToolTipIndex).Actions.Count; i++)
{
sharedStepReference = testCase.ElementAt(nToolTipIndex).Actions.ElementAt(i) as ISharedStepReference;
if (sharedStepReference != null)
{
sharedStep = sharedStepReference.FindSharedStep();
actionsList.Add((i + 1) + ". " + sharedStep.Title + "\t(ОБЩИЙ ШАГ)");
}
else
{
ParameterizedString parametrizedString = new ParameterizedString(((ITestStep)testCase.ElementAt(nToolTipIndex).Actions[i]).Title.ToPlainText());
actionsList.Add((i + 1) + ". " + wordFile.get_ActionWithParameters(testCase.ElementAt(nToolTipIndex), parametrizedString.ToPlainText()));
}
}
listBox1.Items.AddRange(actionsList.ToArray());
}
catch
{
listBox1.Items.Add("В запросе отсутствуют тест кейсы.");
}
}
public void MultiCharDelimiterOnlyDelimiters()
{
ParameterizedString ps = new ParameterizedString("D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$", "D$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$D$", ps.ToString());
}
public void MultiCharDelimiterOnlyParameters()
{
ParameterizedString ps = new ParameterizedString("D$p1D$D$p2D$D$p3D$", "D$");
Assert.AreEqual(3, ps.Parameters.Count);
Assert.AreEqual(string.Empty, ps.ToString());
}
public void CtorNullEnumerableString()
{
ParameterizedString ps = new ParameterizedString((IEnumerable <ParameterizedStringPart>)null, "delimiter");
}
public void CtorNullString()
{
ParameterizedString ps = new ParameterizedString((string)null, "delimiter");
}
public void CtorStringNull()
{
ParameterizedString ps = new ParameterizedString("string with paramters", null);
}
public void MultiCharDelimiterParameters()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter: D$paramter2D$", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("paramter1", ps.Parameters[0].ParameterName);
Assert.AreEqual("paramter2", ps.Parameters[1].ParameterName);
ps.Parameters[0].LiteralValue = "value1";
ps.Parameters[1].LiteralValue = "value2";
Assert.AreEqual("string with paramter: value1 and parameter: value2", ps.ToString());
}
public void Ctor() {
ParameterizedString ps = new ParameterizedString();
}
public void CtorNullEnumerableString()
{
ParameterizedString ps = new ParameterizedString((IEnumerable<ParameterizedStringPart>)null, "delimiter");
}
public void LeadingDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter:$paramter2$$$", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter:$$", ps.ToString());
}
public void NotClosedDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: $paramter1$ and parameter:$paramter2$ and $literal-opened-delimiter", "$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter: and $literal-opened-delimiter", ps.ToString());
}
public void OnlyDelimiters()
{
ParameterizedString ps = new ParameterizedString("$$$$$$$$$$$$$$$$$", "$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("$$$$$$$$$$$$$$$$$", ps.ToString());
}
public void Ctor()
{
ParameterizedString ps = new ParameterizedString();
}
public void OnlyParameters()
{
ParameterizedString ps = new ParameterizedString("$p1$$p2$$p3$", "$");
Assert.AreEqual(3, ps.Parameters.Count);
Assert.AreEqual(string.Empty, ps.ToString());
}
public void MultiCharDelimiterNotClosedDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter:D$paramter2D$ and D$literal-opened-delimiter", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter: and D$literal-opened-delimiter", ps.ToString());
}
public void MultiCharDelimiterLeadingDelimiter()
{
ParameterizedString ps = new ParameterizedString("string with paramter: D$paramter1D$ and parameter:D$paramter2D$D$D$", "D$");
Assert.AreEqual(2, ps.Parameters.Count);
Assert.AreEqual("string with paramter: and parameter:D$D$", ps.ToString());
}
public void CtorStringNull()
{
ParameterizedString ps = new ParameterizedString("string with paramters", null);
}
public void StartsWithDelimiter()
{
ParameterizedString ps = new ParameterizedString("$P1 parameter is at the begging of string", "$");
Assert.AreEqual(0, ps.Parameters.Count);
Assert.AreEqual("$P1 parameter is at the begging of string", ps.ToString());
}
public void CtorNullString()
{
ParameterizedString ps = new ParameterizedString((string)null, "delimiter");
}
