public void Interpret_GivenValidRuleDefinition_ReturnsCorrectResult()
{
var lexer = new DefaultLexer();
const string queryText = "ensure holding.Nav is within 10 of fund.Nav";
var tokens = lexer.Lex(queryText).ToList();
var parser = new DefaultParser();
var ruleDefinition = parser.Parse(tokens);
var sut = new DefaultInterpreter();
var ruleFunc = sut.Interpret <Holding, Fund>(ruleDefinition);
var holding = new Holding
{
Nav = 5
};
var fund = new Fund
{
Nav = 6
};
var actual = ruleFunc(holding, fund);
Assert.That(actual, Is.True);
}
public void Parse_GivenValidTokens_ReturnsCorrectResult()
{
var lexer = new DefaultLexer();
const string queryText = "ensure holding.Nav is within 10 of fund.Nav";
var tokens = lexer.Lex(queryText).ToList();
var sut = new DefaultParser();
var expected = new RuleDefinition
{
Id = null,
RuleConditions = new List <RuleCondition>
{
new RuleCondition
{
ComparisonType = RuleObject.ObjectProperty,
ComparisonAttribute = "Nav",
ComparisonTypeName = "fund",
LogicalOperator = RuleLogicalOperator.None,
Operator = RuleComparatorOperator.Within,
Value = "10"
}
},
TargetAttribute = "Nav",
TargetType = RuleObject.ObjectProperty,
TargetTypeName = "holding"
};
var actual = sut.Parse(tokens);
Assert.That(actual, Is.EqualTo(expected));
}
public void Parse_GivenTargetObjectPropertyOfMethod_ReturnsCorrectResult()
{
var lexer = new DefaultLexer();
const string queryText = "ensure target.SomeMethod() is within 10 of comparison.SomeProperty";
var tokens = lexer.Lex(queryText).ToList();
var sut = new DefaultParser();
var expected = new RuleDefinition
{
Id = null,
RuleConditions = new List <RuleCondition>
{
new RuleCondition
{
ComparisonType = RuleObject.ObjectProperty,
ComparisonAttribute = "SomeProperty",
ComparisonTypeName = "comparison",
LogicalOperator = RuleLogicalOperator.None,
Operator = RuleComparatorOperator.Within,
Value = "10"
}
},
TargetAttribute = "SomeMethod",
TargetType = RuleObject.ObjectMethod,
TargetTypeName = "target"
};
var actual = sut.Parse(tokens);
Assert.That(actual, Is.EqualTo(expected));
}
static void Main(string[] args)
{
// create Options object
Options options = new Options();
// add t option
options.AddOption("t", false, "display current time");
options.AddOption("h", false, "Display help options");
CommandLineParser parser = new DefaultParser();
CommandLine cmd = parser.Parse(options, args);
options.AddOption("h", "help", false, "Print this usage information");
options.AddOption("v", "verbose", false, "Print out VERBOSE information");
OptionGroup optionGroup = new OptionGroup();
optionGroup.AddOption(new OptionBuilder("f").HasArg(true).ArgName("filename").Build());
optionGroup.AddOption(new OptionBuilder("m").HasArg(true).ArgName("email").Build());
options.AddOptionGroup(optionGroup);
if (cmd.HasOption("h"))
{
HelpFormatter formatter = new HelpFormatter();
formatter.printHelp("x", options, true);
return;
}
if (cmd.HasOption("t"))
{
Console.WriteLine(System.DateTime.Now);
}
}
protected string Run(string input)
{
ExpTree tree;
ParserStatus result = DefaultParser.Parse(input, out tree);
Assert.IsFalse(result.Failed);
return(tree.Root.Execute(_simplifier).Print(_printer));
}
public void TestSimpleValidQuote()
{
var p = new DefaultParser();
var args = p.Parse("\"123\"");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
}
public void TestMultipleInvalidQuotes()
{
var p = new DefaultParser();
var args = p.Parse("\"123\" \"456");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
}
public void TestSimpleArgument()
{
var p = new DefaultParser();
var args = p.Parse("123");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
}
public void TestWhitespaces()
{
var p = new DefaultParser();
var args = p.Parse(" 123");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse(" 123");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse("123 ");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse("123 ");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse(" 123 ");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse("\n123 ");
Assert.AreEqual(1, args.Length);
Assert.AreEqual("123", args[0]);
args = p.Parse(" 123 456 789");
Assert.AreEqual(3, args.Length);
Assert.AreEqual("123", args[0]);
Assert.AreEqual("456", args[1]);
Assert.AreEqual("789", args[2]);
}
public void TestMultipleSimpleArguments()
{
var p = new DefaultParser();
var args = p.Parse("123 456 789");
Assert.AreEqual(3, args.Length);
Assert.AreEqual("123", args[0]);
Assert.AreEqual("456", args[1]);
Assert.AreEqual("789", args[2]);
}
public static AbacAuthorizationPolicy CreateFromGrammar(string policy, WellKnownGrammars grammar = WellKnownGrammars.Bal)
{
try
{
return(DefaultParser.Parse(policy, grammar));
}
catch (Exception exception)
{
throw new InvalidOperationException($"Policy can't be parsed using the grammar {Enum.GetName(typeof(WellKnownGrammars), grammar)} and policy is not created succcesfully.", exception);
}
}
public void ThrowOnBadInput()
{
var targetType = typeof(float);
var parser = new DefaultParser(targetType);
var input = "abc";
var ex = Assert.Throws <ParsingException>(() => parser.Parse(input));
Assert.That(ex.Input, Is.EqualTo(input));
Assert.That(ex.TargetType, Is.EqualTo(targetType));
}
public void TestSimpleArgumentUsingQuoteChar()
{
var p = new DefaultParser();
p.QuoteChar = '`';
var args = p.Parse("`123 456` 789 `123456`");
Assert.AreEqual(3, args.Length);
Assert.AreEqual("123 456", args[0]);
Assert.AreEqual("789", args[1]);
Assert.AreEqual("123456", args[2]);
}
public static void Main(string[] args)
{
try
{
System.Console.Out.WriteLine("khubla.com Paradox DB reader");
/*
* options
*/
Options options = new Options();
Option oo = Option.Builder().ArgName(FileOption).LongOpt(FileOption).Type(Sharpen.Runtime.GetClassForType
(typeof(string))).HasArg().Required(true).Desc("file to read").Build();
options.AddOption(oo);
/*
* parse
*/
CommandLineParser parser = new DefaultParser();
CommandLine cmd = null;
try
{
cmd = parser.Parse(options, args);
}
catch (Exception e)
{
Sharpen.Runtime.PrintStackTrace(e);
HelpFormatter formatter = new HelpFormatter();
formatter.PrintHelp("posix", options);
System.Environment.Exit(0);
}
/*
* get file
*/
string filename = cmd.GetOptionValue(FileOption);
if (null != filename)
{
File inputFile = new File(filename);
if (inputFile.Exists())
{
DBTableFile pdxFile = new DBTableFile();
PDXReaderListener pdxReaderListener = new PDXReaderCSVListenerImpl();
pdxFile.Read(inputFile, pdxReaderListener);
System.Console.Out.WriteLine("done");
}
}
}
catch (Exception e)
{
Sharpen.Runtime.PrintStackTrace(e);
}
}
private static void DefaultParserDemo()
{
var p = new DefaultParser();
PrintRes(p.Parse(" 123"));
PrintRes(p.Parse("123"));
PrintRes(p.Parse("123 456"));
PrintRes(p.Parse("\"123\""));
PrintRes(p.Parse("\"123\" \"456\""));
PrintRes(p.Parse("\"123\" \"456\" \"789"));
}
/// <summary>
/// Convert YAML text <paramref name="yaml"/> to a list of <see cref="YamlNode"/>.
/// </summary>
/// <param name="yaml">YAML text</param>
/// <returns>YAML nodes</returns>
/// <param name="config"><see cref="YamlConfig">YAML configuration</see> to customize serialization.</param>
public static YamlNode[] FromYaml(string yaml, YamlConfig config)
{
return(DefaultParser.Parse(yaml, config).ToArray());
}
public void ParseNegativeDecimal()
{
var parser = new DefaultParser(typeof(decimal));
Assert.AreEqual(parser.Parse("-1.2"), -1.2m);
}
/// <summary>
/// Convert YAML text <paramref name="yaml"/> to a list of <see cref="YamlNode"/>.
/// </summary>
/// <param name="yaml">YAML text</param>
/// <returns>YAML nodes</returns>
public static YamlNode[] FromYaml(string yaml)
{
return(DefaultParser.Parse(yaml).ToArray());
}
public void ParseString()
{
var parser = new DefaultParser(typeof(string));
Assert.AreEqual(parser.Parse("teststring"), "teststring");
}
public void ParseNegativeFloat()
{
var parser = new DefaultParser(typeof(float));
Assert.AreEqual(parser.Parse("-3.5"), -3.5F);
}
public void Parse_should_yield_results()
{
DISetup.SetupContainer();
var sb = new StringBuilder();
sb.AppendLine(@"@test = 1");
sb.AppendLine(@"");
sb.AppendLine(@"asl_mode_options_1 = {");
sb.AppendLine(@" potential = {");
sb.AppendLine(@" NOT = {");
sb.AppendLine(@" has_country_flag = asl_modify_3");
sb.AppendLine(@" has_country_flag = asl_modify_5");
sb.AppendLine(@" }");
sb.AppendLine(@" }");
sb.AppendLine(@" allow = {");
sb.AppendLine(@" always = yes");
sb.AppendLine(@" }");
sb.AppendLine(@" effect = {");
sb.AppendLine(@" }");
sb.AppendLine(@"}");
sb.AppendLine(@"");
sb.AppendLine(@"asl_mode_options_3 = {");
sb.AppendLine(@" potential = {");
sb.AppendLine(@" has_country_flag = asl_modify_3");
sb.AppendLine(@" }");
sb.AppendLine(@" allow = {");
sb.AppendLine(@" always = yes");
sb.AppendLine(@" }");
sb.AppendLine(@" effect = {");
sb.AppendLine(@" }");
sb.AppendLine(@"}");
sb.AppendLine(@"");
sb.AppendLine(@"asl_mode_options_5 = {");
sb.AppendLine(@" potential = {");
sb.AppendLine(@" has_country_flag = asl_modify_5");
sb.AppendLine(@" }");
sb.AppendLine(@" allow = {");
sb.AppendLine(@" always = yes");
sb.AppendLine(@" }");
sb.AppendLine(@" effect = {");
sb.AppendLine(@" }");
sb.AppendLine(@"}");
sb.AppendLine(@"");
sb.AppendLine(@"### END TEMPLATE:effects ###");
var sb2 = new StringBuilder();
sb2.AppendLine(@"asl_mode_options_1 = {");
sb2.AppendLine(@" potential = {");
sb2.AppendLine(@" NOT = {");
sb2.AppendLine(@" has_country_flag = asl_modify_3");
sb2.AppendLine(@" has_country_flag = asl_modify_5");
sb2.AppendLine(@" }");
sb2.AppendLine(@" }");
sb2.AppendLine(@" allow = {");
sb2.AppendLine(@" always = yes");
sb2.AppendLine(@" }");
sb2.AppendLine(@" effect = {");
sb2.AppendLine(@" }");
sb2.AppendLine(@"}");
var args = new ParserArgs()
{
ContentSHA = "sha",
ModDependencies = new List <string> {
"1"
},
File = "common\\fake\\fake.txt",
Lines = sb.ToString().Split(Environment.NewLine.ToCharArray(), StringSplitOptions.RemoveEmptyEntries),
ModName = "fake"
};
var parser = new DefaultParser(new CodeParser(new Logger()), null);
var result = parser.Parse(args).ToList();
result.Should().NotBeNullOrEmpty();
result.Count().Should().Be(4);
for (int i = 0; i < 4; i++)
{
result[i].ContentSHA.Should().Be("sha");
result[i].Dependencies.First().Should().Be("1");
result[i].File.Should().Be("common\\fake\\fake.txt");
switch (i)
{
case 0:
result[i].Code.Trim().Should().Be("@test = 1");
result[i].Id.Should().Be("@test");
result[i].ValueType.Should().Be(ValueType.Variable);
break;
case 1:
result[i].Id.Should().Be("asl_mode_options_1");
result[i].Code.Should().Be(sb2.ToString().Trim().ReplaceTabs());
result[i].ValueType.Should().Be(ValueType.Object);
break;
case 2:
result[i].Id.Should().Be("asl_mode_options_3");
result[i].ValueType.Should().Be(ValueType.Object);
break;
case 3:
result[i].Id.Should().Be("asl_mode_options_5");
result[i].ValueType.Should().Be(ValueType.Object);
break;
default:
break;
}
result[i].ModName.Should().Be("fake");
result[i].Type.Should().Be("common\\fake\\txt");
}
}
public void OpenPath1()
{
//il : del percorso è in conflitto con la sintassi dei nomi dei parametri
string args = @"--open C:\";
var res = _textParser.Parse(args);
Assert.IsTrue((res.First().Param as SimpleParam).Value == @"C:\");
}
public void ParseNegativeInt()
{
var parser = new DefaultParser(typeof(int));
Assert.AreEqual(parser.Parse("-10"), -10);
}