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."); }