private static ParseResult Match_GenericTypeParameter(InputStream input)
{
return(FirstOf(
WithAction(Match_UnqualifiedName, r =>
{
var result = new TypeNameInfo();
InitializeTypeNameInfo((ParsedUnqualifiedName)r.ResultData, result);
return new ParseResult(r.MatchedString, result);
}),
WithAction(Sequence(Match_LeftBracket, Match_TypeName, Match_RightBracket), r => new SequenceResult(r)[1]))
(input));
}
public void SendsHeaders()
{
var port = new AwaitedPort(new TestPort()).Value();
var header = "";
using (var server =
new HttpMock(port,
new FkWire(req =>
{
header = new FirstOf <string>(new Authorization.Of(req)).Value();
return(new Response.Of(200, "OK"));
})
).Value()
)
{
new AspNetCoreWire(
new AspNetCoreClients(),
new TimeSpan(0, 1, 0)
).Response(
new Get(
new Scheme("http"),
new Host("localhost"),
new Port(server.Port),
new Header("Authorization", "Basic dXNlcjpwYXNzd29yZA==")
)
).Wait(30000);
}
Assert.Equal(
"Basic dXNlcjpwYXNzd29yZA==",
header
);
}
public void AddsRequestParts()
{
var token = "";
new Refined(
new FkWire(req =>
{
token = new FirstOf <string>(new BearerTokenAuth.Of(req)).Value();
return(new Responses.Response.Of(200, "OK"));
}),
new BearerTokenAuth("this is a token")
)
.Response(new Get())
.Wait(30000);
Assert.Equal(
"this is a token",
token
);
}
private static ParseResult Match_Eol(InputStream input)
{
return(FirstOf(Match("\r\n"), Match('\r'), Match('\n'))(input));
}
private static ParseResult Match_Space(InputStream input)
{
return(FirstOf(Match(' '), Match('\t'), Match_Eol)(input));
}
private static ParseResult Match_IdAlphanumeric(InputStream input)
{
return(FirstOf(Match_QuotedChar, Match(ch => char.IsLetterOrDigit(ch)))(input));
}
private static ParseResult Match_IdContinuation(InputStream input)
{
return(FirstOf(Match_IdNonAlpha, Match_IdAlphanumeric)(input));
}
private static ParseResult Match_IdStart(InputStream input)
{
return(FirstOf(Match_IdNonAlpha, Match_IdAlpha)(input));
}
private static ParseResult Match_AssemblyNameChar(InputStream input)
{
return(FirstOf(Match_QuotedChar, Match(ch => !"^/\\:?\"<>|,[]".Contains(ch)))(input));
}
private static ParseResult Match_AssemblyNamePart(InputStream input)
{
return(FirstOf(Match_Culture, Match_Version, Match_PublicKey, Match_PublicKeyToken)(input));
}
private static ParseResult Match_OpenGeneric(InputStream input)
{
return(FirstOf(Match_CLRSyntax, Match_EmptyBrackets)(input));
}
private static ParseResult Match_GenericParameters(InputStream input)
{
return(FirstOf(Match_ClosedGeneric, Match_OpenGeneric)(input));
}
public void TestCalc2(bool useArray) {
if(useArray) LispPrinter.PrintVectorsAsLists = true;//required to compare the result
IVectorFactory factory = useArray ? (IVectorFactory)new ArrayVectorFactory() : (IVectorFactory)new BNodeVectorFactory();
/*
E ← T ((‘+’ / ‘-’) T)*
T ← F (('*' / '/') F)*
F ← N / '(' E ')'
N ← [0-9]+
*/
Rule eDigit = new LiteralAnyCharOf("0123456789");
Placeholder eNumber = new Placeholder();
eNumber.Expression = new FirstOf(new CollapseToString(new Sequence(eDigit, eNumber)), new CallbackHandler(eDigit, Convert.ToString));
Placeholder eAdditive = new Placeholder();
Placeholder eMultiplicative = new Placeholder();
Rule eSingular = new FirstOf(eNumber, new ExtractOne(1, new Sequence(new Literal('('), eAdditive, new Literal(')'))));
//
var BinaryInfixToPrefix = new Function(delegate(object v) {
IVector a = (IVector)v;
IVector tail = (IVector)a[1];
object x = a[0];
while (tail != factory.Empty) {
x = factory.Create(tail[0], x, tail[1]);
tail = (IVector)tail[2];
}
return x;
});
Placeholder eAdditiveSuffix = new Placeholder();
eAdditiveSuffix.Expression = new FirstOf(
new Sequence(new LiteralAnyCharOf("+-"), eMultiplicative, eAdditiveSuffix),
new EmptyRule(factory.Empty));
eAdditive.Expression = new CallbackHandler(new Sequence(eMultiplicative, eAdditiveSuffix), BinaryInfixToPrefix);
Placeholder eMultiplicativeSuffix = new Placeholder();
eMultiplicativeSuffix.Expression = new FirstOf(
new Sequence(new LiteralAnyCharOf("*/"), eSingular, eMultiplicativeSuffix),
new EmptyRule(factory.Empty));
eMultiplicative.Expression = new CallbackHandler(new Sequence(eSingular, eMultiplicativeSuffix), BinaryInfixToPrefix);
Rule expr = eAdditive;
{
var parser = new Parser(expr, TextCursor.Create("12+3*45+6+789*(6+2)*9+0"), factory);
Result r = parser.Run();
string expected = "(+ (+ (+ (+ 12 (* 3 45)) 6) (* (* 789 (+ 6 2)) 9)) 0)";
Assert.IsNotNull(r);
Assert.IsFalse(r.Cursor.CanPop());
Assert.AreEqual(expected, Convert.ToString(r.Value).Replace("\"", "").Replace("'", ""));
object num = new CalculatorVisitor().Process(r.Value);
Assert.AreEqual(Convert.ToDouble(12 + 3 * 45 + 6 + 789 * (6 + 2) * 9 + 0), num);
}
{
var parser = new Parser(expr, TextCursor.Create("12+3*4a5+6+7*(6+2)*9+0"), factory);
Result r = parser.Run();
//Assert.IsNull(r);
Assert.IsTrue(r.Cursor.CanPop());
if (System.Diagnostics.Debugger.IsAttached) {
System.Diagnostics.Debug.WriteLine(parser.GetError());
}
Assert.AreEqual(6, parser.FailCursor.Position);
}
{
var parser = new Parser(expr, TextCursor.Create("12+3*45+(6+7*(6+2)*9+0"), factory);
Result r = parser.Run();
//Assert.IsNull(r);
Assert.IsTrue(r.Cursor.CanPop());
if (System.Diagnostics.Debugger.IsAttached) {
System.Diagnostics.Debug.WriteLine(parser.GetError());
}
Assert.AreEqual(22, parser.FailCursor.Position);
}
{
var parser = new Parser(expr, TextCursor.Create("(12+3*45+(6+7*(6+2)*9+0)"), factory);
Result r = parser.Run();
Assert.IsNull(r);
//Assert.AreNotEqual(TextCursor.EOI, r.Cursor.Peek());
if (System.Diagnostics.Debugger.IsAttached) {
System.Diagnostics.Debug.WriteLine(parser.GetError());
}
Assert.AreEqual(24, parser.FailCursor.Position);
}
}
public void TestCalc1(bool useArray) {
if (useArray) LispPrinter.PrintVectorsAsLists = true;//required to compare the results
IVectorFactory factory = useArray? (IVectorFactory)new ArrayVectorFactory() : (IVectorFactory)new BNodeVectorFactory();
/*
Expression ← Term ((‘+’ / ‘-’) Term)*
Term ← Factor (('*' / '/') Factor)*
Factor ← Number / '(' Expression ')'
Number ← [0-9]+
*/
Rule eDigit = new LiteralAnyCharOf("0123456789");
Placeholder eNumber = new Placeholder();
//eNumber.Expression = new First(new CallbackHandler( new Sequence(eDigit, eNumber), delegate(object v){
// object[] a = (object[])v;
// return string.Concat(a[0], a[1]);
//}), eDigit);
eNumber.Expression = new FirstOf(new CollapseToString(new Sequence(eDigit, eNumber)), new CallbackHandler(eDigit, Convert.ToString));
//eNumber.Expression = new CallbackHandler(
// new First(new CollapseToString(new Sequence(eDigit, eNumber)), new CallbackHandler(eDigit, Convert.ToString)),
// delegate(object v) { return Int64.Parse((string)v); });
//eNumber.Expression = new CollapseToArray(new First(new Sequence(eDigit, eNumber), new Sequence(eDigit, new TailStub())));
Placeholder eAdditive = new Placeholder();
Placeholder eMultiplicative = new Placeholder();
Rule eSingular = new FirstOf(eNumber,
new ExtractOne(1, new Sequence(new Literal('('), eAdditive, new Literal(')'))));
//
Placeholder eAdditiveSuffix = new Placeholder();
eAdditiveSuffix.Expression = new FirstOf(
new CallbackHandler(new Sequence(new LiteralAnyCharOf("+-"), eMultiplicative, eAdditiveSuffix), delegate(object v) {
IVector a = (IVector)v;
IVector tail = (IVector)a[2];
return factory.InsertBefore(a[0], factory.InsertBefore(a[1], tail));
//return v;
//return ((object[])v)[1];
}),
//new EmptyExpression(null));
new EmptyRule(factory.Empty));
//eAdditive.Expression = new CallbackHandler( new Sequence(eMultiplicative, eAdditiveSuffix), DoAdd);
eAdditive.Expression = new CallbackHandler(new Sequence(eMultiplicative, eAdditiveSuffix), delegate(object v) {
IVector a = (IVector)v;
IVector tail = (IVector)a[1];
return factory.InsertBefore(a[0], tail);
});
Placeholder eMultiplicativeSuffix = new Placeholder();
eMultiplicativeSuffix.Expression = new FirstOf(
new CallbackHandler(new Sequence(new LiteralAnyCharOf("*/"), eSingular, eMultiplicativeSuffix), delegate(object v) {
IVector a = (IVector)v;
IVector tail = (IVector)a[2];
return factory.InsertBefore(a[0], factory.InsertBefore(a[1], tail));
//return v;
//return ((object[])v)[1];
}),
//new EmptyExpression(null));
new EmptyRule(factory.Empty));
//eMultiplicative.Expression = new CallbackHandler(new Sequence(eSingular, eMultiplicativeSuffix), DoMultiply);
eMultiplicative.Expression = new CallbackHandler(new Sequence(eSingular, eMultiplicativeSuffix), delegate(object v) {
IVector a = (IVector)v;
IVector tail = (IVector)a[1];
if (tail == factory.Empty) return a[0];
return factory.InsertBefore(a[0], tail);
});
Rule expr = eAdditive;
{
var parser = new Parser(expr, TextCursor.Create("12+3*45+6+789*(6+2)*9+0"), factory);
Result r = parser.Run();
//string expected = "(+ 12 (* 3 45) 6 (* 7 8 9) 0)";
string expected = "(12 + (3 * 45) + 6 + (789 * (6 + 2) * 9) + 0)";
Assert.IsNotNull(r);
Assert.IsFalse(r.Cursor.CanPop());
Assert.AreEqual(expected, Convert.ToString(r.Value).Replace("\"", "").Replace("'", ""));
}
{
var parser = new Parser(expr, TextCursor.Create("120+34*((5*6+7)*8+9)-1"), factory);
Result r = parser.Run();
Assert.IsNotNull(r);
Assert.IsFalse(r.Cursor.CanPop());
//Assert.AreEqual(120 + 34 * ((5 * 6 + 7) * 8 + 9) - 1, r.Value);
}
}
public void TestComposition() {
{
var q = new FirstOf(
new Sequence(new LiteralAnyCharOf("a"), new LiteralAnyCharOf("+-"), new LiteralAnyCharOf("z")),
new Sequence(new LiteralAnyCharOf("a"), new LiteralAnyCharOf("z")),
new LiteralAnyCharOf("?")
);
{
var parser = new Parser(q, TextCursor.Create(""));
var r = parser.Run();
Assert.IsNull(r);
Assert.IsNotNull(parser.FailCursor);
Assert.AreEqual(0, parser.FailCursor.Position);
}
{
var parser = new Parser(q, TextCursor.Create("a+z"));
var r = parser.Run();
Assert.IsNotNull(r);
Assert.AreEqual(3, r.Cursor.Position);
var v = r.Value as IVector;
Assert.IsTrue(r.Value is IVector);
Assert.AreEqual(3, v.Length);
Assert.AreEqual('a', v[0]);
Assert.AreEqual('+', v[1]);
Assert.AreEqual('z', v[2]);
}
{
var parser = new Parser(q, TextCursor.Create("az"));
var r = parser.Run();
Assert.IsNotNull(r);
Assert.AreEqual(2, r.Cursor.Position);
var v = r.Value as IVector;
Assert.IsTrue(r.Value is IVector);
Assert.AreEqual(2, v.Length);
Assert.AreEqual('a', v[0]);
Assert.AreEqual('z', v[1]);
}
{
var parser = new Parser(q, TextCursor.Create("?"));
var r = parser.Run();
Assert.IsNotNull(r);
Assert.AreEqual(1, r.Cursor.Position);
Assert.AreEqual('?', r.Value);
}
{
var parser = new Parser(q, TextCursor.Create("a?"));
var r = parser.Run();
Assert.IsNull(r);
Assert.IsNotNull(parser.FailCursor);
Assert.AreEqual(1, parser.FailCursor.Position);
}
}
}
public void TestFirstOf() {
{
var q = new FirstOf(new LiteralAnyCharOf("a"), new LiteralAnyCharOf("+-"), new LiteralAnyCharOf("z"));
{
var parser = new Parser(q, TextCursor.Create(""));
var r = parser.Run();
Assert.IsNull(r);
Assert.IsNotNull(parser.FailCursor);
Assert.AreEqual(0, parser.FailCursor.Position);
}
{
var parser = new Parser(q, TextCursor.Create("+"));
var r = parser.Run();
Assert.IsNotNull(r);
Assert.AreEqual(1, r.Cursor.Position);
Assert.AreEqual('+', r.Value);
}
{
var parser = new Parser(q, TextCursor.Create("z"));
var r = parser.Run();
Assert.IsNotNull(r);
Assert.AreEqual(1, r.Cursor.Position);
Assert.AreEqual('z', r.Value);
}
}
}
