public void SegmentTests()
{
var testCases = new []
{
new{
Uri = "/Customers",
ExpectedNodes = new StartPathToken("Customers", null, null)
},
new{
Uri = "/Customers()",
ExpectedNodes = new StartPathToken("Customers", null, new NamedValue[0])
},
new{
Uri = "/Customers/$count",
ExpectedNodes = (StartPathToken) new KeywordSegmentToken(KeywordKind.Count, new StartPathToken("Customers", null, null))
},
new{
Uri = "/$metadata/Foo",
ExpectedNodes = new StartPathToken("Foo", new KeywordSegmentToken(KeywordKind.Metadata, null), null)
},
new{
Uri = "/Customers()/$count",
ExpectedNodes = (StartPathToken) new KeywordSegmentToken(KeywordKind.Count, new StartPathToken("Customers", null, new NamedValue[0]))
},
new{
Uri = "/Customers()/$links/Orders()",
ExpectedNodes = new StartPathToken(
"Orders",
new KeywordSegmentToken(KeywordKind.Links, new StartPathToken("Customers", null, new NamedValue[0])), new NamedValue[0])
},
new{
Uri = "/Customers/$batch",
ExpectedNodes = (StartPathToken) new KeywordSegmentToken(KeywordKind.Batch, new StartPathToken("Customers", null, null))
},
new{
Uri = "/Orders/$value",
ExpectedNodes = (StartPathToken) new KeywordSegmentToken(KeywordKind.Value, new StartPathToken("Orders", null, null))
},
new{
Uri = "/",
ExpectedNodes = new StartPathToken("", null, null)
},
};
this.CombinatorialEngineProvider.RunCombinations(
testCases,
testCase => QueryTokenUtils.VerifyQueryTokensAreEqual(
testCase.ExpectedNodes,
QueryTokenUtils.ParseQuery(testCase.Uri).Path,
this.Assert));
}
public void FilterExpressionTest()
{
CombinatorialEngineProvider.RunCombinations(
ExpressionTestCase.PrimitiveLiteralTestCases()
.Concat(ExpressionTestCase.BinaryOperatorTestCases())
.Concat(ExpressionTestCase.UnaryOperatorTestCases())
.Concat(ExpressionTestCase.PropertyAccessTestCases(ExpressionTestCase.PropertyAccessNames))
.Concat(ExpressionTestCase.ParenthesisTestCases())
.Concat(ExpressionTestCase.FunctionCallTestCases()),
testCase => QueryTokenUtils.VerifyQueryTokensAreEqual(
testCase.ExpectedToken,
QueryTokenUtils.ParseQuery("Root", filter: testCase.Expression).Filter,
this.Assert));
}
public void UriVariationExpressionsTest()
{
IEnumerable <ExpressionTestCase> testCases = new ExpressionTestCase[]
{
// Uri query where + instead of space is in Uri text
new ExpressionTestCase {
Expression = "1+lt+2+and+true+ne+false", ExpectedToken = new BinaryOperatorToken(
BinaryOperatorKind.And,
new BinaryOperatorToken(BinaryOperatorKind.LessThan, new LiteralToken(1), new LiteralToken(2)),
new BinaryOperatorToken(BinaryOperatorKind.NotEqual, new LiteralToken(true), new LiteralToken(false)))
}
};
CombinatorialEngineProvider.RunCombinations(
testCases,
(testCase) =>
{
QueryTokenUtils.VerifyQueryTokensAreEqual(
testCase.ExpectedToken,
QueryTokenUtils.ParseQuery("Root", filter: testCase.Expression).Filter,
this.Assert);
});
}
public void KeyValuesTest()
{
IEnumerable <KeyValuesTestCase> testCases = new[]
{
new KeyValuesTestCase {
KeyValues = "()",
ExpectedKeyValues = new NamedValue[0]
},
new KeyValuesTestCase {
KeyValues = "(0)",
ExpectedKeyValues = new [] { new NamedValue(null, new LiteralToken(0)) }
},
new KeyValuesTestCase {
KeyValues = "(0,1)",
ExpectedKeyValues = new [] {
new NamedValue(null, new LiteralToken(0)),
new NamedValue(null, new LiteralToken(1))
}
},
new KeyValuesTestCase {
KeyValues = "(Key='some')",
ExpectedKeyValues = new [] {
new NamedValue("Key", new LiteralToken("some")),
}
},
new KeyValuesTestCase {
KeyValues = "(Key=datetime'2010-12-09T14:10:20')",
ExpectedKeyValues = new [] {
new NamedValue("Key", new LiteralToken(new DateTime(2010, 12, 9, 14, 10, 20)))
}
},
new KeyValuesTestCase {
KeyValues = "(Key1=42.42, Key2=42f)",
ExpectedKeyValues = new [] {
new NamedValue("Key1", new LiteralToken((double)42.42)),
new NamedValue("Key2", new LiteralToken((Single)42))
}
},
new KeyValuesTestCase {
KeyValues = "(Key=1,Key=2)",
ExpectedKeyValues = new [] {
new NamedValue("Key", new LiteralToken(1)),
new NamedValue("Key", new LiteralToken(2))
}
},
};
testCases.Concat(ExpressionTestCase.PrimitiveLiteralTestCases().Select(tc =>
new KeyValuesTestCase()
{
KeyValues = "(" + tc.Expression + ")",
ExpectedKeyValues = new[] { new NamedValue(null, (LiteralToken)tc.ExpectedToken) }
}));
this.CombinatorialEngineProvider.RunCombinations(
testCases,
testCase => QueryTokenUtils.VerifyQueryTokensAreEqual(
new StartPathToken("Customers", null, testCase.ExpectedKeyValues),
QueryTokenUtils.ParseQuery("/Customers" + testCase.KeyValues).Path,
this.Assert));
}
