verifyTableSize(100, 33, 64);
    verifyTableSize(60, 60, 128);
    verifyTableSize(120, 60, 256);
    // if the table is only double the necessary size, we don't bother resizing it
    verifyTableSize(180, 60, 128);
    // but if it's even bigger than double, we rebuild the table
    verifyTableSize(17, 17, 32);
    verifyTableSize(17, 16, 32);
    verifyTableSize(17, 15, 32);
  }

            return true;
        }

        // Check Unicode encoded traversals
        if (UNICODE_TRAVERSAL.matcher(path).find()) {
            return true;
        }

        // Check for standalone double dots that could be dangerous
        String[] parts = path.split("[\\\\/]");
        for (String part : parts) {
            if (".".equals(part) || "..".equals(part)) {
                return true;
            }

        }

        public long getIntegerOverflowsPrevented() {
            return integerOverflowsPrevented;
        }

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

  override fun writeTo(sink: BufferedSink) {
    writeOrCountBytes(sink, false)
  }

  /**
   * Either writes this request to [sink] or measures its content length. We have one method
   * do double-duty to make sure the counting and content are consistent, particularly when it comes
   * to awkward operations like measuring the encoded length of header strings, or the
   * length-in-digits of an encoded integer.
   */

                sb.append(" -Dclassifier=");
                sb.append(classifier);
            }
            sb.append(" -Dpackaging=");
            sb.append(type);
            sb.append(" -Dfile=/path/to/file");
            sb.append(LS);

            // If people want to deploy it
            sb.append(LS);
            sb.append(indentation);

        Map<String, Object> sourceMap = new HashMap<>();
        sourceMap.put("string", "test");
        sourceMap.put("integer", 42);
        sourceMap.put("long", 100L);
        sourceMap.put("double", 3.14);
        sourceMap.put("boolean", false);
        sourceMap.put("null_value", null);
        sourceMap.put("nested", nestedMap);

        event.setSourceMap(sourceMap);

    assertTrue(service.shutDownCalled);
    assertEquals(Service.State.FAILED, service.state());
    assertThat(expected.getCause().getSuppressed()[0]).hasMessageThat().isEqualTo("double kaboom!");
  }

  private class ThrowOnRunService extends AbstractExecutionThreadService {
    private boolean shutDownCalled = false;
    private boolean throwOnShutDown = false;

    @Override

     * `get()`, but that is vanishingly unlikely.
     */
    return ref == null ? Optional.absent() : Optional.fromNullable(enumClass.cast(ref.get()));
  }

  static String formatCompact4Digits(double value) {
    return String.format(Locale.ROOT, "%.4g", value);
  }

  static boolean stringIsNullOrEmpty(@Nullable String string) {
    return string == null || string.isEmpty();
  }

  /**

        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;
    }

        if (read(tmp, 0, 4) < 0) {
            throw new SmbException("EOF");
        }
        return Encdec.dec_floatbe(tmp, 0);
    }

    @Override
    public final double readDouble() throws SmbException {
        if (read(tmp, 0, 8) < 0) {
            throw new SmbException("EOF");
        }
        return Encdec.dec_doublebe(tmp, 0);
    }

    @Override