regA(builder);
        return builder;
    }

    protected PercentileRanksAggregationBuilder regPercentileRanksA(String name, String field, double[] values) {
        PercentileRanksAggregationBuilder builder = AggregationBuilders.percentileRanks(name, values).field(field);
        regA(builder);
        return builder;
    }

        }

        public long getIntegerOverflowsPrevented() {
            return integerOverflowsPrevented;
        }

        public double getFailureRate() {
            return totalValidations > 0 ? (double) failedValidations / totalValidations : 0;
        }
    }

                .longOpt("activate-profiles")
                .desc(
                        "Comma-delimited list of profiles to activate. Don't use spaces between commas or double quote the full list. Prefixing a profile with ! excludes it, and ? marks it as optional.")
                .hasArg()
                .build());
        options.addOption(Option.builder(Character.toString(BATCH_MODE))

    }
    final class Splitr extends MapWithIndexSpliterator<Spliterator.OfDouble, R, Splitr>
        implements DoubleConsumer {
      double holder;

      Splitr(Spliterator.OfDouble splitr, long index) {
        super(splitr, index);
      }

      @Override
      public void accept(double t) {
        this.holder = t;
      }

      @Override
      public boolean tryAdvance(Consumer<? super R> action) {

          continue
        }

        val token = parameter.groups[2]?.value
        val value =
          when {
            token == null -> {
              // Value is "double-quoted". That's valid and our regex group already strips the quotes.
              parameter.groups[3]!!.value
            }
            token.startsWith('\'') && token.endsWith('\'') && token.length > 2 -> {

    }

    /** WAVE DASH */
    public static final char WAVE_DASH = '\u301C';

    /** FULLWIDTH TILDE */
    public static final char FULLWIDTH_TILDE = '\uFF5E';

    /** DOUBLE VERTICAL LINE */
    public static final char DOUBLE_VERTICAL_LINE = '\u2016';

    /** PARALLEL TO */
    public static final char PARALLEL_TO = '\u2225';

    /** MINUS SIGN */

      public Hasher putFloat(float f) {
        for (Hasher hasher : hashers) {
          hasher.putFloat(f);
        }
        return this;
      }

      @Override
      public Hasher putDouble(double d) {
        for (Hasher hasher : hashers) {
          hasher.putDouble(d);
        }
        return this;
      }

      @Override
      public Hasher putBoolean(boolean b) {

    public void setCreatedTime_PercentileRanks(double[] values) {
        setCreatedTime_PercentileRanks(values, null);
    }

    public void setCreatedTime_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
        setCreatedTime_PercentileRanks("createdTime", values, opLambda);
    }

    public void setCreatedTime_PercentileRanks(String name, double[] values,

        /** Number of initializing shards */
        public int initializingShards;
        /** Number of relocating shards */
        public int relocatingShards;
        /** Percentage of active shards */
        public double activeShardsPercent;
        /** Number of active shards */
        public int activeShards;
        /** Number of active primary shards */
        public int activePrimaryShards;
        /** Number of data nodes */

        s2.close();
    }

    @Test
    @DisplayName("DFS referrals: invalid double-slash prefix triggers exception")
    void dfsReferrals_invalidPath() {
        CIFSException ex = assertThrows(CIFSException.class, () -> transport.getDfsReferrals(ctx, "\\\\server\\share", null, null, 1));
        assertTrue(ex.getMessage().contains("double slash"));
    }

    @Nested
    @MockitoSettings(strictness = Strictness.LENIENT)