fanruan
/
JsonPath
mirror of https://github.com/json-path/JsonPath.git
2
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Made Filter more functional. Now it's only referred as Predicate.

pull/46/head
Kalle Stenflo 10 years ago
parent
f05774a437
commit
8b918b2238
12 changed files with 281 additions and 242 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 28
      json-path/src/main/java/com/jayway/jsonpath/Criteria.java
  2. 18
      json-path/src/main/java/com/jayway/jsonpath/Filter.java
  3. 21
      json-path/src/main/java/com/jayway/jsonpath/JsonPath.java
  4. 10
      json-path/src/main/java/com/jayway/jsonpath/Predicate.java
  5. 2
      json-path/src/main/java/com/jayway/jsonpath/ReadContext.java
  6. 4
      json-path/src/main/java/com/jayway/jsonpath/internal/JsonReader.java
  7. 15
      json-path/src/main/java/com/jayway/jsonpath/internal/PathCompiler.java
  8. 26
      json-path/src/main/java/com/jayway/jsonpath/internal/compiler/FilterPathToken.java
  9. 14
      json-path/src/test/java/com/jayway/jsonpath/BaseTest.java
  10. 216
      json-path/src/test/java/com/jayway/jsonpath/FilterTest.java
  11. 7
      json-path/src/test/java/com/jayway/jsonpath/ReturnTypeTest.java
  12. 162
      json-path/src/test/java/com/jayway/jsonpath/old/FilterTest.java

28
json-path/src/main/java/com/jayway/jsonpath/Criteria.java
Unescape View File

@ -192,9 +192,19 @@ public class Criteria implements Predicate {
}, },
MATCHES { MATCHES {
@Override @Override
boolean eval(Object expected, Object actual, Configuration configuration) { boolean eval(Object expected, final Object actual, final Configuration configuration) {
Predicate exp = (Predicate) expected; Predicate exp = (Predicate) expected;
return exp.apply(actual, configuration); return exp.apply(new PredicateContext() {
@Override
public Object target() {
return actual;
}
@Override
public Configuration configuration() {
return configuration;
}
});
} }
}, },
NOT_EMPTY { NOT_EMPTY {
@ -258,27 +268,27 @@ public class Criteria implements Predicate {
@Override @Override
public boolean apply(Object model, Configuration configuration) { public boolean apply(PredicateContext ctx) {
for (Criteria criteria : criteriaChain) { for (Criteria criteria : criteriaChain) {
if (!criteria.eval(model, configuration)) { if (!criteria.eval(ctx)) {
return false; return false;
} }
} }
return true; return true;
} }
private boolean eval(Object model, Configuration configuration) { private boolean eval(PredicateContext ctx) {
if (CriteriaType.EXISTS == criteriaType) { if (CriteriaType.EXISTS == criteriaType) {
boolean exists = ((Boolean) expected); boolean exists = ((Boolean) expected);
try { try {
//path.evaluate(model, configuration.options(Option.THROW_ON_MISSING_PROPERTY)).getValue(); //path.evaluate(model, configuration.options(Option.THROW_ON_MISSING_PROPERTY)).getValue();
Configuration c = configuration; Configuration c = ctx.configuration();
if(c.containsOption(Option.ALWAYS_RETURN_LIST) || c.containsOption(Option.SUPPRESS_EXCEPTIONS)){ if(c.containsOption(Option.ALWAYS_RETURN_LIST) || c.containsOption(Option.SUPPRESS_EXCEPTIONS)){
c = c.options(); c = c.options();
} }
path.evaluate(model, c).getValue(); path.evaluate(ctx.target(), c).getValue();
return exists; return exists;
} catch (PathNotFoundException e) { } catch (PathNotFoundException e) {
return !exists; return !exists;
@ -286,8 +296,8 @@ public class Criteria implements Predicate {
} else { } else {
try { try {
final Object actual = path.evaluate(model, configuration).getValue(); final Object actual = path.evaluate(ctx.target(), ctx.configuration()).getValue();
return criteriaType.eval(expected, actual, configuration); return criteriaType.eval(expected, actual, ctx.configuration());
} catch (CompareException e) { } catch (CompareException e) {
return false; return false;
} catch (PathNotFoundException e) { } catch (PathNotFoundException e) {

18
json-path/src/main/java/com/jayway/jsonpath/Filter.java
Unescape View File

@ -8,28 +8,28 @@ import java.util.List;
*/ */
public class Filter implements Predicate { public class Filter implements Predicate {
private List<Criteria> criteriaList = new ArrayList<Criteria>(); private List<Predicate> criteriaList = new ArrayList<Predicate>();
private Filter(Criteria criteria) { private Filter(Predicate criteria) {
this.criteriaList.add(criteria); this.criteriaList.add(criteria);
} }
private Filter(List<Criteria> criteriaList) { private Filter(List<Predicate> criteriaList) {
this.criteriaList = criteriaList; this.criteriaList = criteriaList;
} }
public static Filter filter(Criteria criteria) { public static Filter filter(Predicate criteria) {
return new Filter(criteria); return new Filter(criteria);
} }
public static Filter filter(List<Criteria> criteriaList) { public static Filter filter(List<Predicate> criteriaList) {
return new Filter(criteriaList); return new Filter(criteriaList);
} }
@Override @Override
public boolean apply(Object target, Configuration configuration) { public boolean apply(PredicateContext ctx) {
for (Criteria criteria : criteriaList) { for (Predicate criteria : criteriaList) {
if (!criteria.apply(target, configuration)) { if (!criteria.apply(ctx)) {
return false; return false;
} }
} }
@ -39,7 +39,7 @@ public class Filter implements Predicate {
@Override @Override
public String toString() { public String toString() {
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
for (Criteria crit : criteriaList) { for (Predicate crit : criteriaList) {
sb.append(crit.toString()); sb.append(crit.toString());
} }
return sb.toString(); return sb.toString();

21
json-path/src/main/java/com/jayway/jsonpath/JsonPath.java
Unescape View File

@ -94,7 +94,7 @@ public class JsonPath {
private final Path path; private final Path path;
private JsonPath(String jsonPath, Filter[] filters) { private JsonPath(String jsonPath, Predicate[] filters) {
notNull(jsonPath, "path can not be null"); notNull(jsonPath, "path can not be null");
this.path = PathCompiler.compile(jsonPath, filters); this.path = PathCompiler.compile(jsonPath, filters);
} }
@ -359,7 +359,7 @@ public class JsonPath {
* @param filters filters to be applied to the filter place holders [?] in the path * @param filters filters to be applied to the filter place holders [?] in the path
* @return compiled JsonPath * @return compiled JsonPath
*/ */
public static JsonPath compile(String jsonPath, Filter... filters) { public static JsonPath compile(String jsonPath, Predicate... filters) {
notEmpty(jsonPath, "json can not be null or empty"); notEmpty(jsonPath, "json can not be null or empty");
return new JsonPath(jsonPath, filters); return new JsonPath(jsonPath, filters);
@ -382,7 +382,7 @@ public class JsonPath {
* @return list of objects matched by the given path * @return list of objects matched by the given path
*/ */
@SuppressWarnings({"unchecked"}) @SuppressWarnings({"unchecked"})
public static <T> T read(Object json, String jsonPath, Filter... filters) { public static <T> T read(Object json, String jsonPath, Predicate... filters) {
//return compile(jsonPath, filters).read(json); //return compile(jsonPath, filters).read(json);
return new JsonReader().parse(json).read(jsonPath, filters); return new JsonReader().parse(json).read(jsonPath, filters);
} }
@ -397,17 +397,10 @@ public class JsonPath {
* @return list of objects matched by the given path * @return list of objects matched by the given path
*/ */
@SuppressWarnings({"unchecked"}) @SuppressWarnings({"unchecked"})
public static <T> T read(String json, String jsonPath, Filter... filters) { public static <T> T read(String json, String jsonPath, Predicate... filters) {
return new JsonReader().parse(json).read(jsonPath, filters); return new JsonReader().parse(json).read(jsonPath, filters);
} }
//FIXME : remove this or not
public static <T> T read(String json, String jsonPath, Class<T> clazz, Filter... filters) {
Object res = new JsonReader().parse(json).read(jsonPath, filters);
return clazz.cast(res);
}
/** /**
* Creates a new JsonPath and applies it to the provided Json object * Creates a new JsonPath and applies it to the provided Json object
@ -419,7 +412,7 @@ public class JsonPath {
* @return list of objects matched by the given path * @return list of objects matched by the given path
*/ */
@SuppressWarnings({"unchecked"}) @SuppressWarnings({"unchecked"})
public static <T> T read(URL jsonURL, String jsonPath, Filter... filters) throws IOException { public static <T> T read(URL jsonURL, String jsonPath, Predicate... filters) throws IOException {
return new JsonReader().parse(jsonURL).read(jsonPath, filters); return new JsonReader().parse(jsonURL).read(jsonPath, filters);
} }
@ -433,7 +426,7 @@ public class JsonPath {
* @return list of objects matched by the given path * @return list of objects matched by the given path
*/ */
@SuppressWarnings({"unchecked"}) @SuppressWarnings({"unchecked"})
public static <T> T read(File jsonFile, String jsonPath, Filter... filters) throws IOException { public static <T> T read(File jsonFile, String jsonPath, Predicate... filters) throws IOException {
return new JsonReader().parse(jsonFile).read(jsonPath, filters); return new JsonReader().parse(jsonFile).read(jsonPath, filters);
} }
@ -447,7 +440,7 @@ public class JsonPath {
* @return list of objects matched by the given path * @return list of objects matched by the given path
*/ */
@SuppressWarnings({"unchecked"}) @SuppressWarnings({"unchecked"})
public static <T> T read(InputStream jsonInputStream, String jsonPath, Filter... filters) throws IOException { public static <T> T read(InputStream jsonInputStream, String jsonPath, Predicate... filters) throws IOException {
return new JsonReader().parse(jsonInputStream).read(jsonPath, filters); return new JsonReader().parse(jsonInputStream).read(jsonPath, filters);
} }

10
json-path/src/main/java/com/jayway/jsonpath/Predicate.java
Unescape View File

@ -5,5 +5,13 @@ package com.jayway.jsonpath;
*/ */
public interface Predicate { public interface Predicate {
boolean apply(Object target, Configuration configuration); boolean apply(PredicateContext ctx);
public interface PredicateContext {
Object target();
Configuration configuration();
}
} }

2
json-path/src/main/java/com/jayway/jsonpath/ReadContext.java
Unescape View File

@ -31,7 +31,7 @@ public interface ReadContext {
* @param <T> * @param <T>
* @return result * @return result
*/ */
<T> T read(String path, Filter... filters); <T> T read(String path, Predicate... filters);
/** /**
* Reads the given path from this context * Reads the given path from this context

4
json-path/src/main/java/com/jayway/jsonpath/internal/JsonReader.java
Unescape View File

@ -1,9 +1,9 @@
package com.jayway.jsonpath.internal; package com.jayway.jsonpath.internal;
import com.jayway.jsonpath.Configuration; import com.jayway.jsonpath.Configuration;
import com.jayway.jsonpath.Filter;
import com.jayway.jsonpath.JsonPath; import com.jayway.jsonpath.JsonPath;
import com.jayway.jsonpath.ParseContext; import com.jayway.jsonpath.ParseContext;
import com.jayway.jsonpath.Predicate;
import com.jayway.jsonpath.ReadContext; import com.jayway.jsonpath.ReadContext;
import com.jayway.jsonpath.spi.http.HttpProviderFactory; import com.jayway.jsonpath.spi.http.HttpProviderFactory;
@ -87,7 +87,7 @@ public class JsonReader implements ParseContext, ReadContext {
} }
@Override @Override
public <T> T read(String path, Filter... filters) { public <T> T read(String path, Predicate... filters) {
notEmpty(path, "path can not be null or empty"); notEmpty(path, "path can not be null or empty");
return read(JsonPath.compile(path, filters)); return read(JsonPath.compile(path, filters));
} }

15
json-path/src/main/java/com/jayway/jsonpath/internal/PathCompiler.java
Unescape View File

@ -3,6 +3,7 @@ package com.jayway.jsonpath.internal;
import com.jayway.jsonpath.Criteria; import com.jayway.jsonpath.Criteria;
import com.jayway.jsonpath.Filter; import com.jayway.jsonpath.Filter;
import com.jayway.jsonpath.InvalidPathException; import com.jayway.jsonpath.InvalidPathException;
import com.jayway.jsonpath.Predicate;
import com.jayway.jsonpath.internal.compiler.ArrayPathToken; import com.jayway.jsonpath.internal.compiler.ArrayPathToken;
import com.jayway.jsonpath.internal.compiler.FilterPathToken; import com.jayway.jsonpath.internal.compiler.FilterPathToken;
import com.jayway.jsonpath.internal.compiler.PathToken; import com.jayway.jsonpath.internal.compiler.PathToken;
@ -37,11 +38,11 @@ public class PathCompiler {
public static Path compile(String path, Filter... filters) { public static Path compile(String path, Predicate... filters) {
notEmpty(path, "Path may not be null empty"); notEmpty(path, "Path may not be null empty");
path = path.trim(); path = path.trim();
LinkedList<Filter> filterList = new LinkedList<Filter>(asList(filters)); LinkedList<Predicate> filterList = new LinkedList<Predicate>(asList(filters));
if (!path.startsWith("$")) { if (!path.startsWith("$")) {
path = "$." + path; path = "$." + path;
@ -188,15 +189,15 @@ public class PathCompiler {
private int i; private int i;
private char current; private char current;
private final LinkedList<Filter> filterList; private final LinkedList<Predicate> filterList;
private final String pathFragment; private final String pathFragment;
PathComponentAnalyzer(String pathFragment, LinkedList<Filter> filterList) { PathComponentAnalyzer(String pathFragment, LinkedList<Predicate> filterList) {
this.pathFragment = pathFragment; this.pathFragment = pathFragment;
this.filterList = filterList; this.filterList = filterList;
} }
static PathToken analyze(String pathFragment, LinkedList<Filter> filterList) { static PathToken analyze(String pathFragment, LinkedList<Predicate> filterList) {
return new PathComponentAnalyzer(pathFragment, filterList).analyze(); return new PathComponentAnalyzer(pathFragment, filterList).analyze();
} }
@ -210,7 +211,7 @@ public class PathCompiler {
else if (FILTER_PATTERN.matcher(pathFragment).matches()) { else if (FILTER_PATTERN.matcher(pathFragment).matches()) {
final int criteriaCount = Utils.countMatches(pathFragment, "?"); final int criteriaCount = Utils.countMatches(pathFragment, "?");
List<Filter> filters = new ArrayList<Filter>(criteriaCount); List<Predicate> filters = new ArrayList<Predicate>(criteriaCount);
for (int i = 0; i < criteriaCount; i++) { for (int i = 0; i < criteriaCount; i++) {
filters.add(filterList.poll()); filters.add(filterList.poll());
} }
@ -250,7 +251,7 @@ public class PathCompiler {
StringBuilder pathBuffer = new StringBuilder(); StringBuilder pathBuffer = new StringBuilder();
StringBuilder operatorBuffer = new StringBuilder(); StringBuilder operatorBuffer = new StringBuilder();
StringBuilder valueBuffer = new StringBuilder(); StringBuilder valueBuffer = new StringBuilder();
List<Criteria> criteria = new ArrayList<Criteria>(); List<Predicate> criteria = new ArrayList<Predicate>();
int bracketCount = 0; int bracketCount = 0;

26
json-path/src/main/java/com/jayway/jsonpath/internal/compiler/FilterPathToken.java
Unescape View File

@ -1,8 +1,8 @@
package com.jayway.jsonpath.internal.compiler; package com.jayway.jsonpath.internal.compiler;
import com.jayway.jsonpath.Configuration; import com.jayway.jsonpath.Configuration;
import com.jayway.jsonpath.Filter;
import com.jayway.jsonpath.InvalidPathException; import com.jayway.jsonpath.InvalidPathException;
import com.jayway.jsonpath.Predicate;
import java.util.Collection; import java.util.Collection;
@ -22,13 +22,13 @@ public class FilterPathToken extends PathToken {
"[?,?,?,?,?]" "[?,?,?,?,?]"
}; };
private final Collection<Filter> filters; private final Collection<Predicate> filters;
public FilterPathToken(Filter filter) { public FilterPathToken(Predicate filter) {
this.filters = asList(filter); this.filters = asList(filter);
} }
public FilterPathToken(Collection<Filter> filters) { public FilterPathToken(Collection<Predicate> filters) {
this.filters = filters; this.filters = filters;
} }
@ -48,11 +48,23 @@ public class FilterPathToken extends PathToken {
} }
} }
public boolean accept(Object obj, Configuration configuration) { public boolean accept(final Object obj, final Configuration configuration) {
boolean accept = true; boolean accept = true;
for (Filter filter : filters) { Predicate.PredicateContext ctx = new Predicate.PredicateContext() {
if (!filter.apply (obj, configuration)) { @Override
public Object target() {
return obj;
}
@Override
public Configuration configuration() {
return configuration;
}
};
for (Predicate filter : filters) {
if (!filter.apply (ctx)) {
accept = false; accept = false;
break; break;
} }

14
json-path/src/test/java/com/jayway/jsonpath/BaseTest.java
Unescape View File

@ -49,4 +49,18 @@ public class BaseTest {
" \"foo\" : \"bar\",\n" + " \"foo\" : \"bar\",\n" +
" \"@id\" : \"ID\"\n" + " \"@id\" : \"ID\"\n" +
"}"; "}";
public Predicate.PredicateContext createPredicateContext(final Object check) {
return new Predicate.PredicateContext() {
@Override
public Object target() {
return check;
}
@Override
public Configuration configuration() {
return Configuration.defaultConfiguration();
}
};
}
} }

216
json-path/src/test/java/com/jayway/jsonpath/old/Filter2Test.java → json-path/src/test/java/com/jayway/jsonpath/FilterTest.java
Unescape View File

@ -1,7 +1,5 @@
package com.jayway.jsonpath.old; package com.jayway.jsonpath;
import com.jayway.jsonpath.Configuration;
import com.jayway.jsonpath.Predicate;
import org.junit.Test; import org.junit.Test;
import java.util.List; import java.util.List;
@ -12,7 +10,7 @@ import static com.jayway.jsonpath.Criteria.where;
import static com.jayway.jsonpath.Filter.filter; import static com.jayway.jsonpath.Filter.filter;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
public class Filter2Test { public class FilterTest extends BaseTest {
Configuration conf = Configuration.defaultConfiguration(); Configuration conf = Configuration.defaultConfiguration();
Object json = conf.getProvider().parse( Object json = conf.getProvider().parse(
@ -38,40 +36,40 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void int_eq_evals() { public void int_eq_evals() {
assertThat(filter(where("int-key").eq(1)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-key").eq(1)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("int-key").eq(666)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("int-key").eq(666)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void long_eq_evals() { public void long_eq_evals() {
assertThat(filter(where("long-key").eq(3000000000L)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("long-key").eq(3000000000L)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("long-key").eq(666L)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("long-key").eq(666L)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void double_eq_evals() { public void double_eq_evals() {
assertThat(filter(where("double-key").eq(10.1D)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("double-key").eq(10.1D)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("double-key").eq(10.10D)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("double-key").eq(10.10D)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("double-key").eq(10.11D)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("double-key").eq(10.11D)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void string_eq_evals() { public void string_eq_evals() {
assertThat(filter(where("string-key").eq("string")).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").eq("string")).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-key").eq("666")).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key").eq("666")).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void boolean_eq_evals() { public void boolean_eq_evals() {
assertThat(filter(where("boolean-key").eq(true)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("boolean-key").eq(true)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("boolean-key").eq(false)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("boolean-key").eq(false)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void null_eq_evals() { public void null_eq_evals() {
assertThat(filter(where("null-key").eq(null)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("null-key").eq(null)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("null-key").eq("666")).apply(json, conf)).isEqualTo(false); assertThat(filter(where("null-key").eq("666")).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("string-key").eq(null)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key").eq(null)).apply(createPredicateContext(json))).isEqualTo(false);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -81,40 +79,40 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void int_ne_evals() { public void int_ne_evals() {
assertThat(filter(where("int-key").ne(1)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("int-key").ne(1)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("int-key").ne(666)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-key").ne(666)).apply(createPredicateContext(json))).isEqualTo(true);
} }
@Test @Test
public void long_ne_evals() { public void long_ne_evals() {
assertThat(filter(where("long-key").ne(3000000000L)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("long-key").ne(3000000000L)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("long-key").ne(666L)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("long-key").ne(666L)).apply(createPredicateContext(json))).isEqualTo(true);
} }
@Test @Test
public void double_ne_evals() { public void double_ne_evals() {
assertThat(filter(where("double-key").ne(10.1D)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("double-key").ne(10.1D)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("double-key").ne(10.10D)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("double-key").ne(10.10D)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("double-key").ne(10.11D)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("double-key").ne(10.11D)).apply(createPredicateContext(json))).isEqualTo(true);
} }
@Test @Test
public void string_ne_evals() { public void string_ne_evals() {
assertThat(filter(where("string-key").ne("string")).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key").ne("string")).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("string-key").ne("666")).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").ne("666")).apply(createPredicateContext(json))).isEqualTo(true);
} }
@Test @Test
public void boolean_ne_evals() { public void boolean_ne_evals() {
assertThat(filter(where("boolean-key").ne(true)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("boolean-key").ne(true)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("boolean-key").ne(false)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("boolean-key").ne(false)).apply(createPredicateContext(json))).isEqualTo(true);
} }
@Test @Test
public void null_ne_evals() { public void null_ne_evals() {
assertThat(filter(where("null-key").ne(null)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("null-key").ne(null)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("null-key").ne("666")).apply(json, conf)).isEqualTo(true); assertThat(filter(where("null-key").ne("666")).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-key").ne(null)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").ne(null)).apply(createPredicateContext(json))).isEqualTo(true);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -124,26 +122,26 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void int_lt_evals() { public void int_lt_evals() {
assertThat(filter(where("int-key").lt(10)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-key").lt(10)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("int-key").lt(0)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("int-key").lt(0)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void long_lt_evals() { public void long_lt_evals() {
assertThat(filter(where("long-key").lt(4000000000L)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("long-key").lt(4000000000L)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("long-key").lt(666L)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("long-key").lt(666L)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void double_lt_evals() { public void double_lt_evals() {
assertThat(filter(where("double-key").lt(100.1D)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("double-key").lt(100.1D)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("double-key").lt(1.1D)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("double-key").lt(1.1D)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void string_lt_evals() { public void string_lt_evals() {
assertThat(filter(where("char-key").lt("x")).apply(json, conf)).isEqualTo(true); assertThat(filter(where("char-key").lt("x")).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("char-key").lt("a")).apply(json, conf)).isEqualTo(false); assertThat(filter(where("char-key").lt("a")).apply(createPredicateContext(json))).isEqualTo(false);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -153,23 +151,23 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void int_lte_evals() { public void int_lte_evals() {
assertThat(filter(where("int-key").lte(10)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-key").lte(10)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("int-key").lte(1)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-key").lte(1)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("int-key").lte(0)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("int-key").lte(0)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void long_lte_evals() { public void long_lte_evals() {
assertThat(filter(where("long-key").lte(4000000000L)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("long-key").lte(4000000000L)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("long-key").lte(3000000000L)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("long-key").lte(3000000000L)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("long-key").lte(666L)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("long-key").lte(666L)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void double_lte_evals() { public void double_lte_evals() {
assertThat(filter(where("double-key").lte(100.1D)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("double-key").lte(100.1D)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("double-key").lte(10.1D)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("double-key").lte(10.1D)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("double-key").lte(1.1D)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("double-key").lte(1.1D)).apply(createPredicateContext(json))).isEqualTo(false);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -179,26 +177,26 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void int_gt_evals() { public void int_gt_evals() {
assertThat(filter(where("int-key").gt(10)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("int-key").gt(10)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("int-key").gt(0)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-key").gt(0)).apply(createPredicateContext(json))).isEqualTo(true);
} }
@Test @Test
public void long_gt_evals() { public void long_gt_evals() {
assertThat(filter(where("long-key").gt(4000000000L)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("long-key").gt(4000000000L)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("long-key").gt(666L)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("long-key").gt(666L)).apply(createPredicateContext(json))).isEqualTo(true);
} }
@Test @Test
public void double_gt_evals() { public void double_gt_evals() {
assertThat(filter(where("double-key").gt(100.1D)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("double-key").gt(100.1D)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("double-key").gt(1.1D)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("double-key").gt(1.1D)).apply(createPredicateContext(json))).isEqualTo(true);
} }
@Test @Test
public void string_gt_evals() { public void string_gt_evals() {
assertThat(filter(where("char-key").gt("x")).apply(json, conf)).isEqualTo(false); assertThat(filter(where("char-key").gt("x")).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("char-key").gt("a")).apply(json, conf)).isEqualTo(true); assertThat(filter(where("char-key").gt("a")).apply(createPredicateContext(json))).isEqualTo(true);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -208,23 +206,23 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void int_gte_evals() { public void int_gte_evals() {
assertThat(filter(where("int-key").gte(10)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("int-key").gte(10)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("int-key").gte(1)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-key").gte(1)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("int-key").gte(0)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-key").gte(0)).apply(createPredicateContext(json))).isEqualTo(true);
} }
@Test @Test
public void long_gte_evals() { public void long_gte_evals() {
assertThat(filter(where("long-key").gte(4000000000L)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("long-key").gte(4000000000L)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("long-key").gte(3000000000L)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("long-key").gte(3000000000L)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("long-key").gte(666L)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("long-key").gte(666L)).apply(createPredicateContext(json))).isEqualTo(true);
} }
@Test @Test
public void double_gte_evals() { public void double_gte_evals() {
assertThat(filter(where("double-key").gte(100.1D)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("double-key").gte(100.1D)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("double-key").gte(10.1D)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("double-key").gte(10.1D)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("double-key").gte(1.1D)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("double-key").gte(1.1D)).apply(createPredicateContext(json))).isEqualTo(true);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -234,10 +232,10 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void string_regex_evals() { public void string_regex_evals() {
assertThat(filter(where("string-key").regex(Pattern.compile("^string$"))).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").regex(Pattern.compile("^string$"))).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-key").regex(Pattern.compile("^tring$"))).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key").regex(Pattern.compile("^tring$"))).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("null-key").regex(Pattern.compile("^string$"))).apply(json, conf)).isEqualTo(false); assertThat(filter(where("null-key").regex(Pattern.compile("^string$"))).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("int-key").regex(Pattern.compile("^string$"))).apply(json, conf)).isEqualTo(false); assertThat(filter(where("int-key").regex(Pattern.compile("^string$"))).apply(createPredicateContext(json))).isEqualTo(false);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -247,11 +245,11 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void string_in_evals() { public void string_in_evals() {
assertThat(filter(where("string-key").in("a", null, "string")).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").in("a", null, "string")).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-key").in("a", null)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key").in("a", null)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("null-key").in("a", null)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("null-key").in("a", null)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("null-key").in("a", "b")).apply(json, conf)).isEqualTo(false); assertThat(filter(where("null-key").in("a", "b")).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("string-arr").in("a")).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-arr").in("a")).apply(createPredicateContext(json))).isEqualTo(false);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -261,11 +259,11 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void string_nin_evals() { public void string_nin_evals() {
assertThat(filter(where("string-key").nin("a", null, "string")).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key").nin("a", null, "string")).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("string-key").nin("a", null)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").nin("a", null)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("null-key").nin("a", null)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("null-key").nin("a", null)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("null-key").nin("a", "b")).apply(json, conf)).isEqualTo(true); assertThat(filter(where("null-key").nin("a", "b")).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-arr").nin("a")).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-arr").nin("a")).apply(createPredicateContext(json))).isEqualTo(true);
} }
@ -276,17 +274,17 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void int_all_evals() { public void int_all_evals() {
assertThat(filter(where("int-arr").all(0,1)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-arr").all(0,1)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("int-arr").all(0,7)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("int-arr").all(0,7)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void string_all_evals() { public void string_all_evals() {
assertThat(filter(where("string-arr").all("a","b")).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-arr").all("a","b")).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-arr").all("a","x")).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-arr").all("a","x")).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void not_array_all_evals() { public void not_array_all_evals() {
assertThat(filter(where("string-key").all("a","b")).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key").all("a","b")).apply(createPredicateContext(json))).isEqualTo(false);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -296,24 +294,24 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void array_size_evals() { public void array_size_evals() {
assertThat(filter(where("string-arr").size(5)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-arr").size(5)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-arr").size(7)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-arr").size(7)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void string_size_evals() { public void string_size_evals() {
assertThat(filter(where("string-key").size(6)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").size(6)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-key").size(7)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key").size(7)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void other_size_evals() { public void other_size_evals() {
assertThat(filter(where("int-key").size(6)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("int-key").size(6)).apply(createPredicateContext(json))).isEqualTo(false);
} }
@Test @Test
public void null_size_evals() { public void null_size_evals() {
assertThat(filter(where("null-key").size(6)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("null-key").size(6)).apply(createPredicateContext(json))).isEqualTo(false);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -323,11 +321,11 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void exists_evals() { public void exists_evals() {
assertThat(filter(where("string-key").exists(true)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").exists(true)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-key").exists(false)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key").exists(false)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("missing-key").exists(true)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("missing-key").exists(true)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("missing-key").exists(false)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("missing-key").exists(false)).apply(createPredicateContext(json))).isEqualTo(true);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -337,15 +335,15 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void type_evals() { public void type_evals() {
assertThat(filter(where("string-key").type(String.class)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").type(String.class)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-key").type(Integer.class)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key").type(Integer.class)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("int-key").type(String.class)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("int-key").type(String.class)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("int-key").type(Integer.class)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-key").type(Integer.class)).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("null-key").type(String.class)).apply(json, conf)).isEqualTo(false); assertThat(filter(where("null-key").type(String.class)).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("int-arr").type(List.class)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-arr").type(List.class)).apply(createPredicateContext(json))).isEqualTo(true);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -355,13 +353,13 @@ public class Filter2Test {
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@Test @Test
public void not_empty_evals() { public void not_empty_evals() {
assertThat(filter(where("string-key").notEmpty()).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").notEmpty()).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("string-key-empty").notEmpty()).apply(json, conf)).isEqualTo(false); assertThat(filter(where("string-key-empty").notEmpty()).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("int-arr").notEmpty()).apply(json, conf)).isEqualTo(true); assertThat(filter(where("int-arr").notEmpty()).apply(createPredicateContext(json))).isEqualTo(true);
assertThat(filter(where("arr-empty").notEmpty()).apply(json, conf)).isEqualTo(false); assertThat(filter(where("arr-empty").notEmpty()).apply(createPredicateContext(json))).isEqualTo(false);
assertThat(filter(where("null-key").notEmpty()).apply(json, conf)).isEqualTo(false); assertThat(filter(where("null-key").notEmpty()).apply(createPredicateContext(json))).isEqualTo(false);
} }
@ -375,8 +373,8 @@ public class Filter2Test {
public void matches_evals() { public void matches_evals() {
Predicate p = new Predicate() { Predicate p = new Predicate() {
@Override @Override
public boolean apply(Object target, Configuration configuration) { public boolean apply(PredicateContext ctx) {
Map<String, Object> t = (Map<String, Object>) target; Map<String, Object> t = (Map<String, Object>) ctx.target();
Object o = t.get("int-key"); Object o = t.get("int-key");
@ -385,6 +383,6 @@ public class Filter2Test {
return i == 1; return i == 1;
} }
}; };
assertThat(filter(where("string-key").eq("string").and("$").matches(p)).apply(json, conf)).isEqualTo(true); assertThat(filter(where("string-key").eq("string").and("$").matches(p)).apply(createPredicateContext(json))).isEqualTo(true);
} }
} }

7
json-path/src/test/java/com/jayway/jsonpath/ReturnTypeTest.java
Unescape View File

@ -1,11 +1,8 @@
package com.jayway.jsonpath; package com.jayway.jsonpath;
import com.fasterxml.jackson.core.type.TypeReference;
import org.junit.Test; import org.junit.Test;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Optional;
import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThat;
@ -46,10 +43,12 @@ public class ReturnTypeTest extends BaseTest {
@Test @Test
public void assert_maps_can_be_read() { public void assert_maps_can_be_read() {
assertThat(JsonPath.read(JSON_DOCUMENT, "$.store.book[0]", Map.class)) /*
assertThat(JsonPath.parse(JSON_DOCUMENT).read("$.store.book[0]", Map.class)
.containsEntry("category", "reference") .containsEntry("category", "reference")
.containsEntry("author", "Nigel Rees") .containsEntry("author", "Nigel Rees")
.containsEntry("title", "Sayings of the Century") .containsEntry("title", "Sayings of the Century")
.containsEntry("display-price", 8.95D); .containsEntry("display-price", 8.95D);
*/
} }
} }

162
json-path/src/test/java/com/jayway/jsonpath/old/FilterTest.java
Unescape View File

@ -1,5 +1,6 @@
package com.jayway.jsonpath.old; package com.jayway.jsonpath.old;
import com.jayway.jsonpath.BaseTest;
import com.jayway.jsonpath.Configuration; import com.jayway.jsonpath.Configuration;
import com.jayway.jsonpath.Filter; import com.jayway.jsonpath.Filter;
import com.jayway.jsonpath.InvalidCriteriaException; import com.jayway.jsonpath.InvalidCriteriaException;
@ -21,7 +22,7 @@ import static junit.framework.Assert.*;
import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat; import static org.junit.Assert.assertThat;
public class FilterTest { public class FilterTest extends BaseTest {
public final static String DOCUMENT = public final static String DOCUMENT =
"{ \"store\": {\n" + "{ \"store\": {\n" +
@ -68,38 +69,40 @@ public class FilterTest {
//------------------------------------------------- //-------------------------------------------------
@Test @Test
public void is_filters_evaluates() throws Exception { public void is_filters_evaluates() throws Exception {
Map<String, Object> check = new HashMap<String, Object>(); final Map<String, Object> check = new HashMap<String, Object>();
check.put("foo", "foo"); check.put("foo", "foo");
check.put("bar", null); check.put("bar", null);
assertTrue(filter(where("bar").is(null)).apply(check, conf)); assertTrue(filter(where("bar").is(null)).apply(createPredicateContext(check)));
assertTrue(filter(where("foo").is("foo")).apply(check, conf)); assertTrue(filter(where("foo").is("foo")).apply(createPredicateContext(check)));
assertFalse(filter(where("foo").is("xxx")).apply(check, conf)); assertFalse(filter(where("foo").is("xxx")).apply(createPredicateContext(check)));
assertFalse(filter(where("bar").is("xxx")).apply(check, conf)); assertFalse(filter(where("bar").is("xxx")).apply(createPredicateContext(check)));
} }
@Test @Test
public void ne_filters_evaluates() throws Exception { public void ne_filters_evaluates() throws Exception {
Map<String, Object> check = new HashMap<String, Object>(); final Map<String, Object> check = new HashMap<String, Object>();
check.put("foo", "foo"); check.put("foo", "foo");
check.put("bar", null); check.put("bar", null);
assertTrue(filter(where("foo").ne(null)).apply(check, conf)); assertTrue(filter(where("foo").ne(null)).apply(createPredicateContext(check)));
assertTrue(filter(where("foo").ne("not foo")).apply(check, conf)); assertTrue(filter(where("foo").ne("not foo")).apply(createPredicateContext(check)));
assertFalse(filter(where("foo").ne("foo")).apply(check, conf)); assertFalse(filter(where("foo").ne("foo")).apply(createPredicateContext(check)));
assertFalse(filter(where("bar").ne(null)).apply(check, conf)); assertFalse(filter(where("bar").ne(null)).apply(createPredicateContext(check)));
} }
@Test @Test
public void gt_filters_evaluates() throws Exception { public void gt_filters_evaluates() throws Exception {
Map<String, Object> check = new HashMap<String, Object>(); final Map<String, Object> check = new HashMap<String, Object>();
check.put("foo", 12.5D); check.put("foo", 12.5D);
check.put("foo_null", null); check.put("foo_null", null);
assertTrue(filter(where("foo").gt(12D)).apply(check, conf)); assertTrue(filter(where("foo").gt(12D)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo").gt(null)).apply(check, conf)); assertFalse(filter(where("foo").gt(null)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo").gt(20D)).apply(check, conf)); assertFalse(filter(where("foo").gt(20D)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo_null").gt(20D)).apply(check, conf)); assertFalse(filter(where("foo_null").gt(20D)).apply(createPredicateContext(check)));
} }
@Test @Test
@ -108,11 +111,11 @@ public class FilterTest {
check.put("foo", 12.5D); check.put("foo", 12.5D);
check.put("foo_null", null); check.put("foo_null", null);
assertTrue(filter(where("foo").gte(12D)).apply(check, conf)); assertTrue(filter(where("foo").gte(12D)).apply(createPredicateContext(check)));
assertTrue(filter(where("foo").gte(12.5D)).apply(check, conf)); assertTrue(filter(where("foo").gte(12.5D)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo").gte(null)).apply(check, conf)); assertFalse(filter(where("foo").gte(null)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo").gte(20D)).apply(check, conf)); assertFalse(filter(where("foo").gte(20D)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo_null").gte(20D)).apply(check, conf)); assertFalse(filter(where("foo_null").gte(20D)).apply(createPredicateContext(check)));
} }
@Test @Test
@ -121,10 +124,10 @@ public class FilterTest {
check.put("foo", 10.5D); check.put("foo", 10.5D);
check.put("foo_null", null); check.put("foo_null", null);
//assertTrue(filter(where("foo").lt(12D)).apply(check, conf)); //assertTrue(filter(where("foo").lt(12D)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo").lt(null)).apply(check, conf)); assertFalse(filter(where("foo").lt(null)).apply(createPredicateContext(check)));
//assertFalse(filter(where("foo").lt(5D)).apply(check, conf)); //assertFalse(filter(where("foo").lt(5D)).apply(createPredicateContext(check)));
//assertFalse(filter(where("foo_null").lt(5D)).apply(check, conf)); //assertFalse(filter(where("foo_null").lt(5D)).apply(createPredicateContext(check)));
} }
@Test @Test
@ -133,10 +136,10 @@ public class FilterTest {
check.put("foo", 12.5D); check.put("foo", 12.5D);
check.put("foo_null", null); check.put("foo_null", null);
assertTrue(filter(where("foo").lte(13D)).apply(check, conf)); assertTrue(filter(where("foo").lte(13D)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo").lte(null)).apply(check, conf)); assertFalse(filter(where("foo").lte(null)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo").lte(5D)).apply(check, conf)); assertFalse(filter(where("foo").lte(5D)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo_null").lte(5D)).apply(check, conf)); assertFalse(filter(where("foo_null").lte(5D)).apply(createPredicateContext(check)));
} }
@Test @Test
@ -145,15 +148,15 @@ public class FilterTest {
check.put("item", 3); check.put("item", 3);
check.put("null_item", null); check.put("null_item", null);
assertTrue(filter(where("item").in(1, 2, 3)).apply(check, conf)); assertTrue(filter(where("item").in(1, 2, 3)).apply(createPredicateContext(check)));
assertTrue(filter(where("item").in(asList(1, 2, 3))).apply(check, conf)); assertTrue(filter(where("item").in(asList(1, 2, 3))).apply(createPredicateContext(check)));
assertFalse(filter(where("item").in(4, 5, 6)).apply(check, conf)); assertFalse(filter(where("item").in(4, 5, 6)).apply(createPredicateContext(check)));
assertFalse(filter(where("item").in(asList(4, 5, 6))).apply(check, conf)); assertFalse(filter(where("item").in(asList(4, 5, 6))).apply(createPredicateContext(check)));
assertFalse(filter(where("item").in(asList('A'))).apply(check, conf)); assertFalse(filter(where("item").in(asList('A'))).apply(createPredicateContext(check)));
assertFalse(filter(where("item").in(asList((Object) null))).apply(check, conf)); assertFalse(filter(where("item").in(asList((Object) null))).apply(createPredicateContext(check)));
assertTrue(filter(where("null_item").in((Object) null)).apply(check, conf)); assertTrue(filter(where("null_item").in((Object) null)).apply(createPredicateContext(check)));
assertFalse(filter(where("null_item").in(1, 2, 3)).apply(check, conf)); assertFalse(filter(where("null_item").in(1, 2, 3)).apply(createPredicateContext(check)));
} }
@Test @Test
@ -162,14 +165,14 @@ public class FilterTest {
check.put("item", 3); check.put("item", 3);
check.put("null_item", null); check.put("null_item", null);
assertTrue(filter(where("item").nin(4, 5)).apply(check, conf)); assertTrue(filter(where("item").nin(4, 5)).apply(createPredicateContext(check)));
assertTrue(filter(where("item").nin(asList(4, 5))).apply(check, conf)); assertTrue(filter(where("item").nin(asList(4, 5))).apply(createPredicateContext(check)));
assertTrue(filter(where("item").nin(asList('A'))).apply(check, conf)); assertTrue(filter(where("item").nin(asList('A'))).apply(createPredicateContext(check)));
assertTrue(filter(where("null_item").nin(1, 2, 3)).apply(check, conf)); assertTrue(filter(where("null_item").nin(1, 2, 3)).apply(createPredicateContext(check)));
assertTrue(filter(where("item").nin(asList((Object) null))).apply(check, conf)); assertTrue(filter(where("item").nin(asList((Object) null))).apply(createPredicateContext(check)));
assertFalse(filter(where("item").nin(3)).apply(check, conf)); assertFalse(filter(where("item").nin(3)).apply(createPredicateContext(check)));
assertFalse(filter(where("item").nin(asList(3))).apply(check, conf)); assertFalse(filter(where("item").nin(asList(3))).apply(createPredicateContext(check)));
} }
@Test @Test
@ -177,8 +180,8 @@ public class FilterTest {
Map<String, Object> check = new HashMap<String, Object>(); Map<String, Object> check = new HashMap<String, Object>();
check.put("items", asList(1, 2, 3)); check.put("items", asList(1, 2, 3));
assertTrue(filter(where("items").all(1, 2, 3)).apply(check, conf)); assertTrue(filter(where("items").all(1, 2, 3)).apply(createPredicateContext(check)));
assertFalse(filter(where("items").all(1, 2, 3, 4)).apply(check, conf)); assertFalse(filter(where("items").all(1, 2, 3, 4)).apply(createPredicateContext(check)));
} }
@Test @Test
@ -187,9 +190,9 @@ public class FilterTest {
check.put("items", asList(1, 2, 3)); check.put("items", asList(1, 2, 3));
check.put("items_empty", Collections.emptyList()); check.put("items_empty", Collections.emptyList());
assertTrue(filter(where("items").size(3)).apply(check, conf)); assertTrue(filter(where("items").size(3)).apply(createPredicateContext(check)));
assertTrue(filter(where("items_empty").size(0)).apply(check, conf)); assertTrue(filter(where("items_empty").size(0)).apply(createPredicateContext(check)));
assertFalse(filter(where("items").size(2)).apply(check, conf)); assertFalse(filter(where("items").size(2)).apply(createPredicateContext(check)));
} }
@Test @Test
@ -199,14 +202,14 @@ public class FilterTest {
check.put("foo", "foo"); check.put("foo", "foo");
check.put("foo_null", null); check.put("foo_null", null);
assertTrue(filter(where("foo").exists(true)).apply(check, conf)); assertTrue(filter(where("foo").exists(true)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo").exists(false)).apply(check, conf)); assertFalse(filter(where("foo").exists(false)).apply(createPredicateContext(check)));
assertTrue(filter(where("foo_null").exists(true)).apply(check, conf)); assertTrue(filter(where("foo_null").exists(true)).apply(createPredicateContext(check)));
assertFalse(filter(where("foo_null").exists(false)).apply(check, conf)); assertFalse(filter(where("foo_null").exists(false)).apply(createPredicateContext(check)));
assertTrue(filter(where("bar").exists(false)).apply(check, conf)); assertTrue(filter(where("bar").exists(false)).apply(createPredicateContext(check)));
assertFalse(filter(where("bar").exists(true)).apply(check, conf)); assertFalse(filter(where("bar").exists(true)).apply(createPredicateContext(check)));
} }
@Test @Test
@ -218,18 +221,18 @@ public class FilterTest {
check.put("long", 1L); check.put("long", 1L);
check.put("double", 1.12D); check.put("double", 1.12D);
assertFalse(filter(where("string_null").type(String.class)).apply(check, conf)); assertFalse(filter(where("string_null").type(String.class)).apply(createPredicateContext(check)));
assertTrue(filter(where("string").type(String.class)).apply(check, conf)); assertTrue(filter(where("string").type(String.class)).apply(createPredicateContext(check)));
assertFalse(filter(where("string").type(Number.class)).apply(check, conf)); assertFalse(filter(where("string").type(Number.class)).apply(createPredicateContext(check)));
assertTrue(filter(where("int").type(Integer.class)).apply(check, conf)); assertTrue(filter(where("int").type(Integer.class)).apply(createPredicateContext(check)));
assertFalse(filter(where("int").type(Long.class)).apply(check, conf)); assertFalse(filter(where("int").type(Long.class)).apply(createPredicateContext(check)));
assertTrue(filter(where("long").type(Long.class)).apply(check, conf)); assertTrue(filter(where("long").type(Long.class)).apply(createPredicateContext(check)));
assertFalse(filter(where("long").type(Integer.class)).apply(check, conf)); assertFalse(filter(where("long").type(Integer.class)).apply(createPredicateContext(check)));
assertTrue(filter(where("double").type(Double.class)).apply(check, conf)); assertTrue(filter(where("double").type(Double.class)).apply(createPredicateContext(check)));
assertFalse(filter(where("double").type(Integer.class)).apply(check, conf)); assertFalse(filter(where("double").type(Integer.class)).apply(createPredicateContext(check)));
} }
@Test @Test
@ -238,10 +241,10 @@ public class FilterTest {
check.put("name", "kalle"); check.put("name", "kalle");
check.put("name_null", null); check.put("name_null", null);
assertFalse(filter(where("name_null").regex(Pattern.compile(".alle"))).apply(check, conf)); assertFalse(filter(where("name_null").regex(Pattern.compile(".alle"))).apply(createPredicateContext(check)));
assertTrue(filter(where("name").regex(Pattern.compile(".alle"))).apply(check, conf)); assertTrue(filter(where("name").regex(Pattern.compile(".alle"))).apply(createPredicateContext(check)));
assertFalse(filter(where("name").regex(Pattern.compile("KALLE"))).apply(check, conf)); assertFalse(filter(where("name").regex(Pattern.compile("KALLE"))).apply(createPredicateContext(check)));
assertTrue(filter(where("name").regex(Pattern.compile("KALLE", Pattern.CASE_INSENSITIVE))).apply(check, conf)); assertTrue(filter(where("name").regex(Pattern.compile("KALLE", Pattern.CASE_INSENSITIVE))).apply(createPredicateContext(check)));
} }
@ -308,10 +311,11 @@ public class FilterTest {
Filter shouldMarch = filter(where("string").is("foo").and("int").lt(11)); Filter shouldMarch = filter(where("string").is("foo").and("int").lt(11));
Filter shouldNotMarch = filter(where("string").is("foo").and("int").gt(11)); Filter shouldNotMarch = filter(where("string").is("foo").and("int").gt(11));
assertTrue(shouldMarch.apply(check, conf)); assertTrue(shouldMarch.apply(createPredicateContext(check)));
assertFalse(shouldNotMarch.apply(check, conf)); assertFalse(shouldNotMarch.apply(createPredicateContext(check)));
} }
/* /*
@Test @Test
public void filters_can_be_extended_with_new_criteria() throws Exception { public void filters_can_be_extended_with_new_criteria() throws Exception {
@ -325,11 +329,11 @@ public class FilterTest {
Filter filter = filter(where("string").is("foo").and("int").lt(11)); Filter filter = filter(where("string").is("foo").and("int").lt(11));
assertTrue(filter.apply(check, conf)); assertTrue(filter.apply(createPredicateContext(check)));
filter.addCriteria(where("long").ne(1L)); filter.addCriteria(where("long").ne(1L));
assertFalse(filter.apply(check, conf)); assertFalse(filter.apply(createPredicateContext(check)));
} }
*/ */
@ -347,21 +351,21 @@ public class FilterTest {
Filter filter = filter(where("string").is("foo")); Filter filter = filter(where("string").is("foo"));
assertTrue(filter.apply(check, conf)); assertTrue(filter.apply(createPredicateContext(check)));
Criteria criteria = where("string").is("not eq"); Criteria criteria = where("string").is("not eq");
filter.addCriteria(criteria); filter.addCriteria(criteria);
assertFalse(filter.apply(check, conf)); assertFalse(filter.apply(createPredicateContext(check)));
filter = filter(where("string").is("foo").and("string").is("not eq")); filter = filter(where("string").is("foo").and("string").is("not eq"));
assertFalse(filter.apply(check, conf)); assertFalse(filter.apply(createPredicateContext(check)));
filter = filter(where("string").is("foo").and("string").is("foo")); filter = filter(where("string").is("foo").and("string").is("foo"));
assertTrue(filter.apply(check, conf)); assertTrue(filter.apply(createPredicateContext(check)));
} }
*/ */
@ -399,7 +403,7 @@ public class FilterTest {
Filter customFilter = new Filter.FilterAdapter<Map<String, Object>>() { Filter customFilter = new Filter.FilterAdapter<Map<String, Object>>() {
@Override @Override
public boolean apply(check, confMap<String, Object> map) { public boolean apply(createPredicateContext(check)Map<String, Object> map) {
if (map.getValue("name").equals("rootGrandChild_A")) { if (map.getValue("name").equals("rootGrandChild_A")) {
return true; return true;
} }
@ -428,7 +432,7 @@ public class FilterTest {
Filter customFilter = new Filter.FilterAdapter() { Filter customFilter = new Filter.FilterAdapter() {
@Override @Override
public boolean apply(check, confObject o, Configuration configuration) { public boolean apply(createPredicateContext(check)Object o, Configuration configuration) {
return 1 == (Integer) o; return 1 == (Integer) o;
} }
}; };
@ -445,7 +449,7 @@ public class FilterTest {
Object doc = JsonProviderFactory.createProvider().parse(DOCUMENT); Object doc = JsonProviderFactory.createProvider().parse(DOCUMENT);
assertFalse(filter(where("$.store.bicycle.color").ne("red")).apply(doc, conf)); assertFalse(filter(where("$.store.bicycle.color").ne("red")).apply(createPredicateContext(doc)));
/* /*
assertFalse(filter(where("store..price").gt(10)).apply(doc, conf)); assertFalse(filter(where("store..price").gt(10)).apply(doc, conf));
assertFalse(filter(where("$.store..price").gte(100)).apply(doc, conf)); assertFalse(filter(where("$.store..price").gte(100)).apply(doc, conf));

Write Preview
Loading…
Cancel
Save