public void GetPropertyByFullName_should_include_classes_marked_with_Extender_compound_name()
{
var def = PropertyTreeDefinition.FromType(typeof(Alpha));
var fac = def.GetProperty("Charlie.ValueExtender", "https://ns.example.com/", GetPropertyOptions.IncludeExtenders);
AssertIsCharlieValueExtender(fac);
}
public void add_method_default_implicit()
{
PropertyTreeDefinition def = PropertyTreeDefinition.FromType(typeof(S));
Assert.Equal(2, def.Operators.Count);
Assert.True(def.Operators.Contains("something"));
}
public void GetPropertyByLocalName_should_include_classes_marked_with_Extender()
{
var def = PropertyTreeDefinition.FromType(typeof(Alpha));
var fac = def.GetProperty("ValueExtender", GetPropertyOptions.IncludeExtenders);
AssertIsCharlieValueExtender(fac);
}
public void add_child_operators_inherited()
{
var def = PropertyTreeDefinition.FromType(typeof(ContainerControl));
var fac = def.GetOperator("p");
Assert.NotNull(fac);
}
public void get_property_nominal()
{
var a = PropertyTreeDefinition.FromType(typeof(Alpha));
Assert.Contains("A", a.Properties.Select(t => t.Name));
Assert.NotNull(a.GetProperty("A"));
}
public void Properties_should_include_the_IProperties_indexer()
{
var def = PropertyTreeDefinition.FromType(typeof(Properties));
var indexer = def.Properties.OfType <IndexerUsingIPropertiesPropertyDefinition>().FirstOrDefault();
Assert.NotNull(indexer);
}
void IRoleAttribute.ProcessExtensionMethod(MethodInfo mi)
{
var target = (ReflectedPropertyTreeDefinition)PropertyTreeDefinition.FromType(
mi.GetParameters()[0].ParameterType);
target.AddFactoryDefinition(ReflectedPropertyTreeFactoryDefinition.FromFactory(this, mi));
}
public void generic_list_operators_should_override()
{
var def = PropertyTreeDefinition.FromType(typeof(GenericList));
Assert.Null(def.GetOperator("add"));
Assert.NotNull(def.GetOperator("s"));
}
public void addon_method_nominal()
{
var def = PropertyTreeDefinition.FromType(typeof(Omicron));
var alphaAddon = def.GetOperator("alpha");
Assert.NotNull(alphaAddon);
Assert.Equal(0, alphaAddon.Parameters.Count);
}
public void addon_method_extension()
{
var def = PropertyTreeDefinition.FromType(typeof(Omicron));
var gammaAddon = def.GetOperator("gammaOptional");
Assert.NotNull(gammaAddon);
Assert.Equal(2, gammaAddon.Parameters.Count);
}
public void ComputeName_Natural_should_use_return_type(Type type, string expected)
{
var method = type.GetTypeInfo().GetMethod("AddNew");
string name = ((IRoleAttribute)AddAttribute.Natural).ComputeName(method);
Assert.Equal(expected, name, StringComparer.OrdinalIgnoreCase);
Assert.Contains(expected, PropertyTreeDefinition.FromType(type).EnumerateOperators().Select(t => t.Name));
}
public void simple_properties_should_equal_expected_values_in_simple_types()
{
var a = PropertyTreeDefinition.FromType(typeof(Alpha));
Assert.Equal("Alpha", a.Name);
Assert.Equal("https://ns.example.com/", a.Namespace);
Assert.Equal(typeof(Alpha), a.SourceClrType);
}
public void Name_should_equal_mangle_in_constructed_generic_type()
{
var a = PropertyTreeDefinition.FromType(typeof(List <Alpha>));
Assert.Equal("List-1", a.Name);
Assert.Equal("", a.Namespace);
Assert.Equal(typeof(List <Alpha>), a.SourceClrType);
}
public void add_child_operators_inherited_constructed_generics()
{
var def = PropertyTreeDefinition.FromType(typeof(Collection <Control>));
var fac = def.GetOperator("add");
Assert.NotNull(fac);
Assert.Equal("", fac.Namespace);
Assert.Equal("Add", fac.Name);
}
public void properties_should_include_text_type_indexer()
{
var def = PropertyTreeDefinition.FromType(typeof(Dictionary <QualifiedName, int>));
Assert.NotNull(def.Properties.FirstOrDefault(t => t.IsIndexer));
def = PropertyTreeDefinition.FromType(typeof(Dictionary <string, int>));
Assert.NotNull(def.Properties.FirstOrDefault(t => t.IsIndexer));
}
public void add_child_operators_nominal()
{
var def = PropertyTreeDefinition.FromType(typeof(IAddChild <Control>));
var fac = def.GetOperator("p");
var fac2 = def.Operators.GetByLocalName("p");
Assert.NotNull(fac);
Assert.NotEmpty(fac2);
}
public PropertyDefinition FindProperty(PropertyTreeDefinition definition,
Type componentType,
QualifiedName qn,
IEnumerable <PropertyTreeDefinition> ancestors)
{
// Allow any namespace contained in the definition base classes
var result = definition
.EnumerateProperties()
.FirstOrDefault(t => Compare(t, qn, definition));
if (result != null)
{
return(result);
}
int dot = qn.LocalName.IndexOf('.');
if (dot > 0)
{
// TODO Index whether the PTD has extenders so we can skip some ancestors (perf)
string prefix = qn.LocalName.Substring(0, dot);
foreach (var currentDef in ancestors)
{
if (currentDef.Name == prefix)
{
// TODO Local name could be different
var prop = currentDef.GetProperty(qn);
if (prop != null)
{
return(prop);
}
}
}
}
else
{
foreach (var curDefinition in ancestors)
{
var prop = curDefinition.GetProperty(qn);
if (IsValidExtender(prop, componentType))
{
return(prop);
}
var qn2 = qn.ChangeLocalName(curDefinition.Name + "." + qn.LocalName);
prop = curDefinition.GetProperty(qn2);
if (IsValidExtender(prop, componentType))
{
return(prop);
}
}
}
return(null);
}
public void get_extender_property_nominal()
{
var def = PropertyTreeDefinition.FromType(typeof(Canvas));
var fac = def.GetProperty("Canvas.top");
Assert.NotNull(fac);
Assert.True(fac.IsExtender);
Assert.True(fac.CanExtend(typeof(Control)));
Assert.Equal("https://ns.example.com/", fac.Namespace);
}
public void get_extender_property_extension_method_inherit()
{
var def = PropertyTreeDefinition.FromType(typeof(Paragraph));
var fac = def.GetProperty("left", GetPropertyOptions.IncludeExtenders);
Assert.NotNull(fac);
Assert.True(fac.IsExtender);
Assert.True(fac.CanExtend(typeof(Paragraph)));
Assert.Equal("https://ns.example.com/", fac.Namespace);
}
public void FindOperator_should_implicitly_handle_inherited_operator_names()
{
var unit = new PropertyNameLookupHelper();
var comp = PropertyTreeDefinition.FromType(typeof(ComponentCollection));
// Though add is defined inside default NS, it is accessible via the NS of the type
var qn = QualifiedName.Create(comp.Namespace, "add");
var result = unit.FindOperator(comp, typeof(ComponentCollection), qn);
Assert.NotNull(result);
}
public void get_generic_list_operators()
{
var def = PropertyTreeDefinition.FromType(typeof(Delta));
Assert.Equal(0, def.Operators.Count);
def = PropertyTreeDefinition.FromType(typeof(IList <Alpha>));
Assert.NotNull(def.GetOperator("add"));
Assert.NotNull(def.GetOperator("remove"));
Assert.NotNull(def.GetOperator("clear"));
}
internal virtual OperatorDefinition SelectOperator(QualifiedName qn)
{
var treeDef = PropertyTreeDefinition.FromType(this.ComponentType);
var factory = propertyLookup.FindOperator(treeDef, this.ComponentType, qn);
if (factory == null && ProbeRuntimeComponents())
{
factory = propertyLookup.FindOperator(treeDef, this.ComponentType, qn);
}
return(factory);
}
public void Bind_should_prefer_reflection()
{
var props = PropertyTreeDefinition.FromType(typeof(F))
.Properties.GetByLocalName("s");
var def = PropertyTreeDefinition.FromType(typeof(F));
const string text = @"<fileTarget s='50'> </fileTarget>";
var f = StreamContext.FromText(text).ReadPropertyTree <F>();
Assert.Equal(50, f.S);
}
public void SetProperty_should_apply_to_IPropertiesContainer()
{
var def = PropertyTreeDefinition.FromType(typeof(IPropertiesContainer));
var indexer = def.Properties.OfType <IndexerUsingIPropertiesPropertyDefinition>().FirstOrDefault();
Assert.NotNull(indexer);
var it = new FakePropertiesContainer();
indexer.SetValue(it, QualifiedName.Parse("a"), "hello");
Assert.Equal("hello", it.Properties["a"]);
}
public void FindOperator_should_implicitly_handle_inherited_operator_names_constructed_generics()
{
var unit = new PropertyNameLookupHelper();
var comp = PropertyTreeDefinition.FromType(typeof(Collection <Control>));
// Though add is defined inside default NS, it is accessible via the NS of the type
var qn = QualifiedName.Create("https://ns.example.com", "add");
var result = unit.FindOperator(comp, typeof(Collection <Control>), qn);
var ops = comp.EnumerateOperators();
Assert.NotNull(result);
Assert.Same(comp.GetOperator("add"), result);
}
internal override void ApplyUriContextToProperties(Uri baseUri)
{
if (Component != null)
{
foreach (var prop in PropertyTreeDefinition.FromType(ComponentType).UriContextCache)
{
object value;
if (prop.TryGetValue(Component, null, prop.QualifiedName, out value) && value != null)
{
((IUriContext)value).BaseUri = baseUri;
}
}
}
}
public override PropertyTreeMetaObject Process(PropertyTreeBinderImpl parent, PropertyTreeMetaObject target, PropertyTreeNavigator self, NodeList children)
{
QualifiedName name = self.QualifiedName;
var ctor = PropertyTreeDefinition.FromType(target.ComponentType).Constructor;
if (target.ShouldConstruct && ctor != null)
{
OperatorDefinition op = ctor;
var args = parent.ExtractParameterDictionary(op, target, parent.GetBasicServices(self), children);
target = target.BindConstructor(ctor, args);
}
return(target);
}
public void get_extender_property_extension_method()
{
var def = PropertyTreeDefinition.FromType(typeof(Control));
var fac = def.GetProperty("ControlExtensions.left");
Assert.NotNull(fac);
Assert.True(fac.IsExtender);
Assert.True(fac.CanExtend(typeof(Paragraph)));
Assert.Equal("https://ns.example.com/", fac.Namespace);
// Look for type inheritance
def = PropertyTreeDefinition.FromType(typeof(Paragraph));
var other = def.GetProperty("ControlExtensions.left");
Assert.Same(fac, other);
}
void IRoleAttribute.ProcessExtensionMethod(MethodInfo mi)
{
var target = (ReflectedPropertyTreeDefinition)PropertyTreeDefinition.FromType(
mi.GetParameters()[0].ParameterType);
var attachedID = GetAttachedPropertyID(mi);
var existing = (ReflectedExtenderPropertyDefinition)target.GetProperty(attachedID);
if (existing == null)
{
var extender = new ReflectedExtenderPropertyDefinition(attachedID);
target.AddPropertyDefinition(extender);
existing = extender;
}
existing.AddMethod(mi);
}
public PropertyDefinition FindProperty(PropertyTreeDefinition definition,
Type componentType,
QualifiedName qn,
IEnumerable<PropertyTreeDefinition> ancestors)
{
// Allow any namespace contained in the definition base classes
var result = definition
.EnumerateProperties()
.FirstOrDefault(t => Compare(t, qn, definition));
if (result != null)
return result;
int dot = qn.LocalName.IndexOf('.');
if (dot > 0) {
// TODO Index whether the PTD has extenders so we can skip some ancestors (perf)
string prefix = qn.LocalName.Substring(0, dot);
foreach (var currentDef in ancestors) {
if (currentDef.Name == prefix) {
// TODO Local name could be different
var prop = currentDef.GetProperty(qn);
if (prop != null) {
return prop;
}
}
}
} else {
foreach (var curDefinition in ancestors) {
var prop = curDefinition.GetProperty(qn);
if (IsValidExtender(prop, componentType))
return prop;
var qn2 = qn.ChangeLocalName(curDefinition.Name + "." + qn.LocalName);
prop = curDefinition.GetProperty(qn2);
if (IsValidExtender(prop, componentType))
return prop;
}
}
return null;
}
internal PropertyTreeDefinition GetDefinition()
{
object component = this.Component;
if (component != null)
{
return(PropertyTreeDefinition.FromValue(component));
}
else if (this.ComponentType != null)
{
return(PropertyTreeDefinition.FromType(this.ComponentType));
}
else
{
return(null);
}
}
protected internal virtual void VisitPropertyTree(PropertyTreeDefinition node)
{
DefaultVisit(node);
}
private static bool Compare(PropertyNodeDefinition t,
QualifiedName qn,
PropertyTreeDefinition definition)
{
var x = t.QualifiedName;
var y = qn;
if (x == y)
return true;
if (string.Equals(x.LocalName, y.LocalName, StringComparison.OrdinalIgnoreCase))
return x.Namespace == y.Namespace
|| x.Namespace == string.Empty
|| (definition.GetSerializationCandidateNamespaces().Any(m => m == y.Namespace));
else
return false;
}
public OperatorDefinition FindOperator(PropertyTreeDefinition definition, Type type, QualifiedName qn)
{
return definition
.EnumerateOperators()
.FirstOrDefault(t => Compare(t, qn, definition));
}
public PropertyTreeDefinition ImportType(PropertyTreeDefinition definition)
{
if (definition == null)
throw new ArgumentNullException("definition");
throw new NotImplementedException();
}
