System.clearProperty(Constants.FESS_CONFIG_PREFIX + testKey);
        }
    }

    // Test getting numeric configuration values
    public void test_get_numericValues() {
        String intKey = "numeric.int";
        String floatKey = "numeric.float";

        System.setProperty(Constants.FESS_CONFIG_PREFIX + intKey, "123");

        assertProvideThrowsException("Test\nClassification");
    }

    public void test_provide_withNumericValues() {
        // Test classification names with numeric values
        assertProvideThrowsException("123");
        assertProvideThrowsException("0");
        assertProvideThrowsException("-1");
        assertProvideThrowsException("Test123");

        FAILED(9);

        private final int id;

        Status(final int id) {
            this.id = id;
        }

        /**
         * Gets the numeric ID of the status.
         * @return The numeric ID of the status.
         */
        public int getId() {
            return id;
        }
    }

    /**
     * Represents the base API response structure.
     */

    if (removalListener != null) {
      removalListener.onRemoval(RemovalNotification.create(key, value, cause));
    }
  }

  @SuppressWarnings("GoodTime") // timestamps as numeric primitives
  private V load(K key) throws ExecutionException {
    long startTime = ticker.read();
    V calculatedValue;
    try {
      calculatedValue = loader.load(key);
      put(key, calculatedValue);

        paramMap.put("level1", level1);

        Object result = scriptEngine.evaluate(template, paramMap);
        assertEquals("nested", result);
    }

    // Test evaluate method with numeric values
    public void test_evaluate_withNumericValues() {
        String template = "Result: ${number1} + ${number2} = ${sum}";
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("number1", 10);

        // Test with String data
        Map<String, Object> stringData = new HashMap<>();
        stringData.put("text", "test value");
        callback.store(params, stringData);

        // Test with numeric data
        Map<String, Object> numericData = new HashMap<>();
        numericData.put("integer", 123);
        numericData.put("long", 456L);
        numericData.put("double", 789.0);

            fail("Should throw NumberFormatException");
        } catch (NumberFormatException e) {
            // Expected exception
            assertNotNull(e);
        }
    }

    // Test various numeric values for time adjust
    public void xtest_getTimeAdjustTimeMillisAsLong_variousValues() {
        // Test negative value
        FessEnv.SimpleImpl negativeEnv = new FessEnv.SimpleImpl() {

        assertEquals("default", fessConfig.get(FessConfig.search_engine_TYPE));
        assertEquals("http://localhost:9201", fessConfig.get(FessConfig.search_engine_HTTP_URL));
    }

    // Test numeric conversions
    public void test_numericConversions() {
        // Test integer conversion
        Integer heartbeatInterval = fessConfig.getSearchEngineHeartbeatIntervalAsInteger();
        assertNotNull(heartbeatInterval);

     * parts other than the last may begin with a digit (for example, "3com.com"). It's important to
     * disallow an initial digit in the last part; it's the only thing that stops an IPv4 numeric
     * address like 127.0.0.1 from looking like a valid domain name.
     */

    if (isFinalPart && DIGIT_MATCHER.matches(part.charAt(0))) {
      return false;
    }

    return true;
  }

   * itself. In all other cases, the inverse is a transformation such that applying both the
   * original transformation and its inverse to a value gives you the original value give-or-take
   * numerical errors. Calling this method multiple times on the same instance will always return
   * the same instance. Calling this method on the result of calling this method on an instance will
   * always return that original instance.