public void ProvideValueConst ()
{
var x = new StaticExtension ();
x.MemberType = typeof (XamlLanguage);
x.Member = "Xaml2006Namespace";
Assert.AreEqual (XamlLanguage.Xaml2006Namespace, x.ProvideValue (null), "#1");
}
public void ProvideValueStaticProperty ()
{
var x = new StaticExtension ();
x.MemberType = typeof (XamlLanguage);
x.Member = "Array";
Assert.AreEqual (XamlLanguage.Array, x.ProvideValue (null), "#1");
}
public void ProvideValueInstanceProperty ()
{
var x = new StaticExtension ();
x.MemberType = typeof (StaticExtension);
x.Member = "MemberType"; // instance property is out of scope.
x.ProvideValue (null);
}
public void ProvideValueTest_nonIXamlTypeResolver ()
{
StaticExtension se = new StaticExtension ("Test.Field");
ProviderPoker p = new ProviderPoker (new object());
Assert.IsNull (se.ProvideValue (p));
}
public void CtorTest ()
{
StaticExtension s = new StaticExtension ();
Assert.IsNull (s.Member);
s = new StaticExtension ("hi");
Assert.AreEqual ("hi", s.Member);
}
public void ProvideValueTest_nullService ()
{
StaticExtension se = new StaticExtension ("Test.Field");
ProviderPoker p = new ProviderPoker (null);
Assert.IsNull (se.ProvideValue (p));
}
public void ProvideValueWithoutType ()
{
var x = new StaticExtension ();
// it fails because it cannot be resolved to a static member.
// This possibly mean, there might be a member that
// could be resolved only with the name, without type.
x.Member = "Foo";
x.ProvideValue (null);
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(InstanceDescriptor))
{
StaticExtension staticExtension = value as StaticExtension;
if (staticExtension == null)
{
throw new ArgumentException(SR.Get(SRID.MustBeOfType, "value", "StaticExtension"));
}
return(new InstanceDescriptor(typeof(StaticExtension).GetConstructor(new Type[] { typeof(string) }),
new object[] { staticExtension.Member }));
}
return(base.ConvertTo(context, culture, value, destinationType));
}
public void ProvideValueTest_IXamlTypeResolver_PrivateStaticProperty ()
{
StaticExtension ne = new StaticExtension ("Test.Property");
ProviderPoker2 p = new ProviderPoker2 (typeof (PrivateStaticPropertyTest));
Assert.AreEqual (5, ne.ProvideValue (p));
}
public void ProvideValueTest_IXamlTypeResolver_Enum ()
{
StaticExtension ne = new StaticExtension ("Test.Foo");
ProviderPoker2 p = new ProviderPoker2 (typeof (EnumTest));
Assert.AreEqual (EnumTest.Foo, ne.ProvideValue (p));
}
public void ProvideValueTest_IXamlTypeResolver_StaticField ()
{
StaticExtension ne = new StaticExtension ("Test.Field");
ProviderPoker2 p = new ProviderPoker2 (typeof (StaticFieldTest));
Assert.AreEqual (5, ne.ProvideValue (p));
}
public void ProvideValueTest_IXamlTypeResolver_MissingField ()
{
StaticExtension ne = new StaticExtension ("Test.Field2");
ProviderPoker2 p = new ProviderPoker2 (typeof (StaticFieldTest));
ne.ProvideValue (p);
}
// The end of the constructor parameter section has been reached. Create an
// instance of the object after finding the appropriate constructor and converting
// all of the objects held on the stack.
internal virtual void ReadConstructorParametersEndRecord()
{
Type elementType = ParentContext.ExpectedType;
short positiveElementTypeId = (short)-ParentContext.ExpectedTypeId;
object param = null;
ArrayList paramList = null;
int paramCount;
object instance = null;
bool foundInstance = false;
if( TraceMarkup.IsEnabled )
{
TraceMarkup.Trace( TraceEventType.Start,
TraceMarkup.CreateMarkupExtension,
elementType );
}
if (CurrentContext.CheckFlag(ReaderFlags.SingletonConstructorParam))
{
param = CurrentContext.ObjectData;
paramCount = 1;
// Fast code path for [static/dynamic] resource extensions &
// Type/Static/TemplateBinding extensions
switch (positiveElementTypeId)
{
case (short)KnownElements.TypeExtension:
// Note that this assumes that TypeExtension has a
// constructor with one param of type Type or String.
Type t = param as Type;
if (t != null)
{
instance = new TypeExtension(t);
}
else
{
Debug.Assert(param is String);
instance = new TypeExtension((String)param);
}
foundInstance = true;
break;
case (short)KnownElements.StaticResourceExtension:
// Note that this assumes that StaticResourceExtension has a
// constructor with one param of type object.
instance = new StaticResourceExtension(param);
foundInstance = true;
break;
case (short)KnownElements.DynamicResourceExtension:
// Note that this assumes that DynamicResourceExtension has a
// constructor with one param of type object.
instance = new DynamicResourceExtension(param);
foundInstance = true;
break;
case (short)KnownElements.StaticExtension:
// Note that this assumes that StaticExtension has a default
// constructor and one public property of type string and one
// internal property of type object for optimized member info.
instance = new StaticExtension((string)param);
foundInstance = true;
break;
case (short)KnownElements.TemplateBindingExtension:
// Note that this assumes that TemplateBindingExtension has a
// constructor with one param of type DependencyProperty. If a
// string is passed in due to there being other attributes like
// converter being set, then that needs to be converted now first.
DependencyProperty dp = param as DependencyProperty;
if (dp == null)
{
string paramString = param as string;
Type ownerType = ParserContext.TargetType;
Debug.Assert(paramString != null);
dp = XamlTypeMapper.ParsePropertyName(ParserContext,
paramString.Trim(),
ref ownerType);
if (dp == null)
{
ThrowException(SRID.ParserNoDPOnOwner, paramString, ownerType.FullName);
}
}
instance = new TemplateBindingExtension(dp);
foundInstance = true;
break;
}
}
else
{
paramList = (ArrayList)CurrentContext.ObjectData;
paramCount = paramList.Count;
}
if (!foundInstance)
{
// Find the constructor based on the number of parameters stored in paramList
XamlTypeMapper.ConstructorData data = XamlTypeMapper.GetConstructors(elementType);
ConstructorInfo[] infos = data.Constructors;
for (int i=0; i<infos.Length; i++)
{
ConstructorInfo info = infos[i];
ParameterInfo[] paramInfos = data.GetParameters(i);
if (paramInfos.Length == paramCount)
{
object[] paramArray = new object[paramInfos.Length];
if (paramCount == 1)
{
Debug.Assert(param != null && paramList == null, "Must have a single param");
ProcessConstructorParameter(paramInfos[0], param, ref paramArray[0]);
// Fast code path for other markupextensions
if (positiveElementTypeId == (short)KnownElements.RelativeSource)
{
// Note that this assumes that RelativeSource has a
// constructor with one param of type RelativeSourceMode.
instance = new System.Windows.Data.RelativeSource((System.Windows.Data.RelativeSourceMode)paramArray[0]);
foundInstance = true;
}
}
else
{
Debug.Assert(param == null && paramList != null, "Must have a paramList");
// Check each type and attempt to convert the paramList using
// the type converter associated with each parameter type.
for (int j=0; j<paramInfos.Length; j++)
{
ProcessConstructorParameter(paramInfos[j], paramList[j], ref paramArray[j]);
}
}
if (!foundInstance)
{
// If we make it to here we have a list of converted parameters, so
// invoke the constructor with that list.
#if !STRESS
try
{
#endif
instance = info.Invoke(paramArray);
foundInstance = true;
#if !STRESS
}
catch (Exception e)
{
if (CriticalExceptions.IsCriticalException(e) || e is XamlParseException)
{
throw;
}
TargetInvocationException tie = e as TargetInvocationException;
if( tie != null )
{
e = tie.InnerException;
}
ThrowExceptionWithLine(SR.Get(SRID.ParserFailedToCreateFromConstructor, info.DeclaringType.Name), e);
}
#endif
}
}
}
}
if (foundInstance)
{
ParentContext.ObjectData = instance;
ParentContext.ExpectedType = null;
PopContext();
}
else
{
// If we get to here, then no matching constructor was found, so complain
ThrowException(SRID.ParserBadConstructorParams, elementType.Name, paramCount.ToString(CultureInfo.CurrentCulture));
}
if( TraceMarkup.IsEnabled )
{
TraceMarkup.Trace( TraceEventType.Stop,
TraceMarkup.CreateMarkupExtension,
elementType,
instance );
}
}
public void ProvideValuePrivateConst ()
{
var x = new StaticExtension ();
x.MemberType = GetType ();
x.Member = "FooBar"; // private const could not be resolved.
Assert.AreEqual ("foobar", x.ProvideValue (null), "#1");
}
public void ProvideValueWithoutMember ()
{
var x = new StaticExtension ();
x.MemberType = typeof (int);
x.ProvideValue (null);
}
private object GetStaticExtensionValue(short memberId)
{
object valueObject = null;
if (memberId < 0)
{
short keyId = (short)-memberId;
// if keyId is more than the range it is the actual resource, else it is the key.
if (keyId > (short)SystemResourceKeyID.InternalSystemThemeStylesEnd)
{
keyId -= (short)SystemResourceKeyID.InternalSystemThemeStylesEnd;
valueObject = SystemResourceKey.GetResource(keyId);
}
else
{
valueObject = SystemResourceKey.GetResourceKey(keyId);
}
}
else
{
BamlAttributeInfoRecord attribInfo = MapTable.GetAttributeInfoFromId(memberId);
if (attribInfo != null)
{
StaticExtension se = new StaticExtension();
se.MemberType = MapTable.GetTypeFromId(attribInfo.OwnerTypeId);
se.Member = attribInfo.Name;
valueObject = se.ProvideValue(null);
}
}
return valueObject;
}
public void ProvideValueEvent ()
{
var x = new StaticExtension ();
x.MemberType = GetType ();
x.Member = "FooEvent"; // private const could not be resolved.
Assert.IsNotNull (x.ProvideValue (null), "#1");
}
