public void Protected_CP_FullTrust_DontAllowProtectedMembersOnRoot()
{
XamlType typeOfProtectedRecursive = xsc.GetXamlType(typeof(Test.Properties.ProtectedRecursive));
XamlMember unknownContentProp = new XamlMember("Recurse", typeOfProtectedRecursive, false);
Node[] nodes = new Node[] {
new NS(new NamespaceDeclaration("clr-namespace:Test.Properties;assembly=XamlTestClasses", "")),
new SO(typeOfProtectedRecursive),
new SM(unknownContentProp),
new SO(typeOfProtectedRecursive),
new SM(unknownContentProp),
new SO(typeOfProtectedRecursive),
new EO(),
new EM(),
new EO(),
new EM(),
new EO()
};
CheckXmlToNodes(Protected_CP_Xml, nodes);
}
public void GetValueArrayExtension()
{
var xt = sctx.GetXamlType(typeof(TestClass));
var xm = xt.GetMember("ArrayMember");
Assert.IsNotNull(xm, "#-1");
Assert.AreEqual(XamlLanguage.Array, xm.Type, "#0");
var o = xm.Invoker.GetValue(new TestClass());
Assert.AreEqual(typeof(ArrayExtension), o.GetType(), "#1");
}
public void TestDeferredLoaderProperty()
{
var sc = new XamlSchemaContext();
var xt = sc.GetXamlType(typeof(DeferredLoadingContainerMember));
var xm = xt.GetMember("Child");
Assert.IsNotNull(xm.DeferringLoader, "#1 Deferring Loader should be set on member");
Assert.IsNull(xm.Type.DeferringLoader, "#2 Not set on type, should be null");
Assert.AreEqual(typeof(TestDeferredLoader), xm.DeferringLoader.ConverterType, "#3");
Assert.IsNull(xm.DeferringLoader.TargetType, "#4 This should be null for some reason");
}
internal static XamlType GetXamlTypeFromString(string typeName, NamespaceTable namespaceTable, XamlSchemaContext xsc)
{
XamlTypeName xamlTypeName = XamlTypeName.Parse(typeName, namespaceTable);
XamlType xamlType = xsc.GetXamlType(xamlTypeName);
if (xamlType == null)
{
xamlType = GetXamlTypeFromXamlTypeName(xamlTypeName, namespaceTable, xsc);
}
return(xamlType);
}
public void AttachableMemberTypeShouldBeCorrect()
{
var ctx = new XamlSchemaContext();
var xt = ctx.GetXamlType(typeof(AttachedWrapper5));
Assert.IsNotNull(xt, "#1");
var xm = xt.GetAttachableMember("SomeCollection");
Assert.IsNotNull(xm, "#2");
Assert.AreEqual(typeof(List <TestClass4>), xm.Type.UnderlyingType, "#3");
}
private static XamlMember GetXamlMember(XamlSchemaContext schemaContext, Type type, string memberName)
{
XamlType xamlType = schemaContext.GetXamlType(type);
if (xamlType == null)
{
return(null);
}
XamlMember xamlMember = xamlType.GetMember(memberName);
return(xamlMember);
}
public void WriteValueAsString()
{
var sw = new StringWriter();
var xw = new XamlXmlWriter(sw, sctx, null);
var xt = sctx.GetXamlType(typeof(TestXmlWriterClass1));
xw.WriteStartObject(xt);
xw.WriteStartMember(xt.GetMember("Foo"));
xw.WriteValue("50");
xw.Close();
string xml = String.Format(@"<?xml version='1.0' encoding='utf-16'?><TestXmlWriterClass1 xmlns='clr-namespace:MonoTests.System.Xaml;assembly={0}' xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'></TestXmlWriterClass1>", GetType().Assembly.GetName().Name);
}
public void TestDeferredLoaderType()
{
var sc = new XamlSchemaContext();
var xt = sc.GetXamlType(typeof(DeferredLoadingContainerType));
var xm = xt.GetMember("Child");
Assert.IsNotNull(xm.DeferringLoader, "#1 Deferring Loader should be set on member");
Assert.IsNotNull(xm.Type.DeferringLoader, "#2 Deferring Loader should be set on type");
Assert.IsTrue(ReferenceEquals(xm.DeferringLoader, xm.Type.DeferringLoader), "#3 Deferring loaders should be the same instance from type or member");
Assert.AreEqual(typeof(TestDeferredLoader2), xm.DeferringLoader.ConverterType, "#3");
Assert.IsNull(xm.DeferringLoader.TargetType, "#4 This should be null for some reason");
}
public void DictItemValueNodeNull()
{
XamlSchemaContext c = new XamlSchemaContext();
XamlObjectWriter w = new XamlObjectWriter(c);
w.WriteNamespace(new NamespaceDeclaration("http://schemas.microsoft.com/winfx/2006/xaml", "x"));
w.WriteNamespace(new NamespaceDeclaration("clr-namespace:System.Collections.Generic;assembly=mscorlib", "g"));
w.WriteStartObject(c.GetXamlType(typeof(Dictionary <string, object>)));
w.WriteStartMember(XamlLanguage.Items);
w.WriteValue(null);
w.WriteEndMember();
w.WriteEndObject();
}
void SetupWriterService()
{
var obj = new TestValueSerialized();
var ctx = new XamlSchemaContext();
var xw = new XamlObjectWriter(ctx);
var xt = ctx.GetXamlType(obj.GetType());
xw.WriteStartObject(xt);
xw.WriteStartMember(XamlLanguage.Initialization);
xw.WriteValue("v");
xw.WriteEndMember();
xw.Close();
}
public void GetTypeFromXamlTypeNameWithClrName()
{
// ensure that this does *not* resolve clr type name.
var xn = new XamlTypeName("clr-namespace:System;assembly=mscorlib", "DateTime");
var ctx = NewStandardContext();
var xt = ctx.GetXamlType(xn);
Assert.IsNull(xt, "#1");
ctx = new XamlSchemaContext();
xt = ctx.GetXamlType(xn);
Assert.IsNotNull(xt, "#2");
}
public XamlDomObject(Type type, XamlSchemaContext schemaContext)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (schemaContext == null)
{
throw new ArgumentNullException("schemaContext");
}
_type = schemaContext.GetXamlType(type);
}
public void AllAttachableMembersPreferPublics()
{
var xsc = new XamlSchemaContext();
var AOP = xsc.GetXamlType(typeof(AOP));
var members = AOP.GetAllAttachableMembers();
Assert.AreEqual(1, members.Count);
var enumerator = members.GetEnumerator();
enumerator.MoveNext();
XamlMember member = enumerator.Current;
Assert.IsTrue(member.IsWriteOnly);
}
public void TestGO_2()
{
XamlSchemaContext context = new XamlSchemaContext();
XamlObjectWriter objWriter = new XamlObjectWriter(context);
XamlType type = context.GetXamlType(typeof(Element10));
objWriter.WriteStartObject(type);
objWriter.WriteGetObject();
objWriter.Clear();
objWriter.Close();
}
public void TestSM_1()
{
XamlSchemaContext context = new XamlSchemaContext();
XamlObjectWriter objWriter = new XamlObjectWriter(context);
XamlType type = context.GetXamlType(typeof(Element10));
XamlMember member = type.GetMember("Element3");
/* should fail here */
objWriter.WriteStartMember(member);
objWriter.Clear();
objWriter.Close();
}
internal new static List <XamlDomObject> CreateObject(XElement tag, XamlSchemaContext schema)
{
var domObjects = new List <XamlDomObject>();
Debug.Assert(tag != null);
// Create the view and canvas
var listBoxItem = new XamlDomObject(schema.GetXamlType(typeof(ListBoxItem)));
SetCommonProperties(tag, listBoxItem);
domObjects.Add(listBoxItem);
return(domObjects);
}
void RemoveConnectionIds(XamlNode node, Dictionary <int, EventRegistration[]> eventMappings, XamlSchemaContext context)
{
foreach (XamlNode child in node.Children)
{
RemoveConnectionIds(child, eventMappings, context);
}
XamlObjectNode obj = node as XamlObjectNode;
if (obj != null && obj.Children.Count > 0)
{
var removableNodes = new List <XamlMemberNode>();
var addableNodes = new List <XamlMemberNode>();
foreach (XamlMemberNode memberNode in obj.Children.OfType <XamlMemberNode>())
{
if (memberNode.Member == XamlLanguage.ConnectionId && memberNode.Children.Single() is XamlValueNode)
{
var value = memberNode.Children.Single() as XamlValueNode;
int id;
if (value.Value is string && int.TryParse(value.Value as string, out id) && eventMappings.ContainsKey(id))
{
var map = eventMappings[id];
foreach (var entry in map)
{
if (entry.IsAttached)
{
var type = context.GetXamlType(Type.GetType(entry.AttachSourceType));
var member = new XamlMemberNode(new XamlMember(entry.EventName, type, true));
member.Children.Add(new XamlValueNode(entry.MethodName));
addableNodes.Add(member);
}
else
{
var member = new XamlMemberNode(obj.Type.GetMember(entry.EventName));
member.Children.Add(new XamlValueNode(entry.MethodName));
addableNodes.Add(member);
}
}
removableNodes.Add(memberNode);
}
}
}
foreach (var rnode in removableNodes)
{
node.Children.Remove(rnode);
}
node.Children.InsertRange(node.Children.Count > 1 ? node.Children.Count - 1 : 0, addableNodes);
}
}
public void TestV_2()
{
XamlSchemaContext context = new XamlSchemaContext();
XamlObjectWriter objWriter = new XamlObjectWriter(context);
XamlType type = context.GetXamlType(typeof(Element10));
objWriter.WriteStartObject(type);
/* should fail here */
objWriter.WriteValue("XYZZY-42");
objWriter.Clear();
objWriter.Close();
}
public void WriteEventWithAMarkupExtensionReturingADelegate()
{
XamlSchemaContext xsc = new XamlSchemaContext();
XamlObjectWriter ow = new XamlObjectWriter(xsc);
XamlType eventElementXT = xsc.GetXamlType(typeof(EventElement));
XamlType delegateCreatingMeXT = xsc.GetXamlType(typeof(DelegateCreatingME));
ow.WriteStartObject(eventElementXT);
ow.WriteStartMember(eventElementXT.GetMember("Tap"));
ow.WriteStartObject(delegateCreatingMeXT);
ow.WriteEndObject();
ow.WriteEndMember();
ow.WriteEndObject();
EventElement eventElement = ((EventElement)ow.Result);
int fireCount = eventElement.TapEventCount;
eventElement.RaiseTapEvent();
if (eventElement.TapEventCount != fireCount + 1)
{
throw new Exception("Tap event did not fire");
}
}
private void TestSetup()
{
_mainReader = null;
_mainWriter = null;
_removeProperty = null;
_removeType = null;
_xamlSchemaContext = null;
_xamlSchemaContext = new XamlSchemaContext();
string elementXns = "clr-namespace:Test.Elements;assembly=XamlTestClasses";
XamlType element3 = _xamlSchemaContext.GetXamlType(elementXns, "Element10");
// Remove the Property "Element2"
_removeProperty = element3.GetMember("Element2");
// Remove all instances of "HoldsOneElement"
_removeType = _xamlSchemaContext.GetXamlType(elementXns, "HoldsOneElement");
StringReader stringReader = new StringReader(SubtreeXAML);
XmlReader xmlReader = XmlReader.Create(stringReader);
_mainReader = new XamlXmlReader(xmlReader, _xamlSchemaContext);
_mainWriter = new XamlObjectWriter(_xamlSchemaContext);
}
public void EmptyStringTest()
{
var generated = new StringBuilder();
var xmlSettings = new XmlWriterSettings {
Indent = true, OmitXmlDeclaration = true
};
var xamlSettings = new XamlXmlWriterSettings {
CloseOutput = true
};
var xsc = new XamlSchemaContext();
using (System.Xaml.XamlXmlWriter writer = new System.Xaml.XamlXmlWriter(XmlWriter.Create(new StringWriter(generated), xmlSettings), xsc, xamlSettings))
{
var developerType = xsc.GetXamlType(typeof(Developer));
var developerExtensionType = xsc.GetXamlType(typeof(DeveloperExtension));
writer.WriteNamespace(new NamespaceDeclaration(XamlLanguage.Xaml2006Namespace, "x"));
writer.WriteStartObject(developerType);
writer.WriteStartMember(developerType.GetMember("Name"));
writer.WriteValue("Andrew");
writer.WriteEndMember();
writer.WriteStartMember(developerType.GetMember("Friend"));
writer.WriteStartObject(developerExtensionType);
writer.WriteStartMember(developerExtensionType.GetMember("Name"));
writer.WriteValue("");
writer.WriteEndMember();
writer.WriteEndObject();
writer.WriteEndMember();
writer.WriteEndObject();
}
var target = @"<Developer Name=""Andrew"" Friend=""{Developer Name=""}"" xmlns=""clr-namespace:Test.Elements;assembly=XamlTestClasses"" xmlns:x=""http://schemas.microsoft.com/winfx/2006/xaml"" />";
Assert.AreEqual(target, generated.ToString());
}
internal new static List <XamlDomObject> CreateObject(XElement tag, XamlSchemaContext schema)
{
var domObjects = new List <XamlDomObject>();
var listBox = new XamlDomObject(schema.GetXamlType(typeof(ListBox)));
var childrenMember = new XamlDomMember(listBox.Type.ContentProperty);
listBox.MemberNodes.Add(childrenMember);
var titles = GetElementWithMatchingAttribute(tag, "key", "IBSegmentTitles");
Debug.Assert(titles != null);
foreach (var title in titles.Elements(XName.Get("string")))
{
childrenMember.Items.Add(new XamlDomObject(schema.GetXamlType(typeof(ListBoxItem)),
new XamlDomMember(XamlLanguage.Initialization, title.Value)));
}
SetCommonProperties(tag, listBox);
domObjects.Add(listBox);
return(domObjects);
}
public void Read_NamedItemWithEmptyString()
{
var obj = new NamedItem("");
var ctx = new XamlSchemaContext();
var xr = new XamlObjectReader(obj, ctx);
ReadNamespace(xr, "", Compat.TestAssemblyNamespace, "ns1");
ReadObject(xr, ctx.GetXamlType(typeof(NamedItem)), "#1", xt =>
{
ReadMember(xr, xt.GetMember("ItemName"), "#2", xm =>
{
ReadValue(xr, string.Empty, "#3");
});
});
}
public void Read_ObjectWithShouldSerialize2()
{
var obj = new TestObjectWithShouldSerialize {
Text = "bar"
};
var ctx = new XamlSchemaContext();
var xr = new XamlObjectReader(obj, ctx);
ReadNamespace(xr, "", Compat.TestAssemblyNamespace, "ns1");
ReadObject(xr, ctx.GetXamlType(typeof(TestObjectWithShouldSerialize)), "#1", xt =>
{
// no members
});
Assert.IsFalse(xr.Read());
Assert.IsTrue(obj.ShouldSerializeCalled > 0);
}
internal XamlMember(EventInfo eventInfo, XamlSchemaContext schemaContext, XamlMemberInvoker invoker, MemberReflector reflector)
{
if (eventInfo == null)
{
throw new ArgumentNullException(nameof(eventInfo));
}
if (schemaContext == null)
{
throw new ArgumentNullException(nameof(schemaContext));
}
_name = eventInfo.Name;
_declaringType = schemaContext.GetXamlType(eventInfo.DeclaringType);
_memberType = MemberType.Instance;
_reflector = reflector;
_reflector.Invoker = invoker;
_underlyingMember.Value = eventInfo;
}
public void TestSO_2()
{
XamlSchemaContext context = new XamlSchemaContext();
XamlObjectWriter objWriter = new XamlObjectWriter(context);
XamlType type = context.GetXamlType(typeof(Element10));
objWriter.WriteStartObject(type);
var ns = new NamespaceDeclaration("http://schemas.microsoft.com/winfx/2006/xaml", "xx");
/* should fail here */
objWriter.WriteNamespace(ns);
objWriter.Clear();
objWriter.Close();
}
// support method.
static XamlObjectWriter Setup_SO_SM_V()
{
XamlSchemaContext context = new XamlSchemaContext();
XamlObjectWriter objWriter = new XamlObjectWriter(context);
XamlType type = context.GetXamlType(typeof(Object10));
objWriter.WriteStartObject(type);
XamlMember member = type.GetMember("Object0");
objWriter.WriteStartMember(member);
objWriter.WriteValue("XYZZY-42");
return(objWriter);
}
// Setters and triggers may have a sourceName which we need to resolve
// This only works in templates and it works by looking up the mapping between
// name and type in the template. We use ambient lookup to find the Template property
// and then query it for the type.
private static Type GetTypeFromName(XamlSchemaContext schemaContext,
IAmbientProvider ambientProvider,
string target)
{
XamlType frameworkTemplateXType = schemaContext.GetXamlType(typeof(FrameworkTemplate));
XamlMember templateProperty = frameworkTemplateXType.GetMember("Template");
AmbientPropertyValue ambientValue =
ambientProvider.GetFirstAmbientValue(new XamlType[] { frameworkTemplateXType }, templateProperty);
TemplateContent templateHolder =
ambientValue.Value as System.Windows.TemplateContent;
if (templateHolder != null)
{
return(templateHolder.GetTypeForName(target).UnderlyingType);
}
return(null);
}
internal static object ConvertSetterValue(ITypeDescriptorContext dcontext, XamlSchemaContext context, CultureInfo info, Setter setter, object value)
{
Type targetType = setter?.Property?.PropertyType;
if (targetType == null)
{
return(value);
}
var ttConv = context.GetXamlType(targetType)?.TypeConverter?.ConverterInstance;
if (ttConv != null)
{
value = ttConv.ConvertFromString(dcontext, info, value as string);
}
return(value);
}
public static ParsedMarkupExtensionInfo Parse (string raw, IXamlNamespaceResolver nsResolver, XamlSchemaContext sctx)
{
if (raw == null)
throw new ArgumentNullException ("raw");
if (raw.Length == 0 || raw [0] != '{')
throw Error ("Invalid markup extension attribute. It should begin with '{{', but was {0}", raw);
var ret = new ParsedMarkupExtensionInfo ();
int idx = raw.IndexOf ('}');
if (idx < 0)
throw Error ("Expected '}}' in the markup extension attribute: '{0}'", raw);
raw = raw.Substring (1, idx - 1);
idx = raw.IndexOf (' ');
string name = idx < 0 ? raw : raw.Substring (0, idx);
XamlTypeName xtn;
if (!XamlTypeName.TryParse (name, nsResolver, out xtn))
throw Error ("Failed to parse type name '{0}'", name);
var xt = sctx.GetXamlType (xtn);
ret.Type = xt;
if (idx < 0)
return ret;
string [] vpairs = raw.Substring (idx + 1, raw.Length - idx - 1).Split (',');
List<string> posPrms = null;
foreach (string vpair in vpairs) {
idx = vpair.IndexOf ('=');
// FIXME: unescape string (e.g. comma)
if (idx < 0) {
if (posPrms == null) {
posPrms = new List<string> ();
ret.Arguments.Add (XamlLanguage.PositionalParameters, posPrms);
}
posPrms.Add (UnescapeValue (vpair.Trim ()));
} else {
var key = vpair.Substring (0, idx).Trim ();
// FIXME: is unknown member always isAttacheable = false?
var xm = xt.GetMember (key) ?? new XamlMember (key, xt, false);
ret.Arguments.Add (xm, UnescapeValue (vpair.Substring (idx + 1).Trim ()));
}
}
return ret;
}
static LocalClass BuildSomething()
{
XamlSchemaContext schema = new XamlSchemaContext();
XamlObjectWriter xow = new XamlObjectWriter(schema);
XamlType xamlType = schema.GetXamlType(typeof(LocalClass));
XamlMember xamlProperty = xamlType.GetMember("Title");
xow.WriteStartObject(xamlType);
xow.WriteStartMember(xamlProperty);
xow.WriteValue("This is a string");
xow.WriteEndMember();
xow.WriteEndObject();
object o = xow.Result;
LocalClass local = (LocalClass)o;
return(local);
}
void ProcessAttributesToMember (XamlSchemaContext sctx, StartTagInfo sti, XamlType xt)
{
foreach (var p in sti.Attributes) {
int idx = p.Key.IndexOf (':');
string prefix = idx > 0 ? p.Key.Substring (0, idx) : String.Empty;
string aname = idx > 0 ? p.Key.Substring (idx + 1) : p.Key;
idx = aname.IndexOf ('.');
if (idx > 0) {
string apns = prefix.Length > 0 ? r.LookupNamespace (prefix) : r.NamespaceURI;
var apname = aname.Substring (0, idx);
var axtn = new XamlTypeName (apns, apname, null);
var at = sctx.GetXamlType (axtn);
var am = at.GetAttachableMember (aname.Substring (idx + 1));
if (am != null)
sti.Members.Add (new Pair (am, p.Value));
// ignore unknown attribute
}
var xm = xt.GetMember (aname);
if (xm != null)
sti.Members.Add (new Pair (xm, p.Value));
// ignore unknown attribute
}
}
