private static final long[] VALUES = {MIN_VALUE, -1L, 0L, 1L, MAX_VALUE};

  // We need to test that our method behaves like the JDK method.
  @SuppressWarnings("InlineMeInliner")
  public void testHashCode() {
    for (long value : VALUES) {
      assertWithMessage("hashCode for " + value)
          .that(Longs.hashCode(value))
          .isEqualTo(Long.hashCode(value));
    }
  }

        if (crudMode != expectedMode) {
            throwValidationError(messages -> {
                messages.addErrorsCrudInvalidMode(GLOBAL, String.valueOf(expectedMode), String.valueOf(crudMode));
            }, this::asListHtml);
        }
    }

    // ===================================================================================

        case java.util.Date d -> pattern != null ? Integer.valueOf(new SimpleDateFormat(pattern).format(d)) : (int) d.getTime();
        case Boolean b -> b ? 1 : 0;
        default -> toInteger(o.toString());
        };
    }

    private static Integer toInteger(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Integer.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**

            boolean result = validator.isValid(cron, context);
            // Don't assert true/false here, just test that method doesn't throw
            assertNotNull("Validation should return a boolean result for: " + cron, Boolean.valueOf(result));
        }
    }

    // Test edge cases to understand the validation behavior
    public void test_edgeCaseBehavior() {
        String[] edgeCases = { "0 0 25 * * ?", // Invalid day of month

        } else if (o instanceof String) {
            return toByte((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {
                return Byte.valueOf(new SimpleDateFormat(pattern).format(o));
            }
            return (byte) ((java.util.Date) o).getTime();
        } else if (o instanceof Boolean) {
            return ((Boolean) o) ? (byte) 1 : (byte) 0;

    queue = (BlockingQueue<String>) constructor.newInstance(capacity);

    strings = new String[capacity];
    for (int i = 0; i < capacity; i++) {
      strings[i] = String.valueOf(Math.random());
    }
  }

  @Benchmark
  void addsAndRemoves(int reps) {
    int capacity = this.capacity;
    BlockingQueue<String> queue = this.queue;
    String[] strings = this.strings;

        if (crudMode != expectedMode) {
            throwValidationError(messages -> {
                messages.addErrorsCrudInvalidMode(GLOBAL, String.valueOf(expectedMode), String.valueOf(crudMode));
            }, this::asListHtml);
        }
    }

    // ===================================================================================

  }

  private static final class NullFriendlyComparator<T> implements Comparator<T>, Serializable {
    @Override
    public int compare(T left, T right) {
      return String.valueOf(left).compareTo(String.valueOf(right));
    }
  }

        final Map<String, Object> searchBody = new HashMap<>();
        final String response = checkMethodBase(searchBody).get(API_PATH + "/" + LIST_ENDPOINT_SUFFIX).asString();
        assertEquals(Integer.valueOf(0), JsonPath.from(response).get("response.status"));
    }

    @Override
    protected void tearDown() {
        // do nothing
    }

    @Test
    void crudTest() {
        testRead();
    }

        assertEquals("field1", facetInfo.field[0]);
        assertEquals("field2", facetInfo.field[1]);
        assertEquals("field3", facetInfo.field[2]);
        assertEquals(Integer.valueOf(10), facetInfo.size);
        assertEquals(Long.valueOf(5), facetInfo.minDocCount);
        assertEquals("count.desc", facetInfo.sort);
        assertEquals("unknown", facetInfo.missing);
    }

    // Test init with empty fields