Browse Source

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

pull/46/head
Kalle Stenflo 10 years ago
parent
commit
8b918b2238
  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

@ -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

@ -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

@ -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

@ -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

@ -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

@ -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

@ -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

@ -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

@ -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

@ -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

@ -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

@ -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));

Loading…
Cancel
Save