public void FilterWithFloat()
{
JsonDocumentPath path = new JsonDocumentPath("[?(@.name>=12.1)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.Equal(12.1d, ((JsonElement)expressions.Right).GetDouble());
}
public void FilterWithInteger()
{
JsonDocumentPath path = new JsonDocumentPath("[?(@.name>=12)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.Equal(12, ((JsonElement)expressions.Right).GetInt32());
}
public void FilterWithFloatExp()
{
JPath path = new JPath("[?(@.name>=5.56789e+0)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(5.56789e+0, (double)expressions.Value);
}
public void FilterWithLessThanOrEquals()
{
JsonDocumentPath path = new JsonDocumentPath("[?(@.name<=null)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.Equal(QueryOperator.LessThanOrEquals, expressions.Operator);
}
public void FilterWithNegativeInteger()
{
var path = new JPath("[?(@.name>=-12)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(-12, ((JsonElement)expressions.Right !).GetInt32());
}
public void FilterWithNotEquals2()
{
var path = new JPath("[?(@.name!=null)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(QueryOperator.NotEquals, expressions.Operator);
}
public void FilterWithNegativeInteger()
{
JPath path = new JPath("[?(@.name>=-12)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(-12, (int)expressions.Value);
}
public void FilterWithLessThan()
{
JPath path = new JPath("[?(@.name<null)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(QueryOperator.LessThan, expressions.Operator);
}
public void BooleanExpressionTest_RegexEqualsOperator()
{
BooleanQueryExpression e1 = new BooleanQueryExpression(QueryOperator.RegexEquals,
new List <PathFilter> {
new ArrayIndexFilter()
},
JsonDocument.Parse("\"/foo.*d/\"").RootElement);
var nullElt = JsonDocument.Parse("null").RootElement;
Assert.IsTrue(e1.IsMatch(nullElt, JsonDocument.Parse("[\"food\"]").RootElement));
Assert.IsTrue(e1.IsMatch(nullElt, JsonDocument.Parse("[\"fooood and drink\"]").RootElement));
Assert.IsFalse(e1.IsMatch(nullElt, JsonDocument.Parse("[\"FOOD\"]").RootElement));
Assert.IsFalse(e1.IsMatch(nullElt, JsonDocument.Parse("[\"foo\", \"foog\", \"good\"]").RootElement));
BooleanQueryExpression e2 = new BooleanQueryExpression(QueryOperator.RegexEquals,
new List <PathFilter> {
new ArrayIndexFilter()
}, JsonDocument.Parse("\"/Foo.*d/i\"").RootElement);
Assert.IsTrue(e2.IsMatch(nullElt, JsonDocument.Parse("[\"food\"]").RootElement));
Assert.IsTrue(e2.IsMatch(nullElt, JsonDocument.Parse("[\"fooood and drink\"]").RootElement));
Assert.IsTrue(e2.IsMatch(nullElt, JsonDocument.Parse("[\"FOOD\"]").RootElement));
Assert.IsFalse(e2.IsMatch(nullElt, JsonDocument.Parse("[\"foo\", \"foog\", \"good\"]").RootElement));
}
public void FilterWithFloat()
{
JPath path = new JPath("[?(@.name>=12.1)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(12.1d, (double)(JToken)expressions.Right);
}
public void BooleanExpressionTest()
{
BooleanQueryExpression e1 = new BooleanQueryExpression
{
Operator = QueryOperator.LessThan,
Value = new JValue(3),
Path = new List <PathFilter>
{
new ArrayIndexFilter()
}
};
Assert.IsTrue(e1.IsMatch(null, new JArray(1, 2, 3, 4, 5)));
Assert.IsTrue(e1.IsMatch(null, new JArray(2, 3, 4, 5)));
Assert.IsFalse(e1.IsMatch(null, new JArray(3, 4, 5)));
Assert.IsFalse(e1.IsMatch(null, new JArray(4, 5)));
BooleanQueryExpression e2 = new BooleanQueryExpression
{
Operator = QueryOperator.LessThanOrEquals,
Value = new JValue(3),
Path = new List <PathFilter>
{
new ArrayIndexFilter()
}
};
Assert.IsTrue(e2.IsMatch(null, new JArray(1, 2, 3, 4, 5)));
Assert.IsTrue(e2.IsMatch(null, new JArray(2, 3, 4, 5)));
Assert.IsTrue(e2.IsMatch(null, new JArray(3, 4, 5)));
Assert.IsFalse(e2.IsMatch(null, new JArray(4, 5)));
}
public void FilterWithGreaterThan()
{
JsonDocumentPath path = new JsonDocumentPath("[?(@.name>null)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.Equal(QueryOperator.GreaterThan, expressions.Operator);
}
public void FilterWithFloatExp()
{
var path = new JPath("[?(@.name>=5.56789e+0)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(5.56789e+0, ((JsonElement)expressions.Right !).GetDouble());
}
public void FilterWithGreaterThanOrEquals()
{
JPath path = new JPath("[?(@.name>=null)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(QueryOperator.GreaterThanOrEquals, expressions.Operator);
}
public void AllStrictEqualityTests()
{
// this is a bit cargo-culty; making absolutely sure no false positives caused by instance equivalence
var lhs = new TestData();
var rhs = new TestData();
// For all tests, if Type(x) is different from Type(y), return false.
// given x === y, if Type(x) is Null, return true
var target = lhs.Null;
AssertAll(StrictEquality, target, rhs.Null);
AssertNone(StrictEquality, target, rhs.ErrybodyButNull);
// given x === y, if x is the same Number value as y, return true.
target = lhs.One;
AssertAll(StrictEquality, target, rhs.One, rhs.OneDotZero);
Assert.IsFalse(BooleanQueryExpression.EqualsWithStrictMatch(target, rhs.Two));
target = lhs.Scientific;
Assert.IsTrue(BooleanQueryExpression.EqualsWithStrictMatch(target, rhs.Scientific));
// given x === y, if Type(x) is String, then return true if x and y are exactly the same sequence of characters (same length and same characters in corresponding positions); otherwise, return false.
target = lhs.DerpString;
AssertNone(StrictEquality, target, rhs.HerpString);
AssertAll(StrictEquality, target, rhs.DerpString);
// given x === y, if Type(x) is Boolean, return true if x and y are both true or both false; otherwise, return false.
target = lhs.True;
AssertAll(StrictEquality, target, rhs.True);
AssertNone(
StrictEquality,
target,
new[] { rhs.False },
rhs.Nopes,
rhs.Numbers,
rhs.Strings,
rhs.Dates
);
target = lhs.False;
AssertAll(StrictEquality, target, rhs.False);
AssertNone(
StrictEquality,
target,
new[] { rhs.True },
rhs.Nopes,
rhs.Numbers,
rhs.Strings,
rhs.Dates
);
//Dates
target = lhs.DateYearMonth;
AssertAll(StrictEquality, target, rhs.DateYearMonth);
AssertNone(StrictEquality, target, rhs.DateYear);
target = lhs.DateYear;
AssertNone(StrictEquality, target, rhs.DateYearMonth);
AssertAll(StrictEquality, target, rhs.DateYear);
target = lhs.DateISO;
Assert.IsTrue(BooleanQueryExpression.EqualsWithStrictMatch(target, rhs.DateISO));
Assert.IsFalse(BooleanQueryExpression.EqualsWithStrictMatch(target, rhs.OtherISODate));
}
public void FilterWithScan()
{
JPath path = new JPath("[?(@..name<>null)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual("name", ((ScanFilter)expressions.Path[0]).Name);
}
public void BooleanExpressionTest_RegexEqualsOperator()
{
BooleanQueryExpression e1 = new BooleanQueryExpression(
QueryOperator.RegexEquals,
new List <PathFilter> {
new ArrayIndexFilter()
},
new JValue("/foo.*d/")
);
Assert.IsTrue(e1.IsMatch(null, new JArray("food")));
Assert.IsTrue(e1.IsMatch(null, new JArray("fooood and drink")));
Assert.IsFalse(e1.IsMatch(null, new JArray("FOOD")));
Assert.IsFalse(e1.IsMatch(null, new JArray("foo", "foog", "good")));
BooleanQueryExpression e2 = new BooleanQueryExpression(
QueryOperator.RegexEquals,
new List <PathFilter> {
new ArrayIndexFilter()
},
new JValue("/Foo.*d/i")
);
Assert.IsTrue(e2.IsMatch(null, new JArray("food")));
Assert.IsTrue(e2.IsMatch(null, new JArray("fooood and drink")));
Assert.IsTrue(e2.IsMatch(null, new JArray("FOOD")));
Assert.IsFalse(e2.IsMatch(null, new JArray("foo", "foog", "good")));
}
public void BooleanExpressionTest_RegexEqualsOperator_CornerCase()
{
BooleanQueryExpression e1 = new BooleanQueryExpression
{
Operator = QueryOperator.RegexEquals,
Right = new JValue("/// comment/"),
Left = new List <PathFilter>
{
new ArrayIndexFilter()
}
};
Assert.IsTrue(e1.IsMatch(null, new JArray("// comment")));
Assert.IsFalse(e1.IsMatch(null, new JArray("//comment", "/ comment")));
BooleanQueryExpression e2 = new BooleanQueryExpression
{
Operator = QueryOperator.RegexEquals,
Right = new JValue("/<tag>.*</tag>/i"),
Left = new List <PathFilter>
{
new ArrayIndexFilter()
}
};
Assert.IsTrue(e2.IsMatch(null, new JArray("<Tag>Test</Tag>", "")));
Assert.IsFalse(e2.IsMatch(null, new JArray("<tag>Test<tag>")));
}
public void BooleanExpressionTest()
{
BooleanQueryExpression e1 = new BooleanQueryExpression(QueryOperator.LessThan,
new List <PathFilter> {
new ArrayIndexFilter()
}, JsonDocument.Parse("3").RootElement);
var nullElt = JsonDocument.Parse("null").RootElement;
Assert.IsTrue(e1.IsMatch(nullElt, JsonDocument.Parse("[1, 2, 3, 4, 5]").RootElement));
Assert.IsTrue(e1.IsMatch(nullElt, JsonDocument.Parse("[2, 3, 4, 5]").RootElement));
Assert.IsFalse(e1.IsMatch(nullElt, JsonDocument.Parse("[3, 4, 5]").RootElement));
Assert.IsFalse(e1.IsMatch(nullElt, JsonDocument.Parse("[4, 5]").RootElement));
Assert.IsFalse(e1.IsMatch(nullElt, JsonDocument.Parse("[\"11\", 5]").RootElement));
BooleanQueryExpression e2 = new BooleanQueryExpression(QueryOperator.LessThanOrEquals,
new List <PathFilter> {
new ArrayIndexFilter()
}, JsonDocument.Parse("3").RootElement);
Assert.IsTrue(e2.IsMatch(nullElt, JsonDocument.Parse("[1, 2, 3, 4, 5]").RootElement));
Assert.IsTrue(e2.IsMatch(nullElt, JsonDocument.Parse("[2, 3, 4, 5]").RootElement));
Assert.IsTrue(e2.IsMatch(nullElt, JsonDocument.Parse("[3, 4, 5]").RootElement));
Assert.IsFalse(e2.IsMatch(nullElt, JsonDocument.Parse("[4, 5]").RootElement));
Assert.IsFalse(e2.IsMatch(nullElt, JsonDocument.Parse("[\"11\", 5]").RootElement));
}
public void FilterWithInteger()
{
JPath path = new JPath("[?(@.name>=12)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(12, (int)(JToken)expressions.Right);
}
public void FilterWithScan()
{
var path = new JPath("[?(@..name<>null)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
List <PathFilter> paths = (List <PathFilter>)expressions.Left;
Assert.AreEqual("name", ((ScanFilter)paths[0]).Name);
}
public void FilterWithRoot()
{
JPath path = new JPath("[?($.name>=12.1)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(2, expressions.Path.Count);
Assert.IsInstanceOf(typeof(RootFilter), expressions.Path[0]);
Assert.IsInstanceOf(typeof(FieldFilter), expressions.Path[1]);
}
public void FilterWithRoot()
{
JsonDocumentPath path = new JsonDocumentPath("[?($.name>=12.1)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
List <PathFilter> paths = (List <PathFilter>)expressions.Left;
Assert.Equal(2, paths.Count);
Assert.IsType(typeof(RootFilter), paths[0]);
Assert.IsType(typeof(FieldFilter), paths[1]);
}
public void FilterWithRoot()
{
var path = new JPath("[?($.name>=12.1)]");
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
List <PathFilter> paths = (List <PathFilter>)expressions.Left;
Assert.AreEqual(2, paths.Count);
Assert.IsInstanceOf(typeof(RootFilter), paths[0]);
Assert.IsInstanceOf(typeof(FieldFilter), paths[1]);
}
public void SinglePropertyAndFilterWithRegex()
{
JPath path = new JPath("Blah[?(@.title =~ /^.*Sword.*$/)]");
Assert.AreEqual(2, path.Filters.Count);
Assert.AreEqual("Blah", ((FieldFilter)path.Filters[0]).Name);
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[1]).Expression;
Assert.AreEqual(QueryOperator.RegexEquals, expressions.Operator);
Assert.AreEqual("/^.*Sword.*$/", (string)(JToken)expressions.Right);
}
public void SinglePropertyAndFilterWithDoubleEscape()
{
JPath path = new JPath(@"Blah[ ?( @.name=='h\\i' ) ]");
Assert.AreEqual(2, path.Filters.Count);
Assert.AreEqual("Blah", ((FieldFilter)path.Filters[0]).Name);
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[1]).Expression;
Assert.AreEqual(QueryOperator.Equals, expressions.Operator);
Assert.AreEqual("h\\i", (string)expressions.Value);
}
public void SinglePropertyAndFilterWithNull()
{
JPath path = new JPath("Blah[ ?( @.name==null ) ]");
Assert.AreEqual(2, path.Filters.Count);
Assert.AreEqual("Blah", ((FieldFilter)path.Filters[0]).Name);
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[1]).Expression;
Assert.AreEqual(QueryOperator.Equals, expressions.Operator);
Assert.AreEqual(null, expressions.Value.Value);
}
public void BooleanQuery_TwoValues()
{
JPath path = new JPath("[?(1 > 2)]");
Assert.AreEqual(1, path.Filters.Count);
BooleanQueryExpression booleanExpression = (BooleanQueryExpression)((QueryFilter)path.Filters[0]).Expression;
Assert.AreEqual(1, (int)(JValue)booleanExpression.Left);
Assert.AreEqual(2, (int)(JValue)booleanExpression.Right);
Assert.AreEqual(QueryOperator.GreaterThan, booleanExpression.Operator);
}
public void SinglePropertyAndFilterWithEscapedRegex()
{
JPath path = new JPath(@"Blah[?(@.title =~ /[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g)]");
Assert.AreEqual(2, path.Filters.Count);
Assert.AreEqual("Blah", ((FieldFilter)path.Filters[0]).Name);
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[1]).Expression;
Assert.AreEqual(QueryOperator.RegexEquals, expressions.Operator);
Assert.AreEqual(@"/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g", (string)(JToken)expressions.Right);
}
public void SinglePropertyAndFilterWithTrue()
{
JPath path = new JPath("Blah[ ?( @.name==true ) ]");
Assert.AreEqual(2, path.Filters.Count);
Assert.AreEqual("Blah", ((FieldFilter)path.Filters[0]).Name);
BooleanQueryExpression expressions = (BooleanQueryExpression)((QueryFilter)path.Filters[1]).Expression;
Assert.AreEqual(QueryOperator.Equals, expressions.Operator);
Assert.AreEqual(true, (bool)(JToken)expressions.Right);
}
private QueryExpression ParseExpression()
{
QueryExpression rootExpression = null;
CompositeExpression parentExpression = null;
while (_currentIndex < _expression.Length)
{
EatWhitespace();
if (_expression[_currentIndex] != '@')
throw new JsonException("Unexpected character while parsing path query: " + _expression[_currentIndex]);
_currentIndex++;
List<PathFilter> expressionPath = new List<PathFilter>();
if (ParsePath(expressionPath, _currentIndex, true))
throw new JsonException("Path ended with open query.");
EatWhitespace();
EnsureLength("Path ended with open query.");
QueryOperator op;
object value = null;
if (_expression[_currentIndex] == ')'
|| _expression[_currentIndex] == '|'
|| _expression[_currentIndex] == '&')
{
op = QueryOperator.Exists;
}
else
{
op = ParseOperator();
EatWhitespace();
EnsureLength("Path ended with open query.");
value = ParseValue();
EatWhitespace();
EnsureLength("Path ended with open query.");
}
BooleanQueryExpression booleanExpression = new BooleanQueryExpression
{
Path = expressionPath,
Operator = op,
Value = (op != QueryOperator.Exists) ? new JValue(value) : null
};
if (_expression[_currentIndex] == ')')
{
if (parentExpression != null)
{
parentExpression.Expressions.Add(booleanExpression);
return rootExpression;
}
return booleanExpression;
}
if (_expression[_currentIndex] == '&' && Match("&&"))
{
if (parentExpression == null || parentExpression.Operator != QueryOperator.And)
{
CompositeExpression andExpression = new CompositeExpression { Operator = QueryOperator.And };
if (parentExpression != null)
parentExpression.Expressions.Add(andExpression);
parentExpression = andExpression;
if (rootExpression == null)
rootExpression = parentExpression;
}
parentExpression.Expressions.Add(booleanExpression);
}
if (_expression[_currentIndex] == '|' && Match("||"))
{
if (parentExpression == null || parentExpression.Operator != QueryOperator.Or)
{
CompositeExpression orExpression = new CompositeExpression { Operator = QueryOperator.Or };
if (parentExpression != null)
parentExpression.Expressions.Add(orExpression);
parentExpression = orExpression;
if (rootExpression == null)
rootExpression = parentExpression;
}
parentExpression.Expressions.Add(booleanExpression);
}
}
throw new JsonException("Path ended with open query.");
}
