assertEquals("the", item.getInput());
        assertEquals("the", item.getNewInput());
    }

    @Test
    public void test_constructor_withNonZeroId() {
        // Test when id is not 0 (existing item)
        StopwordsItem item = new StopwordsItem(123, "and");
        assertEquals(123, item.getId());
        assertEquals("and", item.getInput());
        assertNull(item.getNewInput());
    }

    @Test

    }

    /**
     * Test: Bulk update documents
     */
    private void testBulkUpdate() {
        logger.info("[BEGIN] testBulkUpdate");

        // Get existing documents
        final Map<String, Object> searchBody = new HashMap<>();
        searchBody.put("size", 100);
        searchBody.put("q", NAME_PREFIX + "*");

            return null;
        });

        return asJson(new ApiUpdateResponse().id(webConfig.getId()).created(true).status(Status.OK).result());
    }

    /**
     * Updates an existing web configuration setting.
     *
     * @param body the web configuration data to update
     * @return JSON response containing the updated web configuration setting ID
     */
    // PUT /api/admin/webconfig/setting

	. /etc/default/rcS
fi

# The following variables can be overwritten in $DEFAULT

# Run Fess as this user ID and group ID
FESS_USER=${packaging.fess.user}
FESS_GROUP=${packaging.fess.group}

# The first existing directory is used for JAVA_HOME (if JAVA_HOME is not defined in $DEFAULT)

    public void test_atomicCreateDirectories_existingDirectory() throws Exception {
        // Test that Files.createDirectories doesn't fail on existing directory
        Path tempDir = Files.createTempDirectory("toctou_cmd_test");
        try {
            Path existingPath = tempDir.resolve("existing");
            Files.createDirectories(existingPath);
            assertTrue(Files.exists(existingPath));

                            dependencyFixes.addToMap(filePath, extractDependencies(index))
                        }

                        line.contains("Existing dependencies which should be modified to be as indicated:") -> {
                            dependenciesToModify.addToMap(filePath, extractDependencies(index))
                        }

                form.crudMode = CrudMode.CREATE;
            });
        }).renderWith(data -> {
            registerWebConfigItems(data);
        });
    }

    /**
     * Displays the form for editing an existing request header item.
     *
     * @param form the edit form containing the ID of the item to edit
     * @return HTML response for the edit form
     */
    @Execute
    @Secured({ ROLE })

            )
        }

        // with existing non-incubating file-facade class, new members must be annotated with @Incubating and @since
        checkBinaryCompatibleKotlin(
            v1 = """
                val existing = "file-facade-class"
            """,
            v2 = """
                val existing = "file-facade-class"

                $annotatedKotlinMembers

            throwValidationError(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL), this::asEditHtml);
        });
        return redirect(getClass());
    }

    /**
     * Updates an existing key match.
     *
     * @param form the edit form
     * @return HTML response after update
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse update(final EditForm form) {

are flags that allow build engineers to opt into and out of features of Gradle Runtime or Core Plugins.
Practically every Gradle feature is behind a flag, and additional sub-flags or options provide further control.

The number of existing Gradle properties is already in the double digits. More properties will be added in the future.