internal TestNodeInternal(TestHost host, ITestParameter parameter = null, TestFlags?flags = null)
{
Host = host;
Flags = flags ?? host.Flags;
Parameter = host.HasFixedParameter ? host.GetFixedParameter() : parameter;
}
protected TestBuilder(string identifier, string name, ITestParameter parameter)
{
Identifier = identifier;
Name = name;
TestName = name != null ? new TestName(name) : TestName.Empty;
Parameter = parameter;
}
public TestPath Parameterize(ITestParameter parameter)
{
if (!IsParameterized)
{
throw new InternalErrorException();
}
return(new TestPath(Host, Parent, parameter));
}
TestPathTreeNode Parameterize(ITestParameter parameter)
{
var newPath = Path.Parameterize(parameter);
var newNode = new TestPathTreeNode(Tree, newPath, (TestNodeInternal)newPath.Node);
newNode.parameterized = true;
return(newNode);
}
public override TestNode Parameterize(ITestParameter parameter)
{
if (!IsParameterized)
{
throw new InternalErrorException();
}
return(new TestNodeInternal(Host, parameter, Flags));
}
protected TestBuilder(TestPathType type, string identifier, string name, ITestParameter parameter, TestFlags flags = DefaultFlags)
{
PathType = type;
Identifier = identifier;
Name = name;
Flags = flags;
Parameter = parameter;
}
TestPathNode Parameterize(ITestParameter parameter)
{
var newPath = Path.Parameterize(parameter);
var newNode = new TestPathNode(Tree, newPath);
newNode.parameterized = true;
return(newNode);
}
internal TestPath(TestHost host, TestPath parent, ITestParameter parameter = null)
{
Host = host;
Flags = host.Flags;
Parent = parent;
this.parameter = host.HasFixedParameter ? host.GetFixedParameter() : parameter;
this.name = GetTestName(host, parent, this.parameter);
}
internal T Deserialize(ITestParameter parameter)
{
if (Serializer != null)
{
return((T)Serializer.ParameterToObject(parameter));
}
return((T)parameter);
}
internal T Deserialize(ITestParameter parameter)
{
var serialized = parameter;
if (Serializer != null)
{
return((T)Serializer.ParameterToObject(serialized));
}
return((T)serialized);
}
public FixedParameterHost(string name, TypeInfo type, IParameterSerializer serializer, FixedTestParameterAttribute attr, TestFlags flags)
: base(name, type, serializer, flags)
{
Attribute = attr;
if (Serializer != null)
{
fixedParameter = Serializer.ObjectToParameter(Attribute.Value);
}
else
{
fixedParameter = (ITestParameter)Attribute.Value;
}
}
public virtual void TestEnumDefault()
{
ITestObject obj = NewTestObject <Object1>();
ITestAction a1 = obj.GetAction("Do Something Else");
ITestParameter p1 = a1.Parameters.First();
ITestParameter p2 = a1.Parameters.Last();
ITestNaked def1 = p1.GetDefault();
ITestNaked def2 = p2.GetDefault();
Assert.AreEqual(TestEnum.Value2, def1.NakedObject.Object);
Assert.AreEqual(null, def2);
}
static XElement WritePathNode(IPathNode node, ITestParameter parameter)
{
var element = new XElement(ParameterName);
element.Add(new XAttribute("Identifier", node.Identifier));
if (node.Name != null)
{
element.Add(new XAttribute("Name", node.Name));
}
if (node.ParameterType != null)
{
element.Add(new XAttribute("ParameterType", node.ParameterType));
}
if (parameter != null)
{
element.Add(new XAttribute("Parameter", parameter.Value));
}
return(element);
}
static TestName GetTestName(TestHost host, TestPath parent, ITestParameter parameter = null)
{
var builder = new TestNameBuilder();
if (parent != null)
{
builder.Merge(parent.name);
}
if (host.Name != null)
{
if (parameter != null && ((host.Flags & TestFlags.PathHidden) == 0))
{
builder.PushParameter(host.Name, parameter.Value, (host.Flags & TestFlags.Hidden) != 0);
}
else if ((host.Flags & TestFlags.Hidden) == 0)
{
builder.PushName(host.Name);
}
}
return(builder.GetName());
}
public ParameterSourceValue(ParameterizedTestInstance instance, ITestParameter parameter, object value)
: base(instance, value)
{
this.parameter = parameter;
}
public override TestNode Parameterize(ITestParameter parameter)
{
throw new InternalErrorException();
}
public object ParameterToObject(ITestParameter value)
{
return(((ParameterWrapper)value).Value);
}
public abstract TestNode Parameterize(ITestParameter parameter);
public FixedValue(FixedParameterInstance <T> instance, ITestParameter parameter, object value)
: base(instance, value)
{
this.parameter = parameter;
}
public TestPath Parameterize(ITestParameter parameter)
{
var parameterized = Node.Parameterize(parameter);
return(new TestPath(Parent, parameterized));
}
internal TestNode CreateNode(ITestParameter parameter = null, TestFlags?flags = null)
{
return(new TestNodeInternal(this, parameter, flags));
}
