mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 17:02:10 -10:00
* PropertyDescriptor.cs: When adding or removing a new handler for an existing component, update the hashtable. In GetValueChangedHandler, return null if component is null. * PropertyDescriptorTests.cs: Added tests for AddValueChanged, GetInvocationTarget, GetValueChangedHandler and RemoveValueChanged. svn path=/trunk/mcs/; revision=89659
961 lines
25 KiB
C#
961 lines
25 KiB
C#
//
|
|
// System.ComponentModel.PropertyDescriptor test cases
|
|
//
|
|
// Authors:
|
|
// Chris Toshok ([email protected])
|
|
// Gert Driesen ([email protected])
|
|
//
|
|
// (c) 2006 Novell, Inc. (http://www.novell.com/)
|
|
//
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.ComponentModel;
|
|
using System.Globalization;
|
|
using System.Drawing.Design;
|
|
using System.ComponentModel.Design;
|
|
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTests.System.ComponentModel
|
|
{
|
|
[TestFixture]
|
|
public class PropertyDescriptorTests
|
|
{
|
|
class MissingConverterType_test
|
|
{
|
|
public class NestedClass { }
|
|
|
|
[TypeConverter ("missing-type-name")]
|
|
public NestedClass Prop {
|
|
get { return null; }
|
|
}
|
|
|
|
[TypeConverter ("missing-type-name")]
|
|
public int IntProp {
|
|
get { return 5; }
|
|
}
|
|
|
|
[TypeConverter ("missing-type-name")]
|
|
public string StringProp {
|
|
get { return ""; }
|
|
}
|
|
}
|
|
|
|
class ReadOnlyProperty_test
|
|
{
|
|
public int Prop {
|
|
get { return 5; }
|
|
}
|
|
}
|
|
|
|
class ReadOnlyAttribute_test
|
|
{
|
|
[ReadOnly (true)]
|
|
public int Prop {
|
|
get { return 5; }
|
|
set { }
|
|
}
|
|
}
|
|
|
|
class ConflictingReadOnly_test
|
|
{
|
|
[ReadOnly (false)]
|
|
public int Prop {
|
|
get { return 5; }
|
|
}
|
|
}
|
|
|
|
class ShouldSerialize_public_test
|
|
{
|
|
public int Prop {
|
|
get { return 5; }
|
|
}
|
|
|
|
public bool ShouldSerializeProp()
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
class ShouldSerialize_protected_test
|
|
{
|
|
public int Prop {
|
|
get { return 5; }
|
|
}
|
|
|
|
protected bool ShouldSerializeProp()
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
class ShouldSerialize_private_test
|
|
{
|
|
public int Prop {
|
|
get { return 5; }
|
|
}
|
|
|
|
private bool ShouldSerializeProp()
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
class ShouldSerializeFalseEffectOnCanReset_test
|
|
{
|
|
public int Prop {
|
|
get { return 5; }
|
|
set { }
|
|
}
|
|
|
|
public bool ShouldSerializeProp()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public void ResetProp()
|
|
{
|
|
}
|
|
}
|
|
|
|
class ShouldSerialize_Null_Default
|
|
{
|
|
[DefaultValue (null)]
|
|
public string Prop {
|
|
get { return _prop; }
|
|
set { _prop = value; }
|
|
}
|
|
|
|
public bool SerializeProp {
|
|
get { return _serializeProp; }
|
|
set { _serializeProp = value; }
|
|
}
|
|
|
|
public bool ShouldSerializeProp ()
|
|
{
|
|
return _serializeProp;
|
|
}
|
|
|
|
private string _prop;
|
|
private bool _serializeProp;
|
|
}
|
|
|
|
class ShouldSerialize_No_Default
|
|
{
|
|
public string Prop {
|
|
get { return _prop; }
|
|
set { _prop = value; }
|
|
}
|
|
|
|
private string _prop;
|
|
}
|
|
|
|
class ShouldSerialize_ReadOnly
|
|
{
|
|
[ReadOnly (true)]
|
|
[DefaultValue ("ok")]
|
|
public string Prop1 {
|
|
get { return _prop1; }
|
|
set { _prop1 = value; }
|
|
}
|
|
|
|
[ReadOnly (false)]
|
|
public string Prop2 {
|
|
get { return _prop2; }
|
|
set { _prop2 = value; }
|
|
}
|
|
|
|
[ReadOnly (true)]
|
|
public string Prop3 {
|
|
get { return _prop3; }
|
|
set { _prop3 = value; }
|
|
}
|
|
|
|
[ReadOnly (false)]
|
|
public string Prop4 {
|
|
get { return _prop4; }
|
|
set { _prop4 = value; }
|
|
}
|
|
|
|
public string Prop5 {
|
|
get { return _prop5; }
|
|
}
|
|
|
|
[DefaultValue ("bad")]
|
|
public string Prop6 {
|
|
get { return _prop6; }
|
|
}
|
|
|
|
[ReadOnly (true)]
|
|
[DefaultValue ("good")]
|
|
public string Prop7 {
|
|
get { return _prop7; }
|
|
set { _prop7 = value; }
|
|
}
|
|
|
|
[ReadOnly (true)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
public string Prop8 {
|
|
get { return null; }
|
|
}
|
|
|
|
[ReadOnly (true)]
|
|
[DesignerSerializationVisibility (DesignerSerializationVisibility.Content)]
|
|
public string Prop9 {
|
|
get { return null; }
|
|
}
|
|
|
|
public bool SerializeProp3 {
|
|
get { return _serializeProp3; }
|
|
set { _serializeProp3 = value; }
|
|
}
|
|
|
|
public bool SerializeProp4 {
|
|
get { return _serializeProp4; }
|
|
set { _serializeProp4 = value; }
|
|
}
|
|
|
|
public bool SerializeProp5 {
|
|
get { return _serializeProp5; }
|
|
set { _serializeProp5 = value; }
|
|
}
|
|
|
|
public bool SerializeProp6 {
|
|
get { return _serializeProp6; }
|
|
set { _serializeProp6 = value; }
|
|
}
|
|
|
|
public bool SerializeProp7 {
|
|
get { return _serializeProp7; }
|
|
set { _serializeProp7 = value; }
|
|
}
|
|
|
|
public bool ShouldSerializeProp3 ()
|
|
{
|
|
return _serializeProp3;
|
|
}
|
|
|
|
public bool ShouldSerializeProp4 ()
|
|
{
|
|
return _serializeProp4;
|
|
}
|
|
|
|
public bool ShouldSerializeProp5 ()
|
|
{
|
|
return _serializeProp5;
|
|
}
|
|
|
|
public bool ShouldSerializeProp6 ()
|
|
{
|
|
return _serializeProp6;
|
|
}
|
|
|
|
public bool ShouldSerializeProp7 ()
|
|
{
|
|
return _serializeProp7;
|
|
}
|
|
|
|
public bool ShouldSerializeProp8 ()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
private string _prop1;
|
|
private string _prop2;
|
|
private string _prop3;
|
|
private string _prop4;
|
|
private string _prop5 = "good";
|
|
private string _prop6 = "bad";
|
|
private string _prop7;
|
|
private bool _serializeProp3;
|
|
private bool _serializeProp4;
|
|
private bool _serializeProp5;
|
|
private bool _serializeProp6;
|
|
private bool _serializeProp7;
|
|
}
|
|
|
|
class NoSerializeOrResetProp_test
|
|
{
|
|
public int Prop {
|
|
get { return 5; }
|
|
}
|
|
}
|
|
|
|
class CanReset_public_test
|
|
{
|
|
int prop = 5;
|
|
public int Prop {
|
|
get { return prop; }
|
|
set { prop = value; }
|
|
}
|
|
|
|
public void ResetProp()
|
|
{
|
|
prop = 10;
|
|
}
|
|
}
|
|
|
|
class CanReset_protected_test
|
|
{
|
|
int prop = 5;
|
|
public int Prop {
|
|
get { return prop; }
|
|
set { prop = value; }
|
|
}
|
|
|
|
protected void ResetProp()
|
|
{
|
|
prop = 10;
|
|
}
|
|
}
|
|
|
|
class CanReset_private_test
|
|
{
|
|
int prop = 5;
|
|
public int Prop {
|
|
get { return prop; }
|
|
set { prop = value; }
|
|
}
|
|
|
|
private void ResetProp()
|
|
{
|
|
prop = 10;
|
|
}
|
|
}
|
|
|
|
class CanResetNoSetter_test
|
|
{
|
|
int prop = 5;
|
|
public int Prop {
|
|
get { return prop; }
|
|
}
|
|
|
|
private void ResetProp()
|
|
{
|
|
prop = 10;
|
|
}
|
|
}
|
|
|
|
class DisplayName_test
|
|
{
|
|
#if NET_2_0
|
|
[DisplayName ("An explicit displayname")]
|
|
#endif
|
|
public bool Explicit {
|
|
get { return false; }
|
|
}
|
|
|
|
public bool Implicit {
|
|
get { return false; }
|
|
}
|
|
}
|
|
|
|
private ArrayList _invokedHandlers;
|
|
|
|
[SetUp]
|
|
public void SetUp ()
|
|
{
|
|
_invokedHandlers = new ArrayList ();
|
|
}
|
|
|
|
void Reset ()
|
|
{
|
|
_invokedHandlers.Clear ();
|
|
}
|
|
|
|
[Test]
|
|
public void MissingTypeConverter ()
|
|
{
|
|
PropertyDescriptor p1 = TypeDescriptor.GetProperties (typeof (MissingConverterType_test))["Prop"];
|
|
PropertyDescriptor p2 = TypeDescriptor.GetProperties (typeof (MissingConverterType_test))["IntProp"];
|
|
PropertyDescriptor p3 = TypeDescriptor.GetProperties (typeof (MissingConverterType_test))["StringProp"];
|
|
|
|
Assert.AreEqual (typeof (TypeConverter), p1.Converter.GetType (), "1");
|
|
Assert.AreEqual (typeof (Int32Converter), p2.Converter.GetType (), "2");
|
|
Assert.AreEqual (typeof (StringConverter), p3.Converter.GetType (), "3");
|
|
}
|
|
|
|
[Test]
|
|
public void ShouldSerializeTest_public ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (ShouldSerialize_public_test))["Prop"];
|
|
ShouldSerialize_public_test test = new ShouldSerialize_public_test ();
|
|
|
|
Assert.IsFalse (p.ShouldSerializeValue (test), "1");
|
|
}
|
|
|
|
[Test]
|
|
public void ShouldSerializeTest_protected ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (ShouldSerialize_protected_test))["Prop"];
|
|
ShouldSerialize_protected_test test = new ShouldSerialize_protected_test ();
|
|
|
|
Assert.IsFalse (p.ShouldSerializeValue (test), "1");
|
|
}
|
|
|
|
[Test]
|
|
public void ShouldSerializeTest_private ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (ShouldSerialize_protected_test))["Prop"];
|
|
ShouldSerialize_protected_test test = new ShouldSerialize_protected_test ();
|
|
|
|
Assert.IsFalse (p.ShouldSerializeValue (test), "1");
|
|
}
|
|
|
|
[Test]
|
|
public void ShouldSerializeTest_No_Default ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (ShouldSerialize_No_Default)) ["Prop"];
|
|
ShouldSerialize_No_Default test = new ShouldSerialize_No_Default ();
|
|
|
|
Assert.IsTrue (p.ShouldSerializeValue (test), "#1");
|
|
test.Prop = "whatever";
|
|
Assert.IsTrue (p.ShouldSerializeValue (test), "#2");
|
|
}
|
|
|
|
[Test]
|
|
public void ShouldSerializeTest_Null_Default ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (ShouldSerialize_Null_Default)) ["Prop"];
|
|
ShouldSerialize_Null_Default test = new ShouldSerialize_Null_Default ();
|
|
|
|
Assert.IsFalse (p.ShouldSerializeValue (test), "#1");
|
|
test.SerializeProp = true;
|
|
Assert.IsFalse (p.ShouldSerializeValue (test), "#2");
|
|
test.Prop = "whatever";
|
|
Assert.IsTrue (p.ShouldSerializeValue (test), "#3");
|
|
test.SerializeProp = false;
|
|
Assert.IsTrue (p.ShouldSerializeValue (test), "#4");
|
|
}
|
|
|
|
[Test]
|
|
public void ShouldSerializeTest_ReadOnly ()
|
|
{
|
|
PropertyDescriptorCollection properties = TypeDescriptor.GetProperties (
|
|
typeof (ShouldSerialize_ReadOnly));
|
|
ShouldSerialize_ReadOnly test = new ShouldSerialize_ReadOnly ();
|
|
|
|
PropertyDescriptor prop1PD = properties ["Prop1"];
|
|
PropertyDescriptor prop2PD = properties ["Prop2"];
|
|
PropertyDescriptor prop3PD = properties ["Prop3"];
|
|
PropertyDescriptor prop4PD = properties ["Prop4"];
|
|
PropertyDescriptor prop5PD = properties ["Prop5"];
|
|
PropertyDescriptor prop6PD = properties ["Prop6"];
|
|
PropertyDescriptor prop7PD = properties ["Prop7"];
|
|
PropertyDescriptor prop8PD = properties ["Prop8"];
|
|
PropertyDescriptor prop9PD = properties ["Prop9"];
|
|
|
|
Assert.IsFalse (prop1PD.ShouldSerializeValue (test), "#A1");
|
|
Assert.IsTrue (prop2PD.ShouldSerializeValue (test), "#A2");
|
|
Assert.IsFalse (prop3PD.ShouldSerializeValue (test), "#A3");
|
|
Assert.IsFalse (prop4PD.ShouldSerializeValue (test), "#A4");
|
|
Assert.IsFalse (prop5PD.ShouldSerializeValue (test), "#A5");
|
|
Assert.IsFalse (prop6PD.ShouldSerializeValue (test), "#A6");
|
|
Assert.IsFalse (prop7PD.ShouldSerializeValue (test), "#A7");
|
|
|
|
test.Prop1 = "whatever";
|
|
Assert.IsFalse (prop1PD.ShouldSerializeValue (test), "#B1");
|
|
test.Prop2 = "whatever";
|
|
Assert.IsTrue (prop2PD.ShouldSerializeValue (test), "#B2");
|
|
test.Prop3 = "whatever";
|
|
Assert.IsFalse (prop3PD.ShouldSerializeValue (test), "#B3");
|
|
test.Prop4 = "whatever";
|
|
Assert.IsFalse (prop4PD.ShouldSerializeValue (test), "#B4");
|
|
test.Prop7 = "whatever";
|
|
Assert.IsFalse (prop7PD.ShouldSerializeValue (test), "#B5");
|
|
|
|
test.Prop1 = "ok";
|
|
Assert.IsFalse (prop1PD.ShouldSerializeValue (test), "#C1");
|
|
test.SerializeProp3 = true;
|
|
Assert.IsTrue (prop3PD.ShouldSerializeValue (test), "#C2");
|
|
test.SerializeProp4 = true;
|
|
Assert.IsTrue (prop4PD.ShouldSerializeValue (test), "#C3");
|
|
test.SerializeProp5 = true;
|
|
Assert.IsTrue (prop5PD.ShouldSerializeValue (test), "#C4");
|
|
test.SerializeProp6 = true;
|
|
Assert.IsTrue (prop6PD.ShouldSerializeValue (test), "#C5");
|
|
test.Prop7 = "good";
|
|
Assert.IsFalse (prop7PD.ShouldSerializeValue (test), "#C6");
|
|
test.SerializeProp7 = true;
|
|
Assert.IsTrue (prop7PD.ShouldSerializeValue (test), "#C7");
|
|
test.Prop7 = "good";
|
|
Assert.IsTrue (prop7PD.ShouldSerializeValue (test), "#C8");
|
|
|
|
// has both DesignerSerializationVisibility.Content and ShouldSerialize { return false }
|
|
Assert.IsFalse (prop8PD.ShouldSerializeValue (test), "#D1");
|
|
// has DesignerSerializationVisibility.Content, no ShouldSerialize
|
|
Assert.IsTrue (prop9PD.ShouldSerializeValue (test), "#D2");
|
|
}
|
|
|
|
[Test]
|
|
public void CanResetTest_public ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (CanReset_public_test))["Prop"];
|
|
CanReset_public_test test = new CanReset_public_test ();
|
|
|
|
Assert.IsTrue (p.CanResetValue (test), "1");
|
|
Assert.AreEqual (5, test.Prop, "2");
|
|
p.ResetValue (test);
|
|
Assert.AreEqual (10, test.Prop, "3");
|
|
}
|
|
|
|
[Test]
|
|
public void CanResetTest_protected ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (CanReset_protected_test))["Prop"];
|
|
CanReset_protected_test test = new CanReset_protected_test ();
|
|
|
|
Assert.IsTrue (p.CanResetValue (test), "1");
|
|
Assert.AreEqual (5, test.Prop, "2");
|
|
p.ResetValue (test);
|
|
Assert.AreEqual (10, test.Prop, "3");
|
|
}
|
|
|
|
[Test]
|
|
public void CanResetTest_private ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (CanReset_private_test))["Prop"];
|
|
CanReset_private_test test = new CanReset_private_test ();
|
|
|
|
Assert.IsTrue (p.CanResetValue (test), "1");
|
|
Assert.AreEqual (5, test.Prop, "2");
|
|
p.ResetValue (test);
|
|
Assert.AreEqual (10, test.Prop, "3");
|
|
}
|
|
|
|
[Test]
|
|
public void CanResetTestNoSetterTest ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (CanResetNoSetter_test))["Prop"];
|
|
CanResetNoSetter_test test = new CanResetNoSetter_test ();
|
|
|
|
#if NET_2_0
|
|
Assert.IsFalse (p.CanResetValue (test), "1");
|
|
#else
|
|
Assert.IsTrue (p.CanResetValue (test), "1");
|
|
#endif
|
|
Assert.AreEqual (5, test.Prop, "2");
|
|
p.ResetValue (test);
|
|
Assert.AreEqual (10, test.Prop, "3");
|
|
}
|
|
|
|
[Test]
|
|
public void NoSerializeOrResetPropTest ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (NoSerializeOrResetProp_test))["Prop"];
|
|
NoSerializeOrResetProp_test test = new NoSerializeOrResetProp_test ();
|
|
|
|
Assert.IsFalse (p.CanResetValue (test), "1");
|
|
Assert.IsFalse (p.ShouldSerializeValue (test), "2");
|
|
}
|
|
|
|
[Test]
|
|
public void ShouldSerializeFalseEffectOnCanResetTest ()
|
|
{
|
|
PropertyDescriptor p = TypeDescriptor.GetProperties (typeof (ShouldSerializeFalseEffectOnCanReset_test))["Prop"];
|
|
ShouldSerializeFalseEffectOnCanReset_test test = new ShouldSerializeFalseEffectOnCanReset_test ();
|
|
|
|
Assert.IsFalse (p.ShouldSerializeValue (test), "1");
|
|
Assert.IsFalse (p.CanResetValue (test), "2");
|
|
}
|
|
|
|
[Test]
|
|
public void ReadOnlyPropertyTest ()
|
|
{
|
|
PropertyDescriptorCollection col = TypeDescriptor.GetProperties (typeof (ReadOnlyProperty_test));
|
|
Assert.IsTrue (col["Prop"].IsReadOnly, "1");
|
|
}
|
|
|
|
[Test]
|
|
public void ReadOnlyAttributeTest ()
|
|
{
|
|
PropertyDescriptorCollection col = TypeDescriptor.GetProperties (typeof (ReadOnlyAttribute_test));
|
|
Assert.IsTrue (col["Prop"].IsReadOnly, "1");
|
|
}
|
|
|
|
[Test]
|
|
public void ReadOnlyConflictingTest ()
|
|
{
|
|
PropertyDescriptorCollection col = TypeDescriptor.GetProperties (typeof (ConflictingReadOnly_test));
|
|
Assert.IsTrue (col["Prop"].IsReadOnly, "1");
|
|
}
|
|
|
|
[Test] // bug #80292
|
|
public void DisplayNameTest ()
|
|
{
|
|
PropertyDescriptor p1 = TypeDescriptor.GetProperties (typeof (DisplayName_test)) ["Explicit"];
|
|
PropertyDescriptor p2 = TypeDescriptor.GetProperties (typeof (DisplayName_test)) ["Implicit"];
|
|
|
|
#if NET_2_0
|
|
Assert.AreEqual ("An explicit displayname", p1.DisplayName, "#1");
|
|
#else
|
|
Assert.AreEqual ("Explicit", p1.DisplayName, "#1");
|
|
#endif
|
|
Assert.AreEqual ("Implicit", p2.DisplayName, "#2");
|
|
}
|
|
|
|
[Test]
|
|
public void GetEditorTest ()
|
|
{
|
|
PropertyDescriptorCollection col;
|
|
PropertyDescriptor pd;
|
|
UITypeEditor ed;
|
|
|
|
col = TypeDescriptor.GetProperties (typeof (GetEditor_test));
|
|
pd = col [0];
|
|
ed = pd.GetEditor (typeof (UITypeEditor)) as UITypeEditor;
|
|
|
|
Assert.IsNotNull (ed, "#01");
|
|
Assert.AreEqual (ed.GetType ().Name, "UIEditor", "#02");
|
|
}
|
|
|
|
[Test]
|
|
public void AddValueChanged ()
|
|
{
|
|
MockPropertyDescriptor pd = new MockPropertyDescriptor (
|
|
"Name", new Attribute [0]);
|
|
object compA = new object ();
|
|
object compB = new object ();
|
|
EventHandler handlerA = new EventHandler (ValueChanged1);
|
|
EventHandler handlerB = new EventHandler (ValueChanged1);
|
|
EventHandler handlerC = new EventHandler (ValueChanged2);
|
|
|
|
pd.AddValueChanged (compA, handlerA);
|
|
pd.AddValueChanged (compA, handlerC);
|
|
pd.AddValueChanged (compA, handlerC);
|
|
pd.AddValueChanged (compA, handlerB);
|
|
|
|
pd.FireValueChanged (compA, new EventArgs ());
|
|
Assert.AreEqual (4, _invokedHandlers.Count, "#A1");
|
|
Assert.AreEqual ("ValueChanged1", _invokedHandlers [0], "#A1");
|
|
Assert.AreEqual ("ValueChanged2", _invokedHandlers [1], "#A2");
|
|
Assert.AreEqual ("ValueChanged2", _invokedHandlers [2], "#A3");
|
|
Assert.AreEqual ("ValueChanged1", _invokedHandlers [3], "#A4");
|
|
|
|
Reset ();
|
|
|
|
pd.FireValueChanged (compB, new EventArgs ());
|
|
Assert.AreEqual (0, _invokedHandlers.Count, "#B");
|
|
}
|
|
|
|
[Test]
|
|
public void AddValueChanged_Component_Null ()
|
|
{
|
|
MockPropertyDescriptor pd = new MockPropertyDescriptor (
|
|
"Name", new Attribute [0]);
|
|
try {
|
|
pd.AddValueChanged (null, new EventHandler (ValueChanged1));
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("component", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void AddValueChanged_Handler_Null ()
|
|
{
|
|
MockPropertyDescriptor pd = new MockPropertyDescriptor (
|
|
"Name", new Attribute [0]);
|
|
try {
|
|
pd.AddValueChanged (new object (), (EventHandler) null);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("handler", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
#if NET_2_0
|
|
[Test]
|
|
public void GetInvocationTarget_Instance_Null ()
|
|
{
|
|
MockPropertyDescriptor pd = new MockPropertyDescriptor (
|
|
"Name", new Attribute [0]);
|
|
try {
|
|
pd.GetInvocationTarget (typeof (int), null);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("instance", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void GetInvocationTarget_Type_Null ()
|
|
{
|
|
MockPropertyDescriptor pd = new MockPropertyDescriptor (
|
|
"Name", new Attribute [0]);
|
|
try {
|
|
pd.GetInvocationTarget ((Type) null, new object ());
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("type", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void GetValueChangedHandler ()
|
|
{
|
|
object compA = new object ();
|
|
object compB = new object ();
|
|
EventHandler handlerA = new EventHandler (ValueChanged1);
|
|
EventHandler handlerB = new EventHandler (ValueChanged1);
|
|
EventHandler handlerC = new EventHandler (ValueChanged2);
|
|
|
|
MockPropertyDescriptor pd = new MockPropertyDescriptor (
|
|
"Name", new Attribute [0]);
|
|
Assert.IsNull (pd.GetValueChangedHandler (null), "#A1");
|
|
Assert.IsNull (pd.GetValueChangedHandler (compA), "#A2");
|
|
Assert.IsNull (pd.GetValueChangedHandler (compB), "#A3");
|
|
|
|
pd.AddValueChanged (compA, handlerA);
|
|
|
|
Assert.IsNull (pd.GetValueChangedHandler (null), "#B1");
|
|
Assert.AreSame (handlerA, pd.GetValueChangedHandler (compA), "#B2");
|
|
Assert.IsNull (pd.GetValueChangedHandler (compB), "#B3");
|
|
|
|
pd.AddValueChanged (compA, handlerB);
|
|
|
|
Assert.IsNull (pd.GetValueChangedHandler (null), "#C1");
|
|
EventHandler handler = pd.GetValueChangedHandler (compA);
|
|
Assert.AreEqual (2, handler.GetInvocationList ().Length, "#C2");
|
|
Assert.AreEqual (handlerA, handler.GetInvocationList () [0], "#C3");
|
|
Assert.AreEqual (handlerB, handler.GetInvocationList () [1], "#C4");
|
|
Assert.IsNull (pd.GetValueChangedHandler (compB), "#C5");
|
|
|
|
pd.AddValueChanged (compB, handlerA);
|
|
|
|
Assert.IsNull (pd.GetValueChangedHandler (null), "#D1");
|
|
handler = pd.GetValueChangedHandler (compA);
|
|
Assert.AreEqual (2, handler.GetInvocationList ().Length, "#D2");
|
|
Assert.AreSame (handlerA, pd.GetValueChangedHandler (compB), "#D3");
|
|
|
|
pd.RemoveValueChanged (compB, handlerB);
|
|
|
|
Assert.IsNull (pd.GetValueChangedHandler (null), "#E1");
|
|
handler = pd.GetValueChangedHandler (compA);
|
|
Assert.AreEqual (2, handler.GetInvocationList ().Length, "#E2");
|
|
Assert.IsNull (pd.GetValueChangedHandler (compB), "#E3");
|
|
|
|
pd.RemoveValueChanged (compB, handlerB);
|
|
|
|
Assert.IsNull (pd.GetValueChangedHandler (null), "#F1");
|
|
handler = pd.GetValueChangedHandler (compA);
|
|
Assert.AreEqual (2, handler.GetInvocationList ().Length, "#F2");
|
|
Assert.IsNull (pd.GetValueChangedHandler (compB), "#F3");
|
|
|
|
pd.RemoveValueChanged (compA, handlerC);
|
|
|
|
Assert.IsNull (pd.GetValueChangedHandler (null), "#G1");
|
|
handler = pd.GetValueChangedHandler (compA);
|
|
Assert.AreEqual (2, handler.GetInvocationList ().Length, "#G2");
|
|
Assert.IsNull (pd.GetValueChangedHandler (compB), "#G3");
|
|
|
|
pd.AddValueChanged (compA, handlerC);
|
|
|
|
Assert.IsNull (pd.GetValueChangedHandler (null), "#H1");
|
|
handler = pd.GetValueChangedHandler (compA);
|
|
Assert.AreEqual (3, handler.GetInvocationList ().Length, "#H2");
|
|
Assert.IsNull (pd.GetValueChangedHandler (compB), "#H3");
|
|
|
|
pd.RemoveValueChanged (compA, handlerB);
|
|
|
|
Assert.IsNull (pd.GetValueChangedHandler (null), "#I1");
|
|
handler = pd.GetValueChangedHandler (compA);
|
|
Assert.AreEqual (2, handler.GetInvocationList ().Length, "#I2");
|
|
Assert.AreEqual (handlerA, handler.GetInvocationList () [0], "#I3");
|
|
Assert.AreEqual (handlerC, handler.GetInvocationList () [1], "#I4");
|
|
Assert.IsNull (pd.GetValueChangedHandler (compB), "#I5");
|
|
}
|
|
#endif
|
|
|
|
[Test]
|
|
public void RemoveValueChanged ()
|
|
{
|
|
MockPropertyDescriptor pd = new MockPropertyDescriptor (
|
|
"Name", new Attribute [0]);
|
|
object compA = new object ();
|
|
object compB = new object ();
|
|
EventHandler handlerA = new EventHandler (ValueChanged1);
|
|
EventHandler handlerB = new EventHandler (ValueChanged1);
|
|
EventHandler handlerC = new EventHandler (ValueChanged2);
|
|
|
|
pd.AddValueChanged (compA, handlerA);
|
|
pd.AddValueChanged (compA, handlerC);
|
|
pd.AddValueChanged (compA, handlerC);
|
|
pd.AddValueChanged (compA, handlerB);
|
|
pd.AddValueChanged (compB, handlerC);
|
|
|
|
pd.FireValueChanged (compA, new EventArgs ());
|
|
Assert.AreEqual (4, _invokedHandlers.Count, "#A1");
|
|
pd.RemoveValueChanged (new object (), handlerC);
|
|
pd.FireValueChanged (compA, new EventArgs ());
|
|
Assert.AreEqual (8, _invokedHandlers.Count, "#A2");
|
|
|
|
Reset ();
|
|
pd.RemoveValueChanged (compA, handlerC);
|
|
|
|
pd.FireValueChanged (compA, new EventArgs ());
|
|
Assert.AreEqual (3, _invokedHandlers.Count, "#B1");
|
|
Assert.AreEqual ("ValueChanged1", _invokedHandlers [0], "#B2");
|
|
Assert.AreEqual ("ValueChanged2", _invokedHandlers [1], "#B3");
|
|
Assert.AreEqual ("ValueChanged1", _invokedHandlers [2], "#B4");
|
|
|
|
Reset ();
|
|
|
|
pd.FireValueChanged (compB, new EventArgs ());
|
|
Assert.AreEqual (1, _invokedHandlers.Count, "#C1");
|
|
Assert.AreEqual ("ValueChanged2", _invokedHandlers [0], "#C2");
|
|
|
|
Reset ();
|
|
pd.RemoveValueChanged (compB, handlerC);
|
|
|
|
pd.FireValueChanged (compB, new EventArgs ());
|
|
Assert.AreEqual (0, _invokedHandlers.Count, "#D");
|
|
}
|
|
|
|
[Test]
|
|
public void RemoveValueChanged_Component_Null ()
|
|
{
|
|
MockPropertyDescriptor pd = new MockPropertyDescriptor (
|
|
"Name", new Attribute [0]);
|
|
try {
|
|
pd.RemoveValueChanged (null, new EventHandler (ValueChanged1));
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("component", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void RemoveValueChanged_Handler_Null ()
|
|
{
|
|
MockPropertyDescriptor pd = new MockPropertyDescriptor (
|
|
"Name", new Attribute [0]);
|
|
try {
|
|
pd.RemoveValueChanged (new object (), (EventHandler) null);
|
|
Assert.Fail ("#1");
|
|
} catch (ArgumentNullException ex) {
|
|
Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
|
|
Assert.IsNull (ex.InnerException, "#3");
|
|
Assert.IsNotNull (ex.Message, "#4");
|
|
Assert.IsNotNull (ex.ParamName, "#5");
|
|
Assert.AreEqual ("handler", ex.ParamName, "#6");
|
|
}
|
|
}
|
|
|
|
void ValueChanged1 (object sender, EventArgs e)
|
|
{
|
|
_invokedHandlers.Add ("ValueChanged1");
|
|
}
|
|
|
|
void ValueChanged2 (object sender, EventArgs e)
|
|
{
|
|
_invokedHandlers.Add ("ValueChanged2");
|
|
}
|
|
|
|
class GetEditor_test
|
|
{
|
|
[Editor (typeof (UIEditor), typeof (UITypeEditor))]
|
|
public string Property {
|
|
get { return "abc"; }
|
|
set { }
|
|
}
|
|
}
|
|
|
|
class UIEditor : UITypeEditor
|
|
{
|
|
|
|
}
|
|
|
|
class MockPropertyDescriptor : PropertyDescriptor
|
|
{
|
|
public MockPropertyDescriptor (MemberDescriptor reference)
|
|
: base (reference)
|
|
{
|
|
}
|
|
|
|
public MockPropertyDescriptor (MemberDescriptor reference, Attribute [] attrs)
|
|
: base (reference, attrs)
|
|
{
|
|
}
|
|
|
|
public MockPropertyDescriptor (string name, Attribute [] attrs)
|
|
: base (name, attrs)
|
|
{
|
|
}
|
|
|
|
public override Type ComponentType {
|
|
get { return typeof (int); }
|
|
}
|
|
|
|
public override bool IsReadOnly {
|
|
get { return false; }
|
|
}
|
|
|
|
public override Type PropertyType{
|
|
get { return typeof (DateTime); }
|
|
}
|
|
|
|
public override object GetValue (object component)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
public override void SetValue (object component, object value)
|
|
{
|
|
}
|
|
|
|
public override void ResetValue (object component)
|
|
{
|
|
}
|
|
|
|
public override bool CanResetValue (object component)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public override bool ShouldSerializeValue (object component)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public void FireValueChanged (object component, EventArgs e)
|
|
{
|
|
base.OnValueChanged (component, e);
|
|
}
|
|
|
|
#if NET_2_0
|
|
public new object GetInvocationTarget (Type type, object instance)
|
|
{
|
|
return base.GetInvocationTarget (type, instance);
|
|
}
|
|
|
|
public new EventHandler GetValueChangedHandler (object component)
|
|
{
|
|
return base.GetValueChangedHandler (component);
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|