Opposite to seeResponseJsonMatchesJsonPath

@param string $jsonPath
@part json
541415
public function dontSeeResponseJsonMatchesJsonPath($jsonPath)
    {
        $response = $this->connectionModule->_getResponseContent();
        $this->assertEmpty(
            (new JsonArray($response))->filterByJsonPath($jsonPath),
            "Received JSON matched the JsonPath `$jsonPath`.\nJson Response: \n" . $response
        );
    }
1322369
public function saveJSON(string $JSONfile): void
    {
        $file = new FileManager();
        $file->saveLittleFile($this->jsonData, $JSONfile);
    }
10302
public static <T> T loadJsonToBean(String jsonPath, Class<T> clazz) throws IOException {
        return loadJsonToBean(jsonPath, ValueConsts.NULL_STRING, clazz);
    }
1069989
function JSONPath(expression, options) {

		if (!options || typeof options != 'object') {
			options = {};
		}

		if (!options.resultType) {
			options.resultType = 'value';
		}

		if (typeof options.flatten == 'undefined') {
			options.flatten = false;
		}

		if (typeof options.wrap == 'undefined') {
			options.wrap = true;
		}

		if (typeof options.sandbox == 'undefined') {
			options.sandbox = {};
		}

		this.expression = expression;
		this.options = options;
		this.resultType = options.resultType;
	}
158416
public function matches(array $jsonType)
    {
        if (array_key_exists(0, $this->jsonArray) && is_array($this->jsonArray[0])) {
            // a list of items
            $msg = '';
            foreach ($this->jsonArray as $array) {
                $res = $this->typeComparison($array, $jsonType);
                if ($res !== true) {
                    $msg .= "\n" . $res;
                }
            }
            if ($msg) {
                return $msg;
            }
            return true;
        }
        return $this->typeComparison($this->jsonArray, $jsonType);
    }
751207
public function loadJSON(string $JSONfile): void
    {
        $file = new FileManager();
        $this->jsonData = $file->loadLittleFile($JSONfile);
    }
316451
public static function loadJSON($filepath,$prefix_path=null){
    $data = file_get_contents($filepath);
    $results = $data?json_decode($data,true):[];
    if($results) {
      $results = static::filterWith(["load.json", "load"], $results);
      static::loadArray($results,$prefix_path);
    }
  }
1364339
private function loadJsonFile($path)
    {
        $data = json_decode(file_get_contents($path), true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            $error = json_last_error_msg() ?: 'Unknown error';
            throw new UnexpectedValueException(
                sprintf('JSON file "%s" could not be parsed: "%s"', $path, $error)
            );
        }

        if (!is_array($data)) {
            throw new UnexpectedValueException(
                sprintf('JSON file "%s" does not return an array', $path)
            );
        }

        return $data;
    }
962643
def p_jsonpath_sort(self, p):
        "'"
        sort = _iterable.SortedThis(p[3])
        p[0] = jsonpath_rw.Child(p[1], sort)
230722
public void setJsonPathTo(String path, Object value) {
        Object cleanValue = cleanupValue(value);
        String jsonPath = getPathExpr(path);
        String newContent = getPathHelper().updateJsonPathWithValue(content, jsonPath, cleanValue);
        content = newContent;
    }
1214112
public function theJsonNodeShouldExist($jsonNode)
    {
        try {
            $this->evaluateJsonNodeValue($jsonNode);
        } catch (\Exception $e) {
            throw new WrongJsonExpectation(sprintf("The node '%s' does not exist.", $jsonNode), $this->readJson(), $e);
        }
    }
317673
protected function importFromJson($filePath)
    {

        $this->sourceData = $json = $this->readJson($filePath);
        $data = [];
        $docs = [];
        $methods = [];
        $operations = [];

        if (!empty($json)) {

            $globalInfo = $this->readGlobalInfo($json);
            $globalTitle = $this->readGlobalTitle($globalInfo);

            $items = $json['item'];

            foreach ($items as $itemIndex => $apiGroup) {
                $apiGroupName = $this->applyFilter('GroupName', $apiGroup['name']);
                $apiGroupDescription = $this->applyFilter('GroupDescription', $apiGroup['description']);
                if (empty($docs[$apiGroupName])) {
                    $docs[$apiGroupName] = ['description' => $apiGroupDescription, 'items' => []];
                } else {
                    // group already exists
                }

                $apiGroupItems = $apiGroup['item'];
                foreach ($apiGroupItems as $apiIndex => $api) {
                    $api = $this->preProcessApi($api);

                    $commonParams = compact('api', 'apiIndex',
                        'apiGroupItems', 'apiGroup', 'operations') +
                            [
                                'groupIndex' => $itemIndex,
                                'info' => $globalInfo,
                                'allItems' => $items
                            ];

                    $operation = $this->readOperationItem($commonParams);
                    $commonParams['operation'] = $operation;

                    $commonParams['apiName'] = $apiName = $this->readApiName($commonParams);
                    $skipConfig = $this->deliberateSkips($commonParams);
                    if (($skipConfig['operation']  ?? true) !== false) {
                        $operations[$apiName] = $operation;
                    }

                    if (($skipConfig['phpDoc']  ?? ($skipConfig['docs']  ?? true)) !== false) {
                        $commonParams['phpDocMethod'] = $methods[$apiName] = $this->readPhpDocMethodItem($commonParams);
                    }
                    if (($skipConfig['mdDoc']  ?? ($skipConfig['docs']  ?? true)) !== false) {
                        $docs[$apiGroupName]['items'][$apiName] = $this->readMarkdownItem($commonParams);
                    }
                }
            }

            if (!empty($operations)) {
                $data = compact('operations');
                $data['models'] = $this->getOperationModels($operations);
            }

            $this->mdDocsData = ['title' => $globalTitle, 'groups' => $docs];
            $this->methodData = $methods;
        }

        return $data;
    }
412482
public static function fromJson($jsonPatch)
    {
        if (is_string($jsonPatch)) {
            $jsonPatch = json_decode($jsonPatch, true);
        }

        $operations = [];
        foreach ($jsonPatch as $operation) {
            switch ($operation['op']) {
                case AddOperation::NAME:
                    $operations[] = new AddOperation($operation['path'], $operation['value']);
                    break;
                case CopyOperation::NAME:
                    $operations[] = new CopyOperation($operation['from'], $operation['path']);
                    break;
                case MoveOperation::NAME:
                    $operations[] = new MoveOperation($operation['from'], $operation['path']);
                    break;
                case RemoveOperation::NAME:
                    $operations[] = new RemoveOperation($operation['path']);
                    break;
                case ReplaceOperation::NAME:
                    $operations[] = new ReplaceOperation($operation['path'], $operation['value']);
                    break;
                case TestOperation::NAME:
                    $operations[] = new TestOperation($operation['path'], $operation['value']);
                    break;
                default:
                    throw new \InvalidArgumentException(
                        sprintf('Patch contains invalid operation "%s"', $operation['op'])
                    );
            }
        }

        return new static($operations);
    }
1147822
function getTypingNamesFromJson(jsonPath, filesToWatch) {
                if (host.fileExists(jsonPath)) {
                    filesToWatch.push(jsonPath);
                }
                var result = ts.readConfigFile(jsonPath, function (path) { return host.readFile(path); });
                if (result.config) {
                    var jsonConfig = result.config;
                    if (jsonConfig.dependencies) {
                        mergeTypings(ts.getOwnKeys(jsonConfig.dependencies));
                    }
                    if (jsonConfig.devDependencies) {
                        mergeTypings(ts.getOwnKeys(jsonConfig.devDependencies));
                    }
                    if (jsonConfig.optionalDependencies) {
                        mergeTypings(ts.getOwnKeys(jsonConfig.optionalDependencies));
                    }
                    if (jsonConfig.peerDependencies) {
                        mergeTypings(ts.getOwnKeys(jsonConfig.peerDependencies));
                    }
                }
            }
1053678
public static function loadContextFromFile(string $filePath): ContextInterface
    {
        if(!file_exists($filePath)){
            throw new Exception\FileNotFoundException('Context file not found: '.$filePath, 404, null, $filePath);
        }

        $contents = file_get_contents($filePath);
        $context_array = json_decode($contents, true);

        if($context_array === null){
            throw new Exception\MalformedJsonException('JSON sintax error.');
        }

        return new self($context_array);
    }
501244
public List<Object> getAllJsonPath(String json, String jsonPath) {
        List<Object> result;
        if (JsonPath.isPathDefinite(jsonPath)) {
            Object val = getJsonPath(json, jsonPath);
            if (val == null) {
                result = Collections.emptyList();
            } else {
                result = Collections.singletonList(val);
            }
        } else {
            result = parseJson(json).read(jsonPath);
        }
        return result;
    }
1102348
def parse_json_path(self, jsonpath):

        
        if jsonpath not in self.parsed:
            try:
                self.parsed[jsonpath] = self.parser(jsonpath)
            except Exception:
                self.log("Invalid Json Path: " + jsonpath, "error")
                raise InvalidJsonPathError("Invalid Json Path")

        return self.parsed[jsonpath]