public void SetValueWithTypeConversionForInconvertibleTypes()
{
ReflectorMember member = ReflectorMember.Create(GetMember("Count"));
TestClass testClass = new TestClass();
member.SetValue(testClass, "inconvertible");
}
public void SettingValueThrowsException()
{
ReflectorMember member = ReflectorMember.Create(typeof(ExceptionTestClass).GetProperty("ExceptionProperty"));
ExceptionTestClass testClass = new ExceptionTestClass();
member.SetValue(testClass, null);
}
public void SetValueWhenNoSet()
{
PropertyInfo readonlyNameProperty = typeof(ReadOnlMemberClass).GetProperty("ReadOnlyName");
ReflectorMember member = ReflectorMember.Create(readonlyNameProperty);
ReadOnlMemberClass testClass = new ReadOnlMemberClass();
member.SetValue(testClass, "Hello");
}
public void SetValueToNull()
{
ReflectorMember member = ReflectorMember.Create(GetMember("InnerClass"));
TestClass testClass = new TestClass();
member.SetValue(testClass, null);
Assert.IsNull(testClass.InnerClass);
}
public void SetValueWithTypeConversion()
{
ReflectorMember member = ReflectorMember.Create(GetMember("Count"));
TestClass testClass = new TestClass();
member.SetValue(testClass, "99");
Assert.AreEqual(99, testClass.Count);
}
public void SetValue()
{
ReflectorMember member = ReflectorMember.Create(GetMember("Name"));
TestClass testClass = new TestClass();
member.SetValue(testClass, "Hello");
Assert.AreEqual("Hello", testClass.Name);
}
public void ShouldCreateCollectionSerialiserWhenInstanceTypeIsCollection()
{
FieldInfo field = typeof(CollectionTestClass).GetField("Stuff");
attribute = (ReflectorPropertyAttribute)field.GetCustomAttributes(false)[0];
IXmlSerialiser serialiser = factory.Create(ReflectorMember.Create(field), attribute);
Assert.AreEqual(typeof(XmlCollectionSerialiser), serialiser.GetType());
}
public void ShouldCreateCollectionSerialiserWhenCollectionPropertyIsPassed()
{
DefaultSerialiserFactory factory = new DefaultSerialiserFactory();
PropertyInfo property = typeof(Project).GetProperty("Triggers");
ReflectorPropertyAttribute attribute = (ReflectorPropertyAttribute)property.GetCustomAttributes(false)[0];
IXmlSerialiser serialiser = factory.Create(ReflectorMember.Create(property), attribute);
Assert.AreEqual(typeof(XmlCollectionSerialiser), serialiser.GetType());
}
public void SetValueOfSubClass()
{
ReflectorMember member = ReflectorMember.Create(GetMember("InnerClass"));
TestClass testClass = new TestClass();
member.SetValue(testClass, new TestSubClass());
Assert.IsNotNull(testClass.InnerClass);
Assert.AreEqual(typeof(TestSubClass), testClass.InnerClass.GetType());
}
public IXmlMemberSerialiser Create(ReflectorMember memberInfo, ReflectorPropertyAttribute attribute)
{
if (attribute.InstanceType == null || attribute.InstanceType.Equals(typeof(string)))
{
return(new StringJTokenSerializer(memberInfo, attribute));
}
else
{
throw new System.NotSupportedException(attribute.InstanceType.Name);
}
}
public IXmlMemberSerialiser Create(ReflectorMember member, ReflectorPropertyAttribute attribute)
{
if (member.MemberType.IsArray)
{
return(new XmlArraySerialiser(member, attribute));
}
else if (typeof(ICollection).IsAssignableFrom(member.MemberType) ||
(attribute.InstanceType != null && typeof(ICollection).IsAssignableFrom(attribute.InstanceType)))
{
return(new XmlCollectionSerialiser(member, attribute));
}
return(new XmlMemberSerialiser(member, attribute));
}
/// <summary>
/// Writes to the specified writer.
/// </summary>
/// <param name="writer">The writer to use.</param>
/// <param name="target">The URI to write.</param>
public override void Write(XmlWriter writer, object target)
{
if (!(target is Uri))
{
target = ReflectorMember.GetValue(target);
}
var uri = target as Uri;
if (uri != null)
{
writer.WriteElementString("uri", uri.ToString());
}
}
private IEnumerable InitialiseMemberSerialisers()
{
SortedList serialisers = new SortedList();
foreach (MemberInfo member in type.GetMembers())
{
ReflectorPropertyAttribute attribute = ReflectorPropertyAttribute.GetAttribute(member);
if (attribute != null)
{
serialisers.Add(member.Name, attribute.CreateSerialiser(ReflectorMember.Create(member)));
}
}
return(serialisers.Values);
}
public void AutomaticallyParseStringIntoEnum()
{
ReflectorMember member = ReflectorMember.Create(typeof(EnumTestClass).GetField("EnumValue"));
Assert.IsNotNull(member, "member not found");
EnumTestClass testClass = new EnumTestClass();
Assert.AreEqual(TestEnum.D, testClass.EnumValue);
member.SetValue(testClass, TestEnum.A); // set value as enum
Assert.AreEqual(TestEnum.A, testClass.EnumValue);
member.SetValue(testClass, "B"); // set value as string
Assert.AreEqual(TestEnum.B, testClass.EnumValue);
member.SetValue(testClass, "c"); // set value as string
Assert.AreEqual(TestEnum.C, testClass.EnumValue);
}
/// <summary>
/// Writes the specified writer.
/// </summary>
/// <param name="writer">The writer.</param>
/// <param name="target">The target.</param>
/// <remarks></remarks>
public override void Write(XmlWriter writer, object target)
{
if (target == null)
{
return;
}
if (!(target is Timeout))
{
target = ReflectorMember.GetValue(target);
}
Timeout to = target as Timeout;
if (to != null)
{
to.Write(writer);
}
}
/// <summary>
/// Creates the specified serialiser.
/// </summary>
/// <param name="memberInfo">The member info.</param>
/// <param name="attribute">The attribute defining the serialiser.</param>
/// <returns>A new instance of <see cref="NetworkCredentialsSerializer"/>.</returns>
public IXmlMemberSerialiser Create(ReflectorMember memberInfo, ReflectorPropertyAttribute attribute)
{
return(new NetworkCredentialsSerializer(memberInfo, attribute));
}
public IXmlMemberSerialiser Create(ReflectorMember memberInfo, ReflectorPropertyAttribute attribute)
{
return(new BindingsSerializer(memberInfo, attribute));
}
public void ShouldCreateCollectionSerialiserWhenCollectionPropertyIsPassed()
{
IXmlSerialiser serialiser = factory.Create(ReflectorMember.Create(typeof(CollectionTestClass).GetProperty("List")), attribute);
Assert.AreEqual(typeof(XmlCollectionSerialiser), serialiser.GetType());
}
public TimeoutSerializer(ReflectorMember info, ReflectorPropertyAttribute attribute) : base(info, attribute)
{
}
/// <summary>
/// Initialise a new <see cref="MergeFileSerialiser"/>.
/// </summary>
/// <param name="info"></param>
/// <param name="attribute"></param>
public MergeFileSerialiser(ReflectorMember info, ReflectorPropertyAttribute attribute)
: base(info, attribute)
{
}
public void ShouldCreateArraySerialiserWhenArrayPropertyIsPassed()
{
IXmlSerialiser serialiser = factory.Create(ReflectorMember.Create(typeof(ArrayTestClass).GetProperty("Elements")), attribute);
Assert.AreEqual(typeof(XmlArraySerialiser), serialiser.GetType());
}
private IXmlSerialiser GetMemberSerialiser(PropertyInfo prop)
{
var reflectorPropertyAttribute = prop.GetCustomAttribute <ReflectorPropertyAttribute>();
return(reflectorPropertyAttribute.CreateSerialiser(ReflectorMember.Create(prop)));
}
public XmlMemberSerialiser(ReflectorMember member, ReflectorPropertyAttribute attribute)
{
this.member = member;
this.attribute = attribute;
this.instantiator = new DefaultInstantiator();
}
/// <summary>
/// Initialise a new <see cref="NameValuePairSerialiser"/>.
/// </summary>
/// <param name="info"></param>
/// <param name="attribute"></param>
/// <param name="isList"></param>
public NameValuePairSerialiser(ReflectorMember info, ReflectorPropertyAttribute attribute, bool isList)
: base(info, attribute)
{
this.isList = isList;
}
/// <summary>
/// Create the serialiser.
/// </summary>
/// <param name="memberInfo"></param>
/// <param name="attribute"></param>
/// <returns></returns>
public IXmlMemberSerialiser Create(ReflectorMember memberInfo, ReflectorPropertyAttribute attribute)
{
return(new NameValuePairSerialiser(memberInfo, attribute, true));
}
public WsIdCollectionSerializer(ReflectorMember member,
ReflectorPropertyAttribute attribute)
: base(member, attribute)
{
}
public IXmlMemberSerialiser Create(ReflectorMember member,
ReflectorPropertyAttribute attribute)
{
return(new WsIdCollectionSerializer(member, attribute));
}
public VirtualDirectorySerializer(ReflectorMember member, ReflectorPropertyAttribute attribute) : base(member, attribute)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="NetworkCredentialsSerializer"/> class.
/// </summary>
/// <param name="member">The member to use.</param>
/// <param name="attribute">The attribute defining the serialiser.</param>
public NetworkCredentialsSerializer(ReflectorMember member, ReflectorPropertyAttribute attribute)
: base(member, attribute)
{
}
public IXmlMemberSerialiser Create(ReflectorMember memberInfo, ReflectorPropertyAttribute attribute)
{
return(new BuildReportXslFilenameSerialiser(memberInfo, attribute));
}
