public String apply(String value) {
            return Ascii.toLowerCase(value);
          }
        };

    static final EntryTransformer<String, String, String> ENTRY_TRANSFORMER =
        new EntryTransformer<String, String, String>() {
          @Override
          public String transformEntry(String key, String value) {
            return Ascii.toLowerCase(value);
          }
        };
  }

        messageBlock.setUid(uid);

        // Then
        verify(messageBlock).setUid(uid);
    }

    @Test
    @DisplayName("Test setUid with boundary values")
    void testSetUidWithBoundaryValues() {
        // Test with various uid values
        int[] uids = { 0, 1, Integer.MAX_VALUE, Integer.MIN_VALUE };

        for (int uid : uids) {
            doNothing().when(messageBlock).setUid(uid);

    }

    /**
     * Checks if a checkbox value represents an enabled state.
     * This method considers "on" and "true" (case-insensitive) as enabled values.
     *
     * @param value the checkbox value to check
     * @return true if the value represents an enabled checkbox, false otherwise
     */
    public static boolean isCheckboxEnabled(final String value) {
        if (value == null) {
            return false;
        }

    tasksFinished.await();

    // Check all of the removal notifications we received: they should have had correctly-associated
    // keys and values. (An earlier bug saw removal notifications for in-progress computations,
    // which had real keys with null values.)
    Map<String, String> removalNotifications = new HashMap<>();
    for (RemovalNotification<String, String> notification : listener) {

    tasksFinished.await();

    // Check all of the removal notifications we received: they should have had correctly-associated
    // keys and values. (An earlier bug saw removal notifications for in-progress computations,
    // which had real keys with null values.)
    Map<String, String> removalNotifications = new HashMap<>();
    for (RemovalNotification<String, String> notification : listener) {

  public void testPut_supportedPresent() {
    assertEquals("put(present, value) should return the old value", v0(), getMap().put(k0(), v3()));
    expectReplacement(entry(k0(), v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPut_supportedNotPresent() {
    assertNull("put(notPresent, value) should return null", put(e3()));
    expectAdded(e3());
  }

    /** Boost expression to apply to matching documents */
    @Required
    @Size(max = 10000)
    public String boostExpr;

    /** Sort order for displaying boost configurations */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer sortOrder;

    /** User who created this configuration */
    @Size(max = 1000)
    public String createdBy;

     */
    @Size(max = 1000)
    public String virtualHost;

    /**
     * The sort order for this related content (0-2147483647).
     */
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer sortOrder;

    /**
     * The username who created this related content.
     */
    @Size(max = 1000)
    public String createdBy;

        }

        public void setSetupWireFormatReturn(int value) {
            this.setupWireFormatReturn = value;
        }

        public void setParametersWireFormatReturn(int value) {
            this.parametersWireFormatReturn = value;
        }

        public void setDataWireFormatReturn(int value) {
            this.dataWireFormatReturn = value;
        }

        // Getters for protected fields for testing

                }
            }
        }
        return paramMap;
    }

    /**
     * Encrypts sensitive parameter values.
     *
     * @param value the parameter string
     * @return the encrypted parameter string
     */
    public static String encrypt(final String value) {
        final StringBuilder buf = new StringBuilder();