//
// Copyright (C) 2010 Novell Inc. http://novell.com
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Xml;
using NUnit.Framework;
#if PCL
using Portable.Xaml.Markup;
using Portable.Xaml.ComponentModel;
using Portable.Xaml;
using Portable.Xaml.Schema;
#else
using System.Windows.Markup;
using System.ComponentModel;
using System.Xaml;
using System.Xaml.Schema;
#endif
namespace MonoTests.Portable.Xaml.Schema
{
[TestFixture]
public class XamlTypeInvokerTest
{
XamlSchemaContext sctx = new XamlSchemaContext (new XamlSchemaContextSettings ());
[Test]
public void ConstructorTypeNull ()
{
Assert.Throws<ArgumentNullException> (() => new XamlTypeInvoker (null));
}
[Test]
public void DefaultValues ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (object), sctx));
Assert.IsNull (i.SetMarkupExtensionHandler, "#1");
Assert.IsNull (i.SetTypeConverterHandler, "#2");
}
[XamlSetMarkupExtension ("HandleMarkupExtension")]
public class TestClassMarkupExtension1
{
}
// SetMarkupExtensionHandler
[Test]
public void SetHandleMarkupExtensionInvalid ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (TestClassMarkupExtension1), sctx));
Assert.Throws<ArgumentException> (() => { var t = i.SetMarkupExtensionHandler; }, "#1");
}
[XamlSetMarkupExtension ("HandleMarkupExtension")]
public class TestClassMarkupExtension2
{
// delegate type mismatch
void HandleMarkupExtension ()
{
}
}
[Test]
public void SetHandleMarkupExtensionInvalid2 ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (TestClassMarkupExtension2), sctx));
Assert.Throws<ArgumentException> (() => { var t = i.SetMarkupExtensionHandler; }, "#1");
}
[XamlSetMarkupExtension ("HandleMarkupExtension")]
public class TestClassMarkupExtension3
{
// must be static
public void HandleMarkupExtension (object o, XamlSetMarkupExtensionEventArgs a)
{
}
}
[Test]
public void SetHandleMarkupExtensionInvalid3 ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (TestClassMarkupExtension3), sctx));
Assert.Throws<ArgumentException> (() => { var t = i.SetMarkupExtensionHandler; }, "#1");
}
[XamlSetMarkupExtension ("HandleMarkupExtension")]
public class TestClassMarkupExtension4
{
// can be private.
static void HandleMarkupExtension (object o, XamlSetMarkupExtensionEventArgs a)
{
}
}
[Test]
public void SetHandleMarkupExtension ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (TestClassMarkupExtension4), sctx));
Assert.IsNotNull (i.SetMarkupExtensionHandler, "#1");
}
// SetTypeConverterHandler
[XamlSetTypeConverter ("HandleTypeConverter")]
public class TestClassTypeConverter1
{
}
[Test]
public void SetHandleTypeConverterInvalid ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (TestClassTypeConverter1), sctx));
Assert.Throws<ArgumentException> (() => { var t = i.SetTypeConverterHandler; }, "#1");
}
[XamlSetTypeConverter ("HandleTypeConverter")]
public class TestClassTypeConverter2
{
// delegate type mismatch
void HandleTypeConverter ()
{
}
}
[Test]
public void SetHandleTypeConverterInvalid2 ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (TestClassTypeConverter2), sctx));
Assert.Throws<ArgumentException> (() => { var t = i.SetTypeConverterHandler; }, "#1");
}
[XamlSetTypeConverter ("HandleTypeConverter")]
public class TestClassTypeConverter3
{
// must be static
public void HandleTypeConverter (object o, XamlSetTypeConverterEventArgs a)
{
}
}
[Test]
public void SetHandleTypeConverterInvalid3 ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (TestClassTypeConverter3), sctx));
Assert.Throws<ArgumentException> (() => { var t = i.SetTypeConverterHandler; }, "#1");
}
[XamlSetTypeConverter ("HandleTypeConverter")]
public class TestClassTypeConverter4
{
// can be private.
static void HandleTypeConverter (object o, XamlSetTypeConverterEventArgs a)
{
}
}
[Test]
public void SetHandleTypeConverter ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (TestClassTypeConverter4), sctx));
Assert.IsNotNull (i.SetTypeConverterHandler, "#1");
}
// AddToCollection
[Test]
public void AddToCollectionNoUnderlyingType ()
{
var i = new XamlTypeInvoker (new XamlType ("urn:foo", "FooType", null, sctx));
i.AddToCollection (new List<int> (), 5); // ... passes.
}
[Test]
public void AddToCollectionArrayExtension ()
{
var i = XamlLanguage.Array.Invoker;
var ax = new ArrayExtension ();
Assert.Throws<NotSupportedException> (() => i.AddToCollection (ax, 5));
}
[Test]
public void AddToCollectionArrayInstance ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (int []), sctx));
var ax = new ArrayExtension ();
Assert.Throws<NotSupportedException> (() => i.AddToCollection (ax, 5));
}
[Test]
public void AddToCollectionList_ObjectTypeMismatch ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (List<int>), sctx));
try {
i.AddToCollection (new ArrayExtension (), 5);
Assert.Fail ("not supported operation.");
} catch (NotSupportedException) {
#if !WINDOWS_UWP
} catch (TargetException) {
#endif
// .NET throws this, but the difference should not really matter.
}
}
[Test]
public void AddToCollectionList_ObjectTypeMismatch2 ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (List<int>), sctx));
i.AddToCollection (new List<object> (), 5); // it is allowed.
}
[Test]
public void AddToCollectionList_ObjectTypeMismatch3 ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (List<object>), sctx));
i.AddToCollection (new List<int> (), 5); // it is allowed too.
}
[Test]
public void AddToCollectionList_ObjectTypeMismatch4 ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (List<Uri>), sctx));
i.AddToCollection (new List<TimeSpan> (), TimeSpan.Zero); // it is allowed too.
}
[Test]
public void AddToCollectionList_NonCollectionType ()
{
// so, the source collection type is not checked at all.
var i = new XamlTypeInvoker (new XamlType (typeof (Uri), sctx));
i.AddToCollection (new List<TimeSpan> (), TimeSpan.Zero); // it is allowed too.
}
[Test]
public void AddToCollectionList ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (List<int>), sctx));
var l = new List<int> ();
i.AddToCollection (l, 5);
i.AddToCollection (l, 3);
i.AddToCollection (l, -12);
Assert.AreEqual (3, l.Count, "#1");
Assert.AreEqual (-12, l [2], "#2");
}
[Test]
public void AddToCollectionTypeMismatch ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (List<int>), sctx));
var l = new List<int> ();
Assert.Throws<ArgumentException> (() => i.AddToCollection (l, "5"));
}
// CreateInstance
[Test]
public void CreateInstanceNoUnderlyingType ()
{
var i = new XamlTypeInvoker (new XamlType ("urn:foo", "FooType", null, sctx));
Assert.Throws<NotSupportedException> (() => i.CreateInstance (new object [0])); // unkown type is not supported
}
[Test]
public void CreateInstanceArrayExtension ()
{
var i = XamlLanguage.Array.Invoker;
i.CreateInstance (new object [0]);
}
[Test]
public void CreateInstanceArray ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (int []), sctx));
Assert.Throws<MissingMethodException> (() => i.CreateInstance (new object [0])); // no default constructor.
}
[Test]
public void CreateInstanceList_ArgumentMismatch ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (List<int>), sctx));
Assert.Throws<MissingMethodException> (() => i.CreateInstance (new object [] {"foo"}));
}
[Test]
public void CreateInstanceList ()
{
var i = new XamlTypeInvoker (new XamlType (typeof (List<int>), sctx));
i.CreateInstance (new object [0]);
}
[Test]
public void GetItems ()
{
var i = new XamlType (typeof (List<int>), sctx).Invoker;
var list = new int [] {5, -3, 0}.ToList ();
var items = i.GetItems (list);
var arr = new List<object> ();
while (items.MoveNext ())
arr.Add (items.Current);
Assert.AreEqual (5, arr [0], "#1");
Assert.AreEqual (0, arr [2], "#2");
}
[Test]
public void GetItems2 ()
{
// GetItems() returns IEnumerable<KeyValuePair<,>>
var i = new XamlType (typeof (Dictionary<int,string>), sctx).Invoker;
var dic = new Dictionary<int,string> ();
dic [5] = "foo";
dic [-3] = "bar";
dic [0] = "baz";
var items = i.GetItems (dic);
var arr = new List<object> ();
while (items.MoveNext ())
arr.Add (items.Current);
Assert.AreEqual (new KeyValuePair<int,string> (5, "foo"), arr [0], "#1");
Assert.AreEqual (new KeyValuePair<int,string> (0, "baz"), arr [2], "#1");
}
[Test]
public void UnknownInvokerCreateInstance ()
{
Assert.Throws<NotSupportedException> (() => XamlTypeInvoker.UnknownInvoker.CreateInstance (new object [0]));
}
[Test]
public void UnknownInvokerGetItems ()
{
var items = XamlTypeInvoker.UnknownInvoker.GetItems (new object [] {1});
Assert.IsNotNull (items, "#1");
Assert.IsTrue (items.MoveNext (), "#2");
Assert.AreEqual (1, items.Current, "#3");
Assert.IsFalse (items.MoveNext (), "#4");
}
[Test]
public void UnknownInvokerAddToCollection ()
{
// this does not check Unknown-ness.
var c = new List<object> ();
XamlTypeInvoker.UnknownInvoker.AddToCollection (c, 1);
Assert.AreEqual (1, c.Count, "#1");
}
[Test]
public void UnknownInvokerAddToDictionary ()
{
var dic = new Dictionary<object,object> ();
// this does not check Unknown-ness.
XamlTypeInvoker.UnknownInvoker.AddToDictionary (dic, 1, 2);
Assert.AreEqual (1, dic.Count, "#1");
}
[Test]
public void UnknownInvokerGetEnumeratorMethod ()
{
try {
Assert.IsNull (XamlTypeInvoker.UnknownInvoker.GetEnumeratorMethod (), "#1");
} catch (Exception) {
// .NET is buggy, returns NRE.
}
}
[Test]
public void UnknownInvoker ()
{
Assert.IsNull (XamlTypeInvoker.UnknownInvoker.SetMarkupExtensionHandler, "#1");
Assert.IsNull (XamlTypeInvoker.UnknownInvoker.SetTypeConverterHandler, "#2");
Assert.IsNull (XamlTypeInvoker.UnknownInvoker.GetAddMethod (XamlLanguage.Object), "#3");
}
}
}
