Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.apache.solr;
 
 
 import java.util.*;
 
 
 public class JSONTestUtil {

  
Default delta used in numeric equality comparisons for floats and doubles.
 
   public final static double DEFAULT_DELTA = 1e-5;

  
comparison using default delta

 
   public static String match(String inputString pathAndExpectedthrows Exception {
     return match(inputpathAndExpected);
   }

  
 
   public static String match(String pathString inputString expectedthrows Exception {
     return match(pathinputexpected);
   }

  
 
   public static String matchObj(String pathObject inputObject expectedthrows Exception {
     return matchObj(path,input,expected);
   }

  

Parameters:
input JSON Structure to parse and test against
pathAndExpected JSON path expression + '==' + expected value
delta tollerance allowed in comparing float/double values
 
   public static String match(String inputString pathAndExpecteddouble deltathrows Exception {
     int pos = pathAndExpected.indexOf("==");
     String path = pos>=0 ? pathAndExpected.substring(0,pos) : null;
     String expected = pos>=0 ? pathAndExpected.substring(pos+2) : pathAndExpected;
     return match(pathinputexpecteddelta);
   }

  

Parameters:
path JSON path expression
input JSON Structure to parse and test against
expected expected value of path
delta tollerance allowed in comparing float/double values
 
   public static String match(String pathString inputString expecteddouble deltathrows Exception {
     Object inputObj = ObjectBuilder.fromJSON(input);
     Object expectObj = ObjectBuilder.fromJSON(expected);
     return matchObj(pathinputObjexpectObjdelta);
   }

  

Parameters:
path JSON path expression
input JSON Structure
expected expected JSON Object
delta tollerance allowed in comparing float/double values
 
   public static String matchObj(String pathObject inputObject expecteddouble delta) {
     CollectionTester tester = new CollectionTester(input,delta);
     boolean reversed = path.startsWith("!");
     String positivePath = reversed ? path.substring(1) : path;
     if (!tester.seek(positivePath) ^ reversed) {
       return "Path not found: " + path;
     }
     if (expected != null && (!tester.match(expected) ^ reversed)) {
       return tester.err + " @ " + tester.getPath();
     }
    return null;
  }
Tests simple object graphs, like those generated by the noggit JSON parser
  public Object valRoot;
  public Object val;
  public Object expectedRoot;
  public Object expected;
  public double delta;
  public List<Objectpath;
  public String err;
  public CollectionTester(Object valdouble delta) {
    this. = val;
    this. = val;
    this. = delta;
     = new ArrayList<Object>();
  }
  public CollectionTester(Object val) {
    this(val.);
  }
  public String getPath() {
    StringBuilder sb = new StringBuilder();
    boolean first=true;
    for (Object seg : ) {
      if (seg==nullbreak;
      if (!firstsb.append('/');
      else first=false;
      if (seg instanceof Integer) {
        sb.append('[');
        sb.append(seg);
        sb.append(']');
      } else {
        sb.append(seg.toString());
      }
    }
    return sb.toString();
  }
  void setPath(Object lastSeg) {
    .set(.size()-1, lastSeg);
  }
  Object popPath() {
    return .remove(.size()-1);
  }
  void pushPath(Object lastSeg) {
    .add(lastSeg);
  }
  void setErr(String msg) {
     = msg;
  }
  public boolean match(Object expected) {
    this. = expected;
    this. = expected;
    return match();
  }
  boolean match() {
    if ( == ) {
      return true;
    }
    if ( == null ||  == null) {
      setErr("mismatch: '" +  + "'!='" +  + "'");
      return false;
    }
    if ( instanceof List) {
      return matchList();
    }
    if ( instanceof Map) {
      return matchMap();
    }
    // generic fallback
    if (!.equals()) {
      // make an exception for some numerics
      if (( instanceof Integer &&  instanceof Long ||  instanceof Long &&  instanceof Integer)
          && ((Number)).longValue() == ((Number)).longValue()) {
        return true;
      } else if (( instanceof Double ||  instanceof Float) && ( instanceof Double ||  instanceof Float)) {
        double a = ((Number)).doubleValue();
        double b = ((Number)).doubleValue();
        if (Double.compare(a,b) == 0) return true;
        if (Math.abs(a-b) < return true;
      }
      setErr("mismatch: '" +  + "'!='" +  + "'");
      return false;
    }
    // setErr("unknown expected type " + expected.getClass().getName());
    return true;
  }
  boolean matchList() {
    List expectedList = (List);
    List v = asList();
    if (v == nullreturn false;
    int a = 0;
    int b = 0;
    pushPath(null);
    for (;;) {
      if (a >= expectedList.size() &&  b >=v.size()) {
        break;
      }
      if (a >= expectedList.size() || b >=v.size()) {
        popPath();
        setErr("List size mismatch");
        return false;
      }
       = expectedList.get(a);
       = v.get(b);
      setPath(b);
      if (!match()) return false;
      a++; b++;
    }
    
    popPath();
    return true;
  }
  private static Set<Stringreserved = new HashSet<String>(Arrays.asList("_SKIP_","_MATCH_","_ORDERED_","_UNORDERED_"));
  boolean matchMap() {
    Map<String,ObjectexpectedMap = (Map<String,Object>);
    Map<String,Objectv = asMap();
    if (v == nullreturn false;
    boolean ordered = false;
    String skipList = (String)expectedMap.get("_SKIP_");
    String matchList = (String)expectedMap.get("_MATCH_");
    Object orderedStr = expectedMap.get("_ORDERED_");
    Object unorderedStr = expectedMap.get("_UNORDERED_");
    if (orderedStr != nullordered = true;
    if (unorderedStr != nullordered = false;
    Set<Stringmatch = null;
    if (matchList != null) {
      match = new HashSet(StrUtils.splitSmart(matchList,",",false));
    }
    Set<Stringskips = null;
    if (skipList != null) {
      skips = new HashSet(StrUtils.splitSmart(skipList,",",false));
    }
    Set<Stringkeys = match != null ? match : expectedMap.keySet();
    Set<Stringvisited = new HashSet<String>();
    Iterator<Map.Entry<String,Object>> iter = ordered ? v.entrySet().iterator() : null;
    int numExpected=0;
    pushPath(null);
    for (String expectedKey : keys) {
      if (.contains(expectedKey)) continue;
      numExpected++;
      setPath(expectedKey);
      if (!v.containsKey(expectedKey)) {
        popPath();
        setErr("expected key '" + expectedKey + "'");
        return false;
      }
       = expectedMap.get(expectedKey);
      if (ordered) {
        Map.Entry<String,Objectentry;
        String foundKey;
        for(;;) {
          if (!iter.hasNext()) {
            popPath();
            setErr("expected key '" + expectedKey + "' in ordered map");
            return false;           
          }
          entry = iter.next();
          foundKey = entry.getKey();
          if (skips != null && skips.contains(foundKey))continue;
          if (match != null && !match.contains(foundKey)) continue;
          break;
        }
        if (!entry.getKey().equals(expectedKey)) {
          popPath();          
          setErr("expected key '" + expectedKey + "' instead of '"+entry.getKey()+"' in ordered map");
          return false;
        }
         = entry.getValue();
      } else {
        if (skips != null && skips.contains(expectedKey)) continue;
         = v.get(expectedKey);
      }
      if (!match()) return false;
    }
    popPath();
    // now check if there were any extra keys in the value (as long as there wasn't a specific list to include)
    if (match == null) {
      int skipped = 0;
      if (skips != null) {
        for (String skipStr : skips)
          if (v.containsKey(skipStr)) skipped++;
      }
      if (numExpected != (v.size() - skipped)) {
        HashSet<Stringset = new HashSet<String>(v.keySet());
        set.removeAll(expectedMap.keySet());
        setErr("unexpected map keys " + set); 
        return false;
      }
    }
    return true;
  }
  public boolean seek(String seekPath) {
    if ( == nullreturn true;
    if (seekPath.startsWith("/")) {
      seekPath = seekPath.substring(1);
    }
    if (seekPath.endsWith("/")) {
      seekPath = seekPath.substring(0,seekPath.length()-1);
    }
    List<StringpathList = StrUtils.splitSmart(seekPath"/"false);
    return seek(pathList);
  }
  List asList() {
    // TODO: handle native arrays
    if ( instanceof List) {
      return (List);
    }
    setErr("expected List");
    return null;
  }
  
    // TODO: handle NamedList
    if ( instanceof Map) {
      return (Map<String,Object>);
    }
    setErr("expected Map");
    return null;
  }
  public boolean seek(List<StringseekPath) {
    if (seekPath.size() == 0) return true;
    String seg = seekPath.get(0);
    if (seg.charAt(0)=='[') {
      List listVal = asList();
      if (listVal==nullreturn false;
      int arrIdx = Integer.parseInt(seg.substring(1, seg.length()-1));
      if (arrIdx >= listVal.size()) return false;
       = listVal.get(arrIdx);
      pushPath(arrIdx);
    } else {
      Map<String,ObjectmapVal = asMap();
      if (mapVal==nullreturn false;
      // use containsKey rather than get to handle null values
      if (!mapVal.containsKey(seg)) return false;
       = mapVal.get(seg);
      pushPath(seg);
    }
    // recurse after removing head of the path
    return seek(seekPath.subList(1,seekPath.size()));
  }
New to GrepCode? Check out our FAQ X