rval, flatten, err := jsonpathEval(p[1:], a)
			if err != nil {
				return nil, false, err
			}

			if flatten {
				// Flatten if array.
				if arr, ok := rval.([]any); ok {
					result = append(result, arr...)
					continue
				}
			}
			result = append(result, rval)
		}
		return result, true, nil
	}
	panic("cannot reach here")

            LinkedList<String> cycle) {
        if (children != null) {
            for (String v : children) {
                DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
                if (state == null) {
                    cycle.addLast(v);
                    List<String> ret = visitCycle(graph, graph.get(v), stateMap, cycle);
                    if (ret != null) {
                        return ret;

	AssertEqual(t, result3, namedUser)

	var result4 NamedUser
	if err := DB.Raw("SELECT * FROM named_users WHERE name1 = @name OR name2 = @name2 OR name3 = @name", sql.Named("name", "jinzhu-none"), sql.Named("name2", "jinzhu2")).Find(&result4).Error; err != nil {
		t.Errorf("failed to update with named arg")
	}

	AssertEqual(t, result4, namedUser)

	cpuResourceMetrics, found := resourceMetricsMap[cpuSubsystem]
	if found {
		if cpuIdleMetric, ok := cpuResourceMetrics[getResourceKey(cpuIdle, nil)]; ok {
			avgVal := math.Round(cpuIdleMetric.Avg*100) / 100
			m.Set(sysCPUAvgIdle, avgVal)
		}
		if cpuIOWaitMetric, ok := cpuResourceMetrics[getResourceKey(cpuIOWait, nil)]; ok {
			avgVal := math.Round(cpuIOWaitMetric.Avg*100) / 100

        DataConfigCQ cq = new DataConfigCQ();
        if (queryLambda != null) {
            queryLambda.callback(cq);
        }
        FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
        if (opLambda != null) {
            opLambda.callback(builder);
        }
        if (aggsLambda != null) {
            DataConfigCA ca = new DataConfigCA();

            builder.startObject();
            if (fieldSet.contains(CLUSTER_NAME)) {
                builder.field(CLUSTER_NAME, response.getClusterName());
            }
            if (fieldSet.contains(STATUS)) {
                builder.field(STATUS, response.getStatus().name().toLowerCase(Locale.ROOT));
            }
            if (fieldSet.contains(TIMED_OUT)) {

     *             If the underlying constructor represents an abstract class
     * @throws IllegalAccessRuntimeException
     *             If the number of actual and formal parameters differ, if unwrapping of primitive arguments fails,
     *             or if after unwrapping, the parameter values cannot be converted to the corresponding formal parameter types,
     *             or if the constructor is related to an enum type

	var cred auth.Credentials
	v2Auth := r.Header.Get(xhttp.Authorization)
	if v2Auth == "" {
		return cred, ErrAuthHeaderEmpty
	}

	// Verify if the header algorithm is supported or not.
	if !strings.HasPrefix(v2Auth, signV2Algorithm) {
		return cred, ErrSignatureVersionNotSupported
	}

	cred, _, apiErr := getReqAccessKeyV2(r)
	if apiErr != ErrNone {
		return cred, apiErr
	}

	return cred, ErrNone
}

     * @param token the input token bytes
     * @param off offset into the token array
     * @param len length of token data
     * @return result token
     * @throws SmbException if an SMB protocol error occurs
     * @throws CIFSException if a general CIFS error occurs
     */
    byte[] initSecContext(byte[] token, int off, int len) throws CIFSException;

    /**
     * Gets the NetBIOS name of the remote endpoint.

			expectedErr:    errRestoreHDRMalformed,
		},
	}
	for i, tc := range testCases {
		actual, err := parseRestoreObjStatus(tc.restoreHdr)
		if err != tc.expectedErr {
			t.Fatalf("Test %d: got %v expected %v", i+1, err, tc.expectedErr)
		}
		if actual != tc.expectedStatus {
			t.Fatalf("Test %d: got %v expected %v", i+1, actual, tc.expectedStatus)
		}
	}
}