err := input.Replace(v)
			if err != nil {
				return nil, err
			}

		case []any:
			recs := make([]*Record, len(v))
			for i, val := range v {
				tmpRec := input.Clone(nil)
				if err = tmpRec.Replace(val); err != nil {
					return nil, err
				}
				recs[i] = &tmpRec
			}
			return recs, nil

		default:
			input.Reset()
			input, err = input.Set("_1", &Value{value: v})

			// Read only the first json object from the file
			recs, err := getJSONStructs(b)
			if err != nil || len(recs) != 3 {
				t.Fatalf("%v or length was not 3", err)
			}

			for j, rec := range recs {
				// fmt.Println(rec)
				r, _, err := jsonpathEval(jp.PathExpr, rec)
				if err != nil {
					t.Errorf("Error: %d %d %v", i, j, err)
				}
				if !reflect.DeepEqual(r, tc.res[j]) {

  }

  @Benchmark
  int hashUtf8(int reps) {
    int res = 0;
    for (int i = 0; i < reps; i++) {
      res +=
          System.identityHashCode(
              hashFunctionEnum.getHashFunction().hashString(strings[i & SAMPLE_MASK], UTF_8));
    }
    return res;
  }

  @Benchmark
  int hashUtf8Hasher(int reps) {
    int res = 0;
    for (int i = 0; i < reps; i++) {
      res +=

  @Benchmark
  long stopwatch(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {
      Stopwatch s = Stopwatch.createStarted();
      // here is where you would do something
      total += s.elapsed(NANOSECONDS);
    }
    return total;
  }

  @Benchmark
  long manual(int reps) {
    long total = 0;
    for (int i = 0; i < reps; i++) {
      long start = System.nanoTime();

      - master
  pull_request:
    branches:
      - master

concurrency:
  # On master/release, we don't want any jobs cancelled so the sha is used to name the group
  group: ${{ (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/release' ) && format('contributor-pr-base-{0}', github.sha) || format('contributor-pr-{0}', github.ref) }}
  cancel-in-progress: false

env:

	r := new(T)
	res := c.g.apply(ctx).Delete(r)
	return int(res.RowsAffected), res.Error
}

func (c chainG[T]) Update(ctx context.Context, name string, value any) (rowsAffected int, err error) {
	var r T
	res := c.g.apply(ctx).Model(r).Update(name, value)
	return int(res.RowsAffected), res.Error
}

		}

		apiRouter.ServeHTTP(rec, req)

		// Check response code (we make only valid requests in
		// this test)
		if rec.Code != http.StatusPartialContent && rec.Code != http.StatusOK {
			bd, err1 := io.ReadAll(rec.Body)
			t.Fatalf("%s Object: %s Case %d ByteRange: %s: Got response status `%d` and body: %s,%v",
				instanceType, object, i+1, byteRange, rec.Code, string(bd), err1)
		}

         */

        CacheEntry<DfsReferralDataInternal> refs;
        synchronized (this.referralsLock) {
            refs = this.referrals;
            if (refs == null || now > refs.expiration) {
                refs = new CacheEntry<>(0);
            }
            this.referrals = refs;
        }
        String key = "\\" + domain + "\\" + root;
        if (!path.equals("\\")) {

    }
  }

  @Benchmark
  long factorialDouble(int reps) {
    long tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;
      tmp += Double.doubleToRawLongBits(impl.factorialDouble(factorials[j]));
    }
    return tmp;
  }

  @Benchmark
  int intGCD(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      int j = i & ARRAY_MASK;

    /**
     * The flag to use ECS format.
     */
    protected boolean useEcsFormat = false;

    /**
     * The ECS version.
     */
    protected String ecsVersion = "1.2.0";

    /**
     * The ECS service name.
     */
    protected String ecsServiceName = "fess";

    /**
     * The ECS event dataset.
     */
    protected String ecsEventDataset = "app";