public void TestBaseUri2()
{
string xaml = @"
<c:ArrayList xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml'
xmlns:s='clr-namespace:System;assembly=mscorlib'
xmlns:c='clr-namespace:System.Collections;assembly=mscorlib' xml:base='http://schemas.microsoft.com/winfx/2006/xaml'>
<s:String>Hello</s:String>
</c:ArrayList>";
MemoryStream ms = new MemoryStream();
using (StreamWriter sw = new StreamWriter(ms))
{
sw.Write(xaml);
sw.Flush();
ms.Position = 0;
XamlXmlReaderSettings settings = new XamlXmlReaderSettings();
XamlXmlReader xxr = new XamlXmlReader(ms, settings);
XamlObjectWriter objWriter = new XamlObjectWriter(xxr.SchemaContext);
while (xxr.Read())
{
objWriter.WriteNode(xxr);
}
objWriter.Clear();
objWriter.Close();
}
}
bool ProcessMarkupItem(string markupItem, XamlNsReplacingContext wxsc, Assembly localAssembly)
{
XamlXmlReaderSettings settings = new XamlXmlReaderSettings()
{
LocalAssembly = localAssembly, ProvideLineInfo = true, AllowProtectedMembersOnRoot = true
};
using (StreamReader streamReader = new StreamReader(markupItem))
{
var xamlReader = new XamlXmlReader(XmlReader.Create(streamReader), wxsc, settings);
ClassValidator validator = new ClassValidator(markupItem, localAssembly, this.RootNamespace);
IList <LogData> validationErrors = null;
if (validator.ValidateXaml(xamlReader, false, this.AssemblyName, out validationErrors))
{
return(true);
}
else
{
foreach (LogData logData in validationErrors)
{
this.LogData.Add(logData);
}
return(false);
}
}
}
/// <summary>
/// Loads XAML from a stream.
/// </summary>
/// <param name="stream">The stream containing the XAML.</param>
/// <param name="localAssembly">Default assembly for clr-namespace</param>
/// <param name="rootInstance">
/// The optional instance into which the XAML should be loaded.
/// </param>
/// <param name="uri">The URI of the XAML</param>
/// <returns>The loaded object.</returns>
public object Load(Stream stream, Assembly localAssembly, object rootInstance = null, Uri uri = null)
{
var readerSettings = new XamlXmlReaderSettings()
{
BaseUri = uri,
LocalAssembly = localAssembly,
ProvideLineInfo = true,
};
var context = IsDesignMode ? AvaloniaXamlSchemaContext.DesignInstance : AvaloniaXamlSchemaContext.Instance;
var reader = new XamlXmlReader(stream, context, readerSettings);
object result = LoadFromReader(
reader,
AvaloniaXamlContext.For(readerSettings, rootInstance));
var topLevel = result as TopLevel;
if (topLevel != null)
{
DelayedBinding.ApplyBindings(topLevel);
}
return(result);
}
public XamlFileDefinition Parse(string content)
{
var document = XmlReader.Create(new StringReader(content));
// Initialize the reader using an empty context, because when the tasl
// is run under the BeforeCompile in VS IDE, the loaded assemblies are used
// to interpret the meaning of objects, which is not correct in Uno.UI context.
var context = new XamlSchemaContext(Enumerable.Empty <Assembly>());
// Force the line info, otherwise it will be enabled only when the debugger is attached.
var settings = new XamlXmlReaderSettings()
{
ProvideLineInfo = true
};
using (var reader = new XamlXmlReader(document, context, settings))
{
if (reader.Read())
{
return(Visit(reader));
}
}
return(null);
}
public static Activity LoadActivityFromFile(string activityXamlPath, string activityName, string activityAssemblyPath = null)
{
XamlReader xamlReader;
if (!string.IsNullOrWhiteSpace(activityAssemblyPath))
{
Assembly actAssembly = Assembly.LoadFile(activityAssemblyPath);
XamlXmlReaderSettings settings = new XamlXmlReaderSettings
{
LocalAssembly = actAssembly //TODO: this needs to be checked
};
xamlReader = new XamlXmlReader(activityXamlPath, settings);
}
else
{
xamlReader = new XamlXmlReader(activityXamlPath);
}
ActivityXamlServicesSettings activitySettings = new ActivityXamlServicesSettings
{
CompileExpressions = true //compile C# expressions in workflow
};
Activity activity = ActivityXamlServices.Load(xamlReader, activitySettings);
activity.DisplayName = activityName;
return(activity);
}
public static Activity CreateWorkflowActivityFromXaml(string workflowXaml, Assembly type)
{
if (string.IsNullOrEmpty(workflowXaml) || type == null)
{
return(null);
}
var xmlReaderSettings = new XamlXmlReaderSettings {
LocalAssembly = type
};
var settings1 = xmlReaderSettings;
StringReader stringReader = null;
var settings2 = new ActivityXamlServicesSettings {
CompileExpressions = true
};
try
{
stringReader = new StringReader(workflowXaml);
var activity = ActivityXamlServices.Load(new XamlXmlReader(stringReader, settings1), settings2);
return(activity);
}
finally
{
stringReader?.Dispose();
}
}
private XamlFileDefinition ParseFile(string file)
{
try
{
this.Log().InfoFormat("Pre-processing XAML file: {0}", file);
var document = ApplyIgnorables(file);
// Initialize the reader using an empty context, because when the tasl
// is run under the BeforeCompile in VS IDE, the loaded assemblies are used
// to interpret the meaning of objects, which is not correct in Uno.UI context.
var context = new XamlSchemaContext(Enumerable.Empty <Assembly>());
// Force the line info, otherwise it will be enabled only when the debugger is attached.
var settings = new XamlXmlReaderSettings()
{
ProvideLineInfo = true
};
using (var reader = new XamlXmlReader(document, context, settings))
{
if (reader.Read())
{
return(Visit(reader, file));
}
}
return(null);
}
catch (Exception e)
{
throw new InvalidOperationException($"Failed to parse file {file}", e);
}
}
public XamlAnalysis(TextReader textReader)
{
try
{
var settings = new XamlXmlReaderSettings
{
ProvideLineInfo = true
};
var context = new XamlSchemaContext(new XamlSchemaContextSettings()
{
FullyQualifyAssemblyNamesInClrNamespaces = true
});
using (XamlXmlReader reader = new XamlXmlReader(textReader, context, settings))
{
Analyze(reader);
}
}
catch
{
// ignore malformed XAML - XamlReader does a bad job of documenting what it throws
// so we just need to try/catch here.
}
}
private ActivityBuilder ReadXamlDefinition()
{
var xamlStr = RootActivity.ToString();
try
{
if (xamlStr.Length != 0)
{
using (var sw = new StringReader(xamlStr))
{
var xamlXmlWriterSettings = new XamlXmlReaderSettings
{
LocalAssembly = System.Reflection.Assembly.GetAssembly(typeof(VirtualizedContainerService))
};
var xw = ActivityXamlServices.CreateBuilderReader(new XamlXmlReader(sw, new XamlSchemaContext(), xamlXmlWriterSettings));
var load = XamlServices.Load(xw);
return(load as ActivityBuilder);
}
}
}
catch (Exception e)
{
Dev2Logger.Error("Error loading XAML: ", e, GlobalConstants.WarewolfError);
}
return(null);
}
private static ActivityBuilder StartUpdate(string name)
{
// Create the XamlXmlReaderSettings.
XamlXmlReaderSettings readerSettings = new XamlXmlReaderSettings()
{
// In the XAML the "local" namespace referes to artifacts that come from
// the same project as the XAML. When loading XAML if the currently executing
// assembly is not the same assembly that was referred to as "local" in the XAML
// LocalAssembly must be set to the assembly containing the artifacts.
// Assembly.LoadFile requires an absolute path so convert this relative path
// to an absolute path.
LocalAssembly = Assembly.LoadFile(
Path.GetFullPath(Path.Combine(mapPath, "NumberGuessWorkflowActivities_v1.dll")))
};
string path = Path.Combine(definitionPath, name);
XamlXmlReader xamlReader = new XamlXmlReader(path, readerSettings);
// Load the workflow definition into an ActivityBuilder.
ActivityBuilder wf = XamlServices.Load(
ActivityXamlServices.CreateBuilderReader(xamlReader))
as ActivityBuilder;
// PrepareForUpdate makes a copy of the workflow definition in the
// ActivityBuilder that is used for comparison when the update
// map is created.
DynamicUpdateServices.PrepareForUpdate(wf);
return(wf);
}
private Activity GetWorkflowDefinition(WorkflowServiceParameter param)
{
var wfDefVersionRepository = WorkflowServiceEngine.Instance.WorkflowContainerManager.Resolve <IRepository <WorkflowDefinitionVersion> >();
var wfDefVersion = new WorkflowDefinitionVersion();
string xaml = "";
//if starting workflow
if (param.WorkflowDefinitionId == 0)
{
//get the latest version of the default wf def
wfDefVersion = wfDefVersionRepository.GetAll()
.Where(w => w.WorkflowDefinition.EntityType == param.EntityType && w.WorkflowDefinition.IsDefault == true)
.OrderByDescending(w => w.WorkflowVersion)
.First();
param.WorkflowDefinitionId = wfDefVersion.WorkflowDefinitionId.Value;
}
else if (param.WorkflowVersion == 0)
{
//get the latest version of the specified wf def
wfDefVersion = wfDefVersionRepository.GetAll()
.Where(w => w.WorkflowDefinition.EntityType == param.EntityType && w.WorkflowDefinition.Id == param.WorkflowDefinitionId)
.OrderByDescending(w => w.WorkflowVersion)
.First();
}
else
{
//get the specified version of the specified wf def
wfDefVersion = wfDefVersionRepository.GetAll()
.Where(w => w.WorkflowDefinition.EntityType == param.EntityType && w.WorkflowDefinition.Id == param.WorkflowDefinitionId &&
w.WorkflowVersion == param.WorkflowVersion)
.OrderByDescending(w => w.WorkflowVersion)
.First();
}
xaml = wfDefVersion.WorkflowXamlFileContent;
string _byteOrderMarkUtf8 = Encoding.UTF8.GetString(Encoding.UTF8.GetPreamble());
if (xaml.StartsWith(_byteOrderMarkUtf8))
{
var lastIndexOfUtf8 = _byteOrderMarkUtf8.Length - 1;
xaml = xaml.Remove(0, lastIndexOfUtf8);
}
//Load workflow definition from xaml
ActivityXamlServicesSettings settings = new ActivityXamlServicesSettings
{
CompileExpressions = true
};
XamlXmlReaderSettings xamlReaderSettings = new XamlXmlReaderSettings {
LocalAssembly = typeof(ReceiptWorkflow).Assembly
};
var stream = new MemoryStream(Encoding.UTF8.GetBytes(xaml));
XamlReader xamlReader = new XamlXmlReader(stream, xamlReaderSettings);
var activity = ActivityXamlServices.Load(xamlReader, settings);
return(activity);
}
public void DefaultValues ()
{
var s = new XamlXmlReaderSettings ();
Assert.IsFalse (s.CloseInput, "#1");
Assert.IsFalse (s.SkipXmlCompatibilityProcessing, "#2");
Assert.IsNull (s.XmlLang, "#3");
Assert.IsFalse (s.XmlSpacePreserve, "#4");
}
public PortableXamlXamlService()
{
_readerSettings = new XamlXmlReaderSettings()
{
LocalAssembly = this.GetType().Assembly,
};
_readerSettings.AddNamespaces(this.GetType().Assembly);
_readerSettings.AddNamespaces(typeof(View.Schemas.S2ViewDefinitions).Assembly);
}
public object LocalAssemblyLoader(string xaml)
{
XamlXmlReaderSettings settings = new XamlXmlReaderSettings {
LocalAssembly = typeof(Element).Assembly
};
XamlXmlReader reader = new XamlXmlReader(XmlReader.Create(new StringReader(xaml)), settings);
return(XamlServices.Load(reader));
}
public void DefaultValues()
{
var s = new XamlXmlReaderSettings();
Assert.IsFalse(s.CloseInput, "#1");
Assert.IsFalse(s.SkipXmlCompatibilityProcessing, "#2");
Assert.IsNull(s.XmlLang, "#3");
Assert.IsFalse(s.XmlSpacePreserve, "#4");
}
[ExpectedException] // not checking type of exception due to differences in implementation
public void LocalAssemblyShouldNotApplyToNamespace()
{
var settings = new XamlXmlReaderSettings();
string xml = File.ReadAllText(Path.Combine("XmlFiles", "LocalAssembly.xml")).UpdateXml();
var obj = XamlServices.Load(new XamlXmlReader(new StringReader(xml), settings));
Assert.IsNotNull(obj, "#1");
Assert.IsInstanceOf <TestClass1>(obj, "#2");
}
/// <summary>
/// Loads the specified type from the specified XML <paramref name="reader"/>.
/// </summary>
/// <typeparam name="T">Type of object to load from the specified xaml</typeparam>
/// <param name="reader">XmlReader to read the Xaml content</param>
/// <param name="instance">Instance to use as the starting object, or null to create a new instance</param>
/// <returns>A new or existing instance of the specified type with the contents loaded from the xaml stream</returns>
public static T Load <T>(XmlReader reader, T instance)
{
var readerSettings = new XamlXmlReaderSettings();
if (!DesignMode)
{
readerSettings.LocalAssembly = typeof(T).GetAssembly();
}
return(Load <T>(new XamlXmlReader(reader, context, readerSettings), instance));
}
internal static AvaloniaXamlContext For(XamlXmlReaderSettings sett,
object rootInstance)
{
return(new AvaloniaXamlContext()
{
BaseUri = sett.BaseUri,
LocalAssembly = sett.LocalAssembly,
RootInstance = rootInstance
});
}
void LoadSkin()
{
if (ConfigHelper.Main.Values.Debug.UseInternalSkin)
{
return;
}
var skinFileName = ConfigHelper.Main.Values.SkinFileName;
if (!File.Exists(FileContainer.GetFullPathFileName(skinFileName)))
{
Log.WriteLine($"Failed to load skin file '{skinFileName}'");
return;
}
m_SkinFile.TryChangeFileName(skinFileName);
try
{
ResourceDictionary resourceDictionary = null;
using (var streamReader = new StreamReader(m_SkinFile.FullPathFileName, Encoding.UTF8))
{
LoadExternalAssemblies();
var xmlReaderSettings = new XamlXmlReaderSettings
{
LocalAssembly = Assembly.GetExecutingAssembly()
};
using (var xamlReader = new XamlXmlReader(streamReader.BaseStream, XamlReader.GetWpfSchemaContext(), xmlReaderSettings))
{
resourceDictionary = XamlReader.Load(xamlReader) as ResourceDictionary;
}
}
if (resourceDictionary != null)
{
Resources.MergedDictionaries.Clear();
Resources.MergedDictionaries.Add(resourceDictionary);
if (m_Overlay != null)
{
m_Overlay.RefreshWidgetsLayout();
}
Log.WriteLine($"{m_SkinFile.FileName} loaded");
}
}
catch (Exception ex)
{
Log.WriteException(ex);
}
m_LastSkinFileName = skinFileName;
}
public NodeStreamSorter(XamlParserContext context, XamlPullParser parser, XamlXmlReaderSettings settings, Dictionary <string, string> xmlnsDictionary)
{
this._context = context;
this._settings = settings;
this._source = parser.Parse().GetEnumerator();
this._xmlnsDictionary = xmlnsDictionary;
this._buffer = new Queue <XamlNode>();
this._sortingInfoArray = null;
this.StartNewNodeStreamWithSettingsPreamble();
this.ReadAheadAndSortCtorProperties();
}
public void LocalAssemblyShouldApplyToNamespace()
{
var settings = new XamlXmlReaderSettings();
settings.LocalAssembly = typeof(TestClass1).GetTypeInfo().Assembly;
string xml = File.ReadAllText(Compat.GetTestFile("LocalAssembly.xml")).UpdateXml();
var obj = XamlServices.Load(new XamlXmlReader(new StringReader(xml), settings));
Assert.IsNotNull(obj, "#1");
Assert.IsInstanceOf <TestClass1>(obj, "#2");
}
private static Activity CreateActivityFrom(string xaml)
{
var xamlSettings = new XamlXmlReaderSettings {
LocalAssembly = Assembly.GetExecutingAssembly()
};
var xamlReader = ActivityXamlServices
.CreateReader(new XamlXmlReader(xaml, xamlSettings));
Activity activity = ActivityXamlServices.Load(xamlReader);
return(activity);
}
internal XamlScanner(XamlParserContext context, XmlReader xmlReader, XamlXmlReaderSettings settings)
{
this._xmlReader = xmlReader;
this._xmlLineInfo = settings.ProvideLineInfo ? (xmlReader as IXmlLineInfo) : null;
this._parserContext = context;
this._scannerStack = new XamlScannerStack();
this._readNodesQueue = new Queue <XamlScannerNode>();
this._settings = settings;
if (settings.XmlSpacePreserve)
{
this._scannerStack.CurrentXmlSpacePreserve = true;
}
}
public XamlAnalysis(string filename) {
try {
var settings = new XamlXmlReaderSettings();
settings.ProvideLineInfo = true;
using (XamlXmlReader reader = new XamlXmlReader(filename, settings)) {
Analyze(reader);
}
} catch {
// ignore malformed XAML - XamlReader does a bad job of documenting what it throws
// so we just need to try/catch here.
}
}
private static void InitializeComponentFromXamlResource(Type componentType, string resource, object componentInstance, XamlSchemaContext schemaContext)
{
Stream initializeXaml = componentType.Assembly.GetManifestResourceStream(resource);
XmlReader xmlReader = null;
XamlReader reader = null;
XamlObjectWriter objectWriter = null;
try
{
xmlReader = XmlReader.Create(initializeXaml);
XamlXmlReaderSettings readerSettings = new XamlXmlReaderSettings
{
LocalAssembly = componentType.Assembly,
AllowProtectedMembersOnRoot = true
};
reader = new XamlXmlReader(xmlReader, schemaContext, readerSettings);
XamlObjectWriterSettings writerSettings = new XamlObjectWriterSettings
{
RootObjectInstance = componentInstance
};
//writerSettings.AccessLevel = XamlAccessLevel.PrivateAccessTo(componentType);
objectWriter = new XamlObjectWriter(schemaContext, writerSettings);
// We need the XamlLoadPermission for the assembly we are dealing with.
//XamlLoadPermission perm = new XamlLoadPermission(XamlAccessLevel.PrivateAccessTo(componentType));
//perm.Assert();
try
{
XamlServices.Transform(reader, objectWriter);
}
finally
{
//CodeAccessPermission.RevertAssert();
}
}
finally
{
if ((xmlReader != null))
{
((IDisposable)(xmlReader)).Dispose();
}
if ((reader != null))
{
((IDisposable)(reader)).Dispose();
}
if ((objectWriter != null))
{
((IDisposable)(objectWriter)).Dispose();
}
}
}
public void Read_DefaultNamespaces_WithDefinedNamespace()
{
#if PCL
var settings = new XamlXmlReaderSettings();
settings.AddNamespace(null, "urn:mono-test");
settings.AddNamespace("x", "urn:mono-test2");
var obj = (NamespaceTest.NamespaceTestClass)XamlServices.Load(GetReader("DefaultNamespaces_WithDefinedNamespace.xml", settings));
Assert.IsNotNull(obj, "#1");
Assert.AreEqual(obj.Foo, "Hello");
Assert.AreEqual(obj.Bar, null);
#else
Assert.Ignore("Not supported in System.Xaml");
#endif
}
public void DefaultNamespaceFromAttributes()
{
#if PCL
var s = new XamlXmlReaderSettings();
s.AddNamespaces(GetType());
var testNamespaces = new Dictionary <string, string>
{
{ "test", "http://schemas.example.com/test" }
};
CollectionAssert.AreEquivalent(s.DefaultNamespaces, testNamespaces);
#else
Assert.Ignore("Not supported in System.Xaml");
#endif
}
public static XamlDomObject Load(string fileName, XamlSchemaContext schemaContext)
{
XamlDomObject rootObject = null;
using (var xr = XmlReader.Create(fileName))
{
var xxrs = new XamlXmlReaderSettings();
xxrs.ProvideLineInfo = true;
var xxr = new XamlXmlReader(xr, schemaContext, xxrs);
rootObject = (XamlDomObject)Load(xxr);
}
return(rootObject);
}
public void Read_DefaultNamespaces_ClrNamespace()
{
#if PCL
var settings = new XamlXmlReaderSettings();
settings.AddNamespace(null, Compat.TestAssemblyNamespace);
settings.AddNamespace("x", XamlLanguage.Xaml2006Namespace);
var obj = (TestClass5)XamlServices.Load(GetReader("DefaultNamespaces.xml", settings));
Assert.IsNotNull(obj, "#1");
Assert.AreEqual(obj.Bar, "Hello");
Assert.AreEqual(obj.Baz, null);
#else
Assert.Ignore("Not supported in System.Xaml");
#endif
}
public void CheckDesignDataContext()
{
var type = typeof(ClassWithDataContext);
var xaml = $@"
<{type.Name} xmlns='clr-namespace:{type.Namespace}'
xmlns:d='http://schemas.microsoft.com/expression/blend/2008'
xmlns:mc='http://schemas.openxmlformats.org/markup-compatibility/2006'
mc:Ignorable='d'
d:DataContext='value'>
</{type.Name}>";
foreach (var designMode in new[] { true, false })
{
foreach (var useDirective in new[] { true, false })
{
ClassWithDataContext res;
var settings = new XamlXmlReaderSettings {
LocalAssembly = type.Assembly
};
var rdr = new XamlXmlReader(new StringReader(xaml), new CustomContext()
{
IsDesignMode = designMode,
NamespaceMap = useDirective ? null : ("clr-namespace:" + typeof(ClassWithDataContext).Namespace)
}, settings);
if (useDirective)
{
var writer = new CustomWriter(rdr.SchemaContext)
{
IsDesignMode = designMode
};
XamlServices.Transform(rdr, writer);
res = (ClassWithDataContext)writer.Result;
}
else
{
res = (ClassWithDataContext)XamlServices.Load(rdr);
}
if (designMode)
{
Assert.AreEqual("value", res.DataContext);
}
else
{
Assert.IsNull(res.DataContext);
}
}
}
}
internal XamlScanner(XamlParserContext context, XmlReader xmlReader, XamlXmlReaderSettings settings)
{
_xmlReader = xmlReader;
_xmlLineInfo = settings.ProvideLineInfo ? (xmlReader as IXmlLineInfo) : null; //consider removing the "settings" check
_parserContext = context;
_scannerStack = new XamlScannerStack();
_readNodesQueue = new Queue <XamlScannerNode>();
_settings = settings;
if (settings.XmlSpacePreserve)
{
_scannerStack.CurrentXmlSpacePreserve = true;
}
}
public void CopyConstructor ()
{
var s = new XamlXmlReaderSettings ();
s.CloseInput = true;
s.SkipXmlCompatibilityProcessing = true;
s.XmlLang = "ja-JP";
s.XmlSpacePreserve = true;
s = new XamlXmlReaderSettings (s);
// .NET fails to copy this value.
//Assert.IsTrue (s.CloseInput, "#1");
Assert.IsTrue (s.SkipXmlCompatibilityProcessing, "#2");
Assert.AreEqual ("ja-JP", s.XmlLang, "#3");
Assert.IsTrue (s.XmlSpacePreserve, "#4");
}
public void RootObjectInstance ()
{
// bug #689548
var obj = new RootObjectInstanceTestClass ();
RootObjectInstanceTestClass result;
var rsettings = new XamlXmlReaderSettings ();
var xml = String.Format (@"<RootObjectInstanceTestClass Property=""Test"" xmlns=""clr-namespace:MonoTests.Portable.Xaml;assembly={0}""></RootObjectInstanceTestClass>", GetType ().Assembly.GetName ().Name);
using (var reader = new XamlXmlReader (new StringReader (xml), rsettings)) {
var wsettings = new XamlObjectWriterSettings ();
wsettings.RootObjectInstance = obj;
using (var writer = new XamlObjectWriter (reader.SchemaContext, wsettings)) {
XamlServices.Transform (reader, writer, false);
result = (RootObjectInstanceTestClass) writer.Result;
}
}
Assert.AreEqual (obj, result, "#1");
Assert.AreEqual ("Test", obj.Property, "#2");
}
public void LocalAssemblyShouldApplyToNamespace()
{
var settings = new XamlXmlReaderSettings();
settings.LocalAssembly = typeof(TestClass1).Assembly;
string xml = File.ReadAllText(Compat.GetTestFile ("LocalAssembly.xml")).UpdateXml();
var obj = XamlServices.Load(new XamlXmlReader(new StringReader(xml), settings));
Assert.IsNotNull(obj, "#1");
Assert.IsInstanceOf<TestClass1>(obj, "#2");
}
// not checking type of exception due to differences in implementation
public void LocalAssemblyShouldNotApplyToNamespace()
{
var settings = new XamlXmlReaderSettings();
string xml = File.ReadAllText(Compat.GetTestFile ("LocalAssembly.xml")).UpdateXml();
#if PCL
var exType = typeof(XamlParseException);
#else
var exType = typeof(XamlObjectWriterException);
#endif
Assert.Throws(exType, () => {
var obj = XamlServices.Load (new XamlXmlReader (new StringReader (xml), settings));
Assert.IsNotNull (obj, "#1");
Assert.IsInstanceOf<TestClass1> (obj, "#2");
});
}
[ExpectedException] // not checking type of exception due to differences in implementation
public void LocalAssemblyShouldNotApplyToNamespace()
{
var settings = new XamlXmlReaderSettings();
string xml = File.ReadAllText(Path.Combine("XmlFiles", "LocalAssembly.xml")).UpdateXml();
var obj = XamlServices.Load(new XamlXmlReader(new StringReader(xml), settings));
Assert.IsNotNull(obj, "#1");
Assert.IsInstanceOf<TestClass1>(obj, "#2");
}
