// 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.ComponentModel;
|
using System.Xml.Linq;
|
using OpenTap.Translation;
|
|
namespace OpenTap.Plugins.BasicSteps
|
{
|
public enum InputButtons
|
{
|
[Display("OK / Cancel", "Shows the OK and Cancel buttons")]
|
OkCancel,
|
[Display("Yes / No", "Shows the Yes and No buttons")]
|
YesNo
|
}
|
|
enum WaitForInputResult1
|
{
|
// The order of the results determines the order in which the buttons is shown in the dialog box.
|
// The number assigned, determines the default value.
|
No = 2, Yes = 1
|
}
|
|
enum WaitForInputResult2
|
{
|
// The order of the results determines the order in which the buttons is shown in the dialog box.
|
// The number assigned, determines the default value.
|
Cancel = 2, [Display("OK")] Ok = 1
|
}
|
|
class DialogRequest : IDisplayAnnotation, IStringLocalizer
|
{
|
public DialogRequest(string Title, string Message)
|
{
|
this.Name = Title;
|
this.Message = Message;
|
}
|
|
[Browsable(false)]
|
public bool PictureEnabled => Picture != null;
|
|
[Layout(LayoutMode.FullRow)]
|
[Display("Picture", Order: 1)]
|
[EnabledIf(nameof(PictureEnabled), HideIfDisabled = true)]
|
public Picture Picture { get; set; }
|
|
// implementing Name of IDisplayAnnotation explicitly.
|
public string Name { get;}
|
|
[Layout(LayoutMode.FullRow, rowHeight: 2)]
|
[Browsable(true)]
|
[Display("Message", Order: 2)]
|
public string Message { get; }
|
|
[Browsable(false)]
|
public InputButtons Buttons { get; set; }
|
|
[Layout(LayoutMode.FloatBottom | LayoutMode.FullRow)]
|
[EnabledIf("Buttons", InputButtons.YesNo, HideIfDisabled = true)]
|
[Submit]
|
public WaitForInputResult1 Input1 { get; set; } = WaitForInputResult1.Yes;
|
|
[Layout(LayoutMode.FloatBottom | LayoutMode.FullRow)]
|
[EnabledIf("Buttons", InputButtons.OkCancel, HideIfDisabled = true)]
|
[Submit]
|
public WaitForInputResult2 Input2 { get; set; } = WaitForInputResult2.Ok;
|
|
// the rest of IDisplayAnntation can be implemented implicitly
|
// as these properties are not really needed for user input requests.
|
|
string IDisplayAnnotation.Description => string.Empty;
|
|
string[] IDisplayAnnotation.Group => Array.Empty<string>();
|
|
double IDisplayAnnotation.Order => DisplayAttribute.DefaultOrder;
|
|
bool IDisplayAnnotation.Collapsed => false;
|
}
|
|
[Display("Dialog", Group: "OpenTap", Description: "Shows a message to the user and waits for a response. " +
|
"A verdict can be set based on the response.",Order:1)]
|
public class DialogStep : TestStep
|
{
|
[Display("Message", Description: "The message shown to the user.", Order: 0.1)]
|
[Layout(LayoutMode.Normal, 2, maxRowHeight: 5)]
|
public string Message { get; set; }
|
|
[Display("Title", "The title of the dialog box.", Order: 0)]
|
public string Title { get; set; }
|
|
[Display("Buttons", "Selects what buttons the user gets presented with.", Order: 0.2)]
|
public InputButtons Buttons { get; set; }
|
|
[Display("If Yes/OK", "This is the verdict presented when the user clicks \"Yes\" or \"OK\".", Group: "Verdict", Order: 0.3, Collapsed: true)]
|
public Verdict PositiveAnswer { get; set; }
|
|
[EnabledIf("Buttons", InputButtons.OkCancel, InputButtons.YesNo)]
|
[Display("If No/Cancel", "This is the verdict presented when the user clicks \"No\" or \"Cancel\".", Group: "Verdict", Order: 0.4, Collapsed: true)]
|
public Verdict NegativeAnswer { get; set; }
|
|
[Display("Use Timeout", "Enabling this will make the dialog close as if No/Cancel was clicked after an amount of time.", Group: "Timeout", Order: 1, Collapsed: true)]
|
public bool UseTimeout { get; set; }
|
|
double timeout = 5;
|
|
[EnabledIf("UseTimeout", true)]
|
[Unit("s")]
|
[Display("Timeout", "After this time the dialog will return the default answer.", Group: "Timeout", Order: 2, Collapsed: true)]
|
public double Timeout
|
{
|
get { return timeout; }
|
set
|
{
|
if (value >= 0)
|
timeout = value;
|
else throw new Exception("Timeout must be greater than 0 seconds.");
|
|
}
|
}
|
|
[EnabledIf(nameof(UseTimeout), true)]
|
[Display("Default Verdict", "The verdict the step will have if timeout is reached", Group: "Timeout", Order: 1, Collapsed: true)]
|
public Verdict DefaultAnswer { get; set; }
|
|
[Display("Show Picture", "The dialog will include a picture if the environment supports it.", "Picture", Order: 0, Collapsed: true)]
|
public bool ShowPicture { get; set; }
|
|
[EnabledIf(nameof(ShowPicture), HideIfDisabled = true)]
|
public Picture Picture { get; } = new Picture();
|
|
[Display("Source", "The source of the picture. Can be a URL or a file path.", "Picture", Order: 2, Collapsed: true)]
|
[FilePath(FilePathAttribute.BehaviorChoice.Open)]
|
[EnabledIf(nameof(ShowPicture), HideIfDisabled = true)]
|
public string PictureSource
|
{
|
get => Picture.Source;
|
set => Picture.Source = value;
|
}
|
|
[Display("Description", "A description of the picture. This is usually displayed in a mouseover tooltip, or if the picture fails to load.", "Picture", Order: 3, Collapsed: true)]
|
[EnabledIf(nameof(ShowPicture), HideIfDisabled = true)]
|
public string PictureDescription
|
{
|
get => Picture.Description;
|
set => Picture.Description = value;
|
}
|
|
public DialogStep()
|
{
|
Message = "Message";
|
Title = "Title";
|
|
Rules.Add(() => !string.IsNullOrWhiteSpace(Title), "Title is empty", Title);
|
Rules.Add(() => !string.IsNullOrWhiteSpace(Message), "Message is empty", Message);
|
}
|
|
public override void Run()
|
{
|
Verdict answer = DefaultAnswer;
|
var req = new DialogRequest(Title, Message) { Buttons = Buttons, Picture = ShowPicture ? Picture : null };
|
try
|
{
|
var timeout = TimeSpan.FromSeconds(Timeout);
|
if (timeout == TimeSpan.Zero)
|
timeout = TimeSpan.FromSeconds(0.001);
|
if (UseTimeout == false)
|
timeout = TimeSpan.MaxValue;
|
UserInput.Request(req, timeout, false);
|
|
if (Buttons == InputButtons.OkCancel)
|
{
|
answer = req.Input2 == WaitForInputResult2.Ok ? PositiveAnswer : NegativeAnswer;
|
}
|
else
|
{
|
answer = req.Input1 == WaitForInputResult1.Yes ? PositiveAnswer : NegativeAnswer;
|
}
|
}
|
catch (TimeoutException)
|
{
|
|
}
|
|
Verdict = answer;
|
}
|
}
|
|
class DialogStepCompatibilitSerializer : ITapSerializerPlugin
|
{
|
public double Order => 2;
|
|
// Box:
|
// A place to put a value.
|
// Since the step is not available when the property is deserialized.
|
// we create a box, where the step value can be put at a later point.
|
// then in Defer we get the step inside the box.
|
class Box
|
{
|
public DialogStep Step;
|
}
|
|
static readonly string legacyNotSetName = "Not_Set";
|
static readonly XName legacyDefaultAnswerPropertyName = "DefaultAnswer";
|
static readonly XName TestStepName = nameof(TestStep);
|
|
Box currentBox;
|
public bool Deserialize(XElement node, ITypeData t, Action<object> setter)
|
{
|
if (t.IsA(typeof(Verdict)))
|
{
|
if(node.Value == legacyNotSetName)
|
{
|
node.SetValue(nameof(Verdict.NotSet));
|
return TapSerializer.GetCurrentSerializer().Serialize(node, setter, t);
|
}
|
}
|
|
if(node.Name == TestStepName && t.DescendsTo(typeof(DialogStep)))
|
{
|
if (currentBox != null) return false;
|
|
currentBox = new Box();
|
var serializer = TapSerializer.GetCurrentSerializer();
|
return serializer.Deserialize(node, x =>
|
{
|
currentBox.Step = (DialogStep)x;
|
setter(x);
|
}, t);
|
|
}
|
else if(currentBox != null && node.Name == legacyDefaultAnswerPropertyName)
|
{
|
if(bool.TryParse(node.Value, out bool defaultAnswer))
|
{
|
node.Remove();
|
var serializer = TapSerializer.GetCurrentSerializer();
|
var thisbox = currentBox;
|
serializer.DeferLoad(() =>
|
{
|
if (thisbox.Step == null) return;
|
if (defaultAnswer)
|
{
|
thisbox.Step.DefaultAnswer = thisbox.Step.PositiveAnswer;
|
}
|
else
|
{
|
thisbox.Step.DefaultAnswer = thisbox.Step.NegativeAnswer;
|
}
|
});
|
return true;
|
}
|
|
}
|
return false;
|
}
|
|
public bool Serialize(XElement node, object obj, ITypeData expectedType)
|
{
|
return false;
|
}
|
}
|
}
|
