public void WhenDoubleValue_ShouldReturn_DoubleProperty()
{
var text1 = "version=3.6";
var text2 = "fontsize=0.8";
var text3 = "fontratio=0.75";
var text4 = "somethingzero=0.0";
var parser = new PropertyParser();
var property1 = parser.Parse(text1);
var property2 = parser.Parse(text2);
var property3 = parser.Parse(text3);
var property4 = parser.Parse(text4);
Assert.AreEqual("version", property1.Name);
Assert.AreEqual("fontsize", property2.Name);
Assert.AreEqual("fontratio", property3.Name);
Assert.AreEqual("somethingzero", property4.Name);
Assert.AreEqual(3.6, property1.Value);
Assert.AreEqual(0.8, property2.Value);
Assert.AreEqual(0.75, property3.Value);
Assert.AreEqual(0.0, property4.Value);
Assert.AreEqual(typeof(double), property1.Value.GetType());
Assert.AreEqual(typeof(double), property2.Value.GetType());
Assert.AreEqual(typeof(double), property3.Value.GetType());
Assert.AreEqual(typeof(double), property4.Value.GetType());
}
public void WhenArrayValue_ShouldReturn_ArrayProperty()
{
var text1 = "margins=(4,0,0,0)";
var text2 = "columns=(1,1)";
var parser = new PropertyParser();
var property1 = parser.Parse(text1);
var property2 = parser.Parse(text2);
Assert.AreEqual("margins", property1.Name);
Assert.AreEqual("columns", property2.Name);
Assert.AreEqual(4, ((object[])property1.Value).Length);
Assert.AreEqual(2, ((object[])property2.Value).Length);
Assert.AreEqual(typeof(object[]), property1.Value.GetType());
Assert.AreEqual(typeof(object[]), property2.Value.GetType());
Console.WriteLine("property1 values:");
foreach (var item in (object[])property1.Value)
{
Assert.AreEqual(typeof(int), item.GetType());
Console.WriteLine(item.ToString() + "\t" + item.GetType());
}
Console.WriteLine("property2 values:");
foreach (var item in (object[])property2.Value)
{
Assert.AreEqual(typeof(int), item.GetType());
Console.WriteLine(item.ToString() + "\t" + item.GetType());
}
}
public void WhenIntValue_ShouldReturn_IntProperty()
{
var text1 = "version=3";
var text2 = "fontsize=153";
var text3 = "fontratio=5";
var text4 = "somethingzero=0";
var parser = new PropertyParser();
var property1 = parser.Parse(text1);
var property2 = parser.Parse(text2);
var property3 = parser.Parse(text3);
var property4 = parser.Parse(text4);
Assert.AreEqual("version", property1.Name);
Assert.AreEqual("fontsize", property2.Name);
Assert.AreEqual("fontratio", property3.Name);
Assert.AreEqual("somethingzero", property4.Name);
Assert.AreEqual(3, property1.Value);
Assert.AreEqual(153, property2.Value);
Assert.AreEqual(5, property3.Value);
Assert.AreEqual(0, property4.Value);
Assert.AreEqual(typeof(int), property1.Value.GetType());
Assert.AreEqual(typeof(int), property2.Value.GetType());
Assert.AreEqual(typeof(int), property3.Value.GetType());
Assert.AreEqual(typeof(int), property4.Value.GetType());
}
public void WhenStringValue_ShouldReturn_StringProperty()
{
var text1 = "string=\"------------------\"";
var text2 = "fontname=\"Courier New\"";
var text3 = "rule=\"if (GetValue(\\\"PROFILE\\\") != NextValue(\\\"PROFILE\\\")||IsLast()) then\\n Output()\\nelse\\n StepOver()\\nendif\"";
var text4 = "name=\"sum_LENGTH\"";
var parser = new PropertyParser();
var property1 = parser.Parse(text1);
var property2 = parser.Parse(text2);
var property3 = parser.Parse(text3);
var property4 = parser.Parse(text4);
Assert.AreEqual("string", property1.Name);
Assert.AreEqual("fontname", property2.Name);
Assert.AreEqual("rule", property3.Name);
Assert.AreEqual("name", property4.Name);
Assert.AreEqual("------------------", property1.Value);
Assert.AreEqual("Courier New", property2.Value);
Assert.AreEqual("if (GetValue(\\\"PROFILE\\\") != NextValue(\\\"PROFILE\\\")||IsLast()) then\\n Output()\\nelse\\n StepOver()\\nendif", property3.Value);
Assert.AreEqual("sum_LENGTH", property4.Value);
Assert.AreEqual(typeof(string), property1.Value.GetType());
Assert.AreEqual(typeof(string), property2.Value.GetType());
Assert.AreEqual(typeof(string), property3.Value.GetType());
Assert.AreEqual(typeof(string), property4.Value.GetType());
}
private static Properties GetProperties(string filePath, PropertiesSerializationContext propertiesContext)
{
var properties = PropertyParser.Parse(filePath);
properties.ExpandEnvironmentVariables(propertiesContext.ExpandVariables);
return(properties);
}
public static PassiveTree GenerateTree(PoeDataService.PassiveTreeJson passiveTreeJson, Leagues league)
{
var passiveTree = new PassiveTree
{
League = league,
};
foreach (var jsonNode in passiveTreeJson.Nodes.Values)
{
var node = new Node
{
Id = jsonNode.Id,
Name = jsonNode.Dn,
Icon = jsonNode.Icon,
Properties = new Property[jsonNode.Sd.Length],
};
for (var i = 0; i < jsonNode.Sd.Length; i++)
{
node.Properties[i] = PropertyParser.Parse(jsonNode.Sd[i]);
}
passiveTree.Nodes.Add(node);
}
return(passiveTree);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
var registry = AvaloniaPropertyRegistry.Instance;
var parser = new PropertyParser();
var reader = new CharacterReader((string)value);
var(ns, owner, propertyName) = parser.Parse(reader);
var ownerType = TryResolveOwnerByName(context, ns, owner);
var targetType = context.GetFirstAmbientValue <ControlTemplate>()?.TargetType ??
context.GetFirstAmbientValue <Style>()?.Selector?.TargetType ??
typeof(Control);
var effectiveOwner = ownerType ?? targetType;
var property = registry.FindRegistered(effectiveOwner, propertyName);
if (property == null)
{
throw new XamlLoadException($"Could not find property '{effectiveOwner.Name}.{propertyName}'.");
}
if (effectiveOwner != targetType &&
!property.IsAttached &&
!registry.IsRegistered(targetType, property))
{
Logger.Warning(
LogArea.Property,
this,
"Property '{Owner}.{Name}' is not registered on '{Type}'.",
effectiveOwner,
propertyName,
targetType);
}
return(property);
}
public void JToken_JTokenFormatter_ComplexObject()
{
var testVal = JObject.Parse(@"{
""msg"": ""JS error message"",
""logLevel"": ""error"",
""data"": {
""link"": ""https://test.com"",
""description"": ""error description"",
""values"": [
""value1"",
""value2"",
""value3""
]
}
}");
var formatter = new JTokenFormatter(new DefaultJTokenFormatters(), ",", 3);
var result = formatter.Format(testVal, 0);
var propParser = new PropertyParser(new DefaultFormatters(), ",");
var result2 = propParser.Parse(testVal);
Assert.Equal(5, result.Count);
Assert.Equal("JS error message", result["msg"]);
Assert.Equal("error", result["logLevel"]);
Assert.Equal("https://test.com", result["data_link"]);
Assert.Equal("error description", result["data_description"]);
Assert.Equal("value1,value2,value3", result["data_values"]);
}
public static bool Parse(SyntaxContext context, int position)
{
var list = context.list;
var offset = 0;
var index = position;
var count = 0;
var isMissed = false;
if (!ParserHelper.IsOperator(list[index], "-"))
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
while (ParenParser.Parse(context, index))
{
;
}
while (TableIParser.Parse(context, index))
{
;
}
while (TableSParser.Parse(context, index))
{
;
}
while (ListParser.Parse(context, index))
{
;
}
while (PropertyParser.Parse(context, index))
{
;
}
while (IndexParser.Parse(context, index))
{
;
}
while (CallParser.Parse(context, index))
{
;
}
if (!list[index].isRightValue)
{
return(false);
}
else
{
// ignored
}
offset += 1;
index = position + offset;
context.Insert(position, ExpressionCreator.CreateNegate(list, position, offset));
context.Remove(position + 1, offset);
return(true);
}
protected override Type DoResolvePropertyType(String propertyExpression)
{
EsperEPL2GrammarParser.StartEventPropertyRuleContext ast = PropertyParser.Parse(propertyExpression);
return(PropertyParser.IsPropertyDynamic(ast)
? typeof(XmlNode)
: typeof(string));
}
protected override Type DoResolvePropertyType(String propertyExpression)
{
var ast = PropertyParser.Parse(propertyExpression);
return(PropertyParser.IsPropertyDynamic(ast)
? typeof(XNode)
: typeof(string));
}
protected override EventPropertyGetter DoResolvePropertyGetter(String propertyExpression)
{
var getter = _propertyGetterCache.Get(propertyExpression);
if (getter != null)
{
return(getter);
}
if (!ConfigurationEventTypeXMLDOM.IsXPathPropertyExpr)
{
var prop = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression);
getter = prop.GetGetterDOM();
if (!prop.IsDynamic)
{
getter = new DOMConvertingGetter(propertyExpression, (DOMPropertyGetter)getter, typeof(string));
}
}
else
{
try
{
var ast = PropertyParser.Parse(propertyExpression);
var isDynamic = PropertyParser.IsPropertyDynamic(ast);
var xPathExpr = SimpleXMLPropertyParser.Walk(
ast,
propertyExpression,
RootElementName,
_defaultNamespacePrefix,
_isResolvePropertiesAbsolute);
if (Log.IsInfoEnabled)
{
Log.Info("Compiling XPath expression for property '" + propertyExpression + "' as '" + xPathExpr +
"'");
}
var xPathExpression = XPathExpression.Compile(xPathExpr, NamespaceContext);
var xPathReturnType = isDynamic ? XPathResultType.Any : XPathResultType.String;
getter = new XPathPropertyGetter(
propertyExpression,
xPathExpr,
xPathExpression,
xPathReturnType,
null,
null);
}
catch (XPathException e)
{
throw new EPException(
"Error constructing XPath expression from property name '" + propertyExpression + '\'', e);
}
}
// no fragment factory, fragments not allowed
_propertyGetterCache.Put(propertyExpression, getter);
return(getter);
}
public void Fails_With_Trailing_Junk()
{
var target = new PropertyParser();
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(new CharacterReader("Foo%".AsSpan())));
Assert.Equal(3, ex.Column);
Assert.Equal("Unexpected '%'.", ex.Message);
}
public void Fails_With_Parens_And_Namespace_But_No_Owner()
{
var target = new PropertyParser();
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(new CharacterReader("(foo:Bar)".AsSpan())));
Assert.Equal(1, ex.Column);
Assert.Equal("Expected property owner.", ex.Message);
}
public void Fails_With_Invalid_Property_Name_After_Owner()
{
var target = new PropertyParser();
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(new CharacterReader("Foo.123".AsSpan())));
Assert.Equal(4, ex.Column);
Assert.Equal("Unexpected '1'.", ex.Message);
}
public void Fails_With_Empty_String()
{
var target = new PropertyParser();
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(new CharacterReader(ReadOnlySpan <char> .Empty)));
Assert.Equal(0, ex.Column);
Assert.Equal("Expected property name.", ex.Message);
}
public void Fails_With_Leading_Whitespace()
{
var target = new PropertyParser();
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(new CharacterReader(" Foo".AsSpan())));
Assert.Equal(0, ex.Column);
Assert.Equal("Unexpected ' '.", ex.Message);
}
public void Fails_With_Unexpected_Close_Parens()
{
var target = new PropertyParser();
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(new CharacterReader("Foo.Bar)".AsSpan())));
Assert.Equal(7, ex.Column);
Assert.Equal("Unexpected ')'.", ex.Message);
}
public void Fails_With_Too_Many_Namespaces()
{
var target = new PropertyParser();
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(new CharacterReader("foo:bar:Baz".AsSpan())));
Assert.Equal(8, ex.Column);
Assert.Equal("Unexpected ':'.", ex.Message);
}
public void Fails_With_Whitespace_Between_Owner_And_Name()
{
var target = new PropertyParser();
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(new CharacterReader("Foo. Bar".AsSpan())));
Assert.Equal(4, ex.Column);
Assert.Equal("Unexpected ' '.", ex.Message);
}
public void Fails_With_Invalid_Property_Name()
{
var target = new PropertyParser();
var reader = new CharacterReader("123");
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader));
Assert.Equal(0, ex.Column);
Assert.Equal("Unexpected '1'.", ex.Message);
}
public void Fails_With_Parens_But_No_Owner()
{
var target = new PropertyParser();
var reader = new CharacterReader("(Foo)");
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader));
Assert.Equal(1, ex.Column);
Assert.Equal("Expected property owner.", ex.Message);
}
public void Fails_With_Missing_Close_Parens()
{
var target = new PropertyParser();
var reader = new CharacterReader("(Foo.Bar");
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader));
Assert.Equal(8, ex.Column);
Assert.Equal("Expected ')'.", ex.Message);
}
public void Fails_With_Too_Many_Segments()
{
var target = new PropertyParser();
var reader = new CharacterReader("Foo.Bar.Baz");
var ex = Assert.Throws <ExpressionParseException>(() => target.Parse(reader));
Assert.Equal(8, ex.Column);
Assert.Equal("Unexpected '.'.", ex.Message);
}
public void WhenBoolValue_ShouldReturn_BoolProperty()
{
var text1 = "cacheable=TRUE";
var text2 = "somefalse=FALSE";
var parser = new PropertyParser();
var property1 = parser.Parse(text1);
var property2 = parser.Parse(text2);
Assert.AreEqual("cacheable", property1.Name);
Assert.AreEqual("somefalse", property2.Name);
Assert.AreEqual(true, property1.Value);
Assert.AreEqual(false, property2.Value);
Assert.AreEqual(typeof(bool), property1.Value.GetType());
Assert.AreEqual(typeof(bool), property2.Value.GetType());
}
public void Parses_Owner_And_Name()
{
var target = new PropertyParser();
var reader = new CharacterReader("Foo.Bar");
var(ns, owner, name) = target.Parse(reader);
Assert.Null(ns);
Assert.Equal("Foo", owner);
Assert.Equal("Bar", name);
}
public void PropParser_JsonObject()
{
var testVal = new
{
A = "test_String",
B = JObject.Parse("{\"propA\" : [1,2,3,4], \"propB\" : \"some_val\"}")
};
var propParser = new PropertyParser(new DefaultFormatters(), ",");
var result = propParser.Parse(testVal);
}
public void Parses_Name()
{
var target = new PropertyParser();
var reader = new CharacterReader("Foo".AsSpan());
var(ns, owner, name) = target.Parse(reader);
Assert.Null(ns);
Assert.Null(owner);
Assert.Equal("Foo", name);
}
public void Parses_Namespace_Owner_And_Name_With_Parentheses()
{
var target = new PropertyParser();
var reader = new CharacterReader("(foo:Bar.Baz)".AsSpan());
var(ns, owner, name) = target.Parse(reader);
Assert.Equal("foo", ns);
Assert.Equal("Bar", owner);
Assert.Equal("Baz", name);
}
public void Parses_Owner_And_Name_With_Parentheses()
{
var target = new PropertyParser();
var reader = new CharacterReader("(Foo.Bar)".AsSpan());
var(ns, owner, name) = target.Parse(reader);
Assert.Null(ns);
Assert.Equal("Foo", owner);
Assert.Equal("Bar", name);
}
