protected void checkEsInvalidAggregation(String name, Object value) {
        if (value == null || (value instanceof String && ((String) value).isEmpty())) {
            String msg = "Cannot register null or empty aggregation: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

        String value = request.getParameter("type");
        if (value == null) {
            final String servletPath = request.getServletPath();
            final String[] values = servletPath.replaceAll("/+", "/").split("/");
            if (values.length > 2) {
                value = values[2];
            }
        }
        if (value == null) {
            return FormatType.SEARCH;

        }
    }

    @Test
    void testNegativeValueHandling() {
        byte[] buffer = new byte[8];

        // Test negative values in writeInt4
        SMBUtil.writeInt4(-1L, buffer, 0);
        assertEquals(-1, SMBUtil.readInt4(buffer, 0));

        // Test negative values in writeInt8
        SMBUtil.writeInt8(-1L, buffer, 0);
        assertEquals(-1L, SMBUtil.readInt8(buffer, 0));
    }

        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,

  private static class IntHolder implements Serializable {
    private int value;

    IntHolder(int value) {
      this.value = value;
    }

    @Override
    public boolean equals(@Nullable Object o) {
      return (o instanceof IntHolder) && ((IntHolder) o).value == value;
    }

    @Override
    public int hashCode() {
      return value;
    }

	switch value := dbValue.(type) {
	case []byte:
		*es = EncryptedString(bytes.TrimPrefix(value, []byte("hello")))
	case string:
		*es = EncryptedString(strings.TrimPrefix(value, "hello"))
	default:
		return fmt.Errorf("unsupported data %#v", dbValue)
	}
	return nil
}

Number validations also work for `float` values.

Here's where it becomes important to be able to declare <abbr title="greater than"><code>gt</code></abbr> and not just <abbr title="greater than or equal"><code>ge</code></abbr>. As with it you can require, for example, that a value must be greater than `0`, even if it is less than `1`.

So, `0.5` would be a valid value. But `0.0` or `0` would not.

        offset += 4;
        buffer[offset++] = (byte) 0xFF; // Non-zero value for deletePending
        buffer[offset++] = (byte) 0x80; // Non-zero value for directory

        // Decode
        int bytesDecoded = fileStandardInfo.decode(buffer, 0, buffer.length);

        // Verify - non-zero values should be treated as true
        assertEquals(22, bytesDecoded);

    return set(rowIndex, columnIndex, value);
  }

  /*
   * TODO(jlevy): Consider creating a merge() method, similar to putAll() but
   * copying non-null values only.
   */

  /**
   * {@inheritDoc}
   *
   * <p>If {@code table} is an {@code ArrayTable}, its null values will be stored in this table,
   * possibly replacing values that were previously non-null.
   *

        }
        if (clazz.isAssignableFrom(Float.class)) {
            if (value instanceof Float) {
                return (T) value;
            }
            return (T) Float.valueOf(value.toString());
        }
        if (clazz.isAssignableFrom(Boolean.class)) {
            if (value instanceof Boolean) {
                return (T) value;
            }