public void Parser_Should_Pass()
{
var p = MarkupExtensionParser.Parse("{guid 123}");
Assert.AreEqual("guid", p.Name);
Assert.AreEqual(1, p.Arguments.Count);
}
static void RunDetectionTest(string markup, int offset, MarkupExtensionInfo expectedResult)
{
MarkupExtensionInfo data = MarkupExtensionParser.Parse(markup);
MarkupExtensionInfo result = Utils.GetMarkupExtensionAtPosition(data, offset);
Assert.AreEqual(expectedResult, result);
}
public void MarkupExtensionParserParse()
{
tlog.Debug(tag, $"MarkupExtensionParserParse START");
try
{
string str = new string('a', 4);
IServiceProviderImpl provider = new IServiceProviderImpl();
Assert.IsNotNull(provider, "null IServiceProviderImplement");
extParser.Parse("myMatch", ref str, provider);
}
catch (Exception e)
{
tlog.Debug(tag, e.Message.ToString());
Assert.Fail("Caught Exception : Failed!");
}
tlog.Debug(tag, $"MarkupExtensionParserParse END");
}
private void Xml_SelectionChanged(object sender, RoutedEventArgs _)
{
try
{
Results.Text = MarkupExtensionParser.Parse(Xml.Text.Substring(0, Xml.SelectionStart)).ToString();
}
catch (Exception e)
{
Results.Text = e.ToString();
}
}
public void ParseExplicitPropertiesTest()
{
XamlNamespaces namespaces = new XamlNamespaces(String.Empty, "default-namespace");
XamlElement root1 = (XamlElement)MarkupExtensionParser.Parse("{root1 property1=value1, property2=value2}", namespaces);
Assert.AreEqual("root1", root1.Name.LocalName);
Assert.AreEqual(2, root1.Members.Count());
Assert.AreEqual("property1", root1.Members.ElementAt(0).Name.LocalName);
Assert.AreEqual("value1", root1.Members.ElementAt(0).Values.Single());
Assert.AreEqual("property2", root1.Members.ElementAt(1).Name.LocalName);
Assert.AreEqual("value2", root1.Members.ElementAt(1).Values.Single());
}
public void ParseNamespaceTest()
{
XamlNamespaces namespaces = new XamlNamespaces(new[]
{
new NamespaceDeclaration("ns1", "namespace1"),
new NamespaceDeclaration("ns2", "namespace2"),
});
XamlElement root1 = (XamlElement)MarkupExtensionParser.Parse("{ns1:root1 value1={ns2:child2}}", namespaces);
Assert.AreEqual("root1", root1.Name.LocalName);
Assert.AreEqual("namespace1", root1.Name.NamespaceName);
Assert.AreEqual("child2", (root1.Members.First().Values.Single() as XamlElement).Name.LocalName);
Assert.AreEqual("namespace2", (root1.Members.First().Values.Single() as XamlElement).Name.NamespaceName);
}
/// <summary>
/// Single line attribute line in style as:
/// attribute_name="attribute_value"
/// </summary>
/// <param name="attributeInfo"></param>
/// <returns></returns>
public static string ToSingleLineString(this AttributeInfo attributeInfo)
{
string valuePart;
if (attributeInfo.IsMarkupExtension)
{
var info = MarkupExtensionParser.Parse(attributeInfo.Value);
valuePart = info.ToSingleLineString();
}
else
{
valuePart = attributeInfo.Value.ToXmlEncodedString();
}
return($"{attributeInfo.Name}=\"{valuePart}\"");
}
public void ParseEscapedTextTest()
{
XamlNamespaces namespaces = new XamlNamespaces(String.Empty, "default-namespace");
string value = (string)MarkupExtensionParser.Parse("{}{0}{1}{2}", namespaces);
Assert.AreEqual("{0}{1}{2}", value);
try
{
MarkupExtensionParser.Parse("{0}{1}{2}", namespaces);
Assert.Fail();
}
catch
{
//
}
}
/// <summary>
/// Single line attribute line in style as:
/// attribute_name="attribute_value"
/// </summary>
/// <param name="attrInfo"></param>
/// <returns></returns>
public static string ToSingleLineString(this AttributeInfo attrInfo)
{
string valuePart;
if (attrInfo.IsMarkupExtension)
{
MarkupExtensionInfo info = MarkupExtensionParser.Parse(attrInfo.Value);
valuePart = info.ToSingleLineString();
}
else
{
valuePart = attrInfo.Value.ToXmlEncodedString();
}
return(String.Format("{0}=\"{1}\"",
attrInfo.Name,
valuePart));
}
public void MarkupExtensionParserParse()
{
tlog.Debug(tag, $"MarkupExtensionParserParse START");
try
{
string s1 = new string('a', 4);
IServiceProviderImplement serviceProviderImplement = new IServiceProviderImplement();
m1.Parse("myMatch", ref s1, serviceProviderImplement);
}
catch (Exception e)
{
Tizen.Log.Error(tag, "Caught Exception" + e.ToString());
Assert.Fail("Caught Exception" + e.ToString());
}
tlog.Debug(tag, $"MarkupExtensionParserParse END (OK)");
Assert.Pass("MarkupExtensionParserParse");
}
/// <summary>
/// Handles markup extension value in style as:
/// XyzAttribute="{XyzMarkup value1,
/// value2,
/// key1=value1,
/// key2=value2}"
/// </summary>
/// <param name="attributeInfo"></param>
/// <param name="baseIndentationString"></param>
/// <returns></returns>
public static string ToMultiLineString(this AttributeInfo attributeInfo, string baseIndentationString)
{
if (!attributeInfo.IsMarkupExtension)
{
throw new ArgumentException(
"AttributeInfo must have a markup extension value.",
MethodBase.GetCurrentMethod().GetParameters()[0].Name);
}
MarkupExtensionInfo info = MarkupExtensionParser.Parse(attributeInfo.Value);
string currentIndentationString = baseIndentationString
+ String.Empty.PadLeft((attributeInfo.Name.Length + 2), ' ');
string value = info.ToMultiLineString(currentIndentationString);
var buffer = new StringBuilder();
buffer.AppendFormat("{0}=\"{1}\"", attributeInfo.Name, value);
return(buffer.ToString());
}
public void ParseChildrenTest()
{
XamlNamespaces namespaces = new XamlNamespaces(String.Empty, "default-namespace");
XamlElement root1 = (XamlElement)MarkupExtensionParser.Parse("{root1 property1={child1 value1, property2=value2}, property3={child3 property4=value4}}", namespaces);
Assert.AreEqual("root1", root1.Name.LocalName);
Assert.AreEqual(2, root1.Members.Count());
Assert.AreEqual("property1", root1.Members.ElementAt(0).Name.LocalName);
Assert.IsTrue(root1.Members.ElementAt(0).Values.Single() is XamlElement);
Assert.AreEqual("child1", (root1.Members.ElementAt(0).Values.Single() as XamlElement).Name.LocalName);
Assert.IsTrue((root1.Members.ElementAt(0).Values.Single() as XamlElement).Members.Count() == 2);
Assert.AreEqual("value1", (root1.Members.ElementAt(0).Values.Single() as XamlElement).Members.ElementAt(0).Values.Single());
Assert.AreEqual("value2", (root1.Members.ElementAt(0).Values.Single() as XamlElement).Members.ElementAt(1).Values.Single());
Assert.IsTrue(root1.Members.ElementAt(1).Values.Single() is XamlElement);
Assert.AreEqual("child3", (root1.Members.ElementAt(1).Values.Single() as XamlElement).Name.LocalName);
Assert.IsTrue((root1.Members.ElementAt(1).Values.Single() as XamlElement).Members.Count() == 1);
Assert.AreEqual("property4", (root1.Members.ElementAt(1).Values.Single() as XamlElement).Members.ElementAt(0).Name.LocalName);
Assert.AreEqual("value4", (root1.Members.ElementAt(1).Values.Single() as XamlElement).Members.ElementAt(0).Values.Single());
}
int BuildCompletionsForMarkupExtension(List <Completion> completions, string data)
{
int?forcedStart = null;
var ext = MarkupExtensionParser.Parse(data);
var transformedName = (ext.ElementName ?? "").Trim();
if (_helper.LookupType(transformedName)?.IsMarkupExtension != true)
{
transformedName += "Extension";
}
if (ext.State == MarkupExtensionParser.ParserStateType.StartElement)
{
completions.AddRange(_helper.FilterTypeNames(ext.ElementName, markupExtensionsOnly: true)
.Select(t => t.EndsWith("Extension") ? t.Substring(0, t.Length - "Extension".Length) : t)
.Select(t => new Completion(t)));
}
if (ext.State == MarkupExtensionParser.ParserStateType.StartAttribute ||
ext.State == MarkupExtensionParser.ParserStateType.InsideElement)
{
if (ext.State == MarkupExtensionParser.ParserStateType.InsideElement)
{
forcedStart = data.Length;
}
completions.AddRange(_helper.FilterPropertyNames(transformedName, ext.AttributeName ?? "")
.Select(x => new Completion(x, x + "=", x, null, null)));
}
if (ext.State == MarkupExtensionParser.ParserStateType.AttributeValue)
{
var prop = _helper.LookupProperty(transformedName, ext.AttributeName);
if (prop?.Type == MetadataPropertyType.Enum && prop.EnumValues != null)
{
completions.AddRange(prop.EnumValues.Select(v => new Completion(v)));
}
}
return(forcedStart ?? ext.CurrentValueStart);
}
static void RunParseTest(string markup, MarkupExtensionInfo expectedResult)
{
MarkupExtensionInfo data = MarkupExtensionParser.Parse(markup);
Assert.AreEqual(expectedResult, data);
}
