### Quotes

- Prefer Japanese corner brackets 「」 in normal prose when quoting a term.
- Do not change quotes inside inline code, code blocks, URLs, or file paths.

### Ellipsis

- Keep ellipsis style consistent with existing Japanese docs (commonly `...`).
- Never change `...` in code, URLs, or CLI examples.

### Preferred translations / glossary

Use the following preferred translations when they apply in documentation prose:

                "false");

        assertFalse(Features.deployBuildPom(properties));
    }

    @Test
    void testConsistencyWithOtherFeatureMethodsFalse() {
        // Test that deployBuildPom behaves consistently with other feature methods when false
        Map<String, Object> properties = Map.of(
                Constants.MAVEN_DEPLOY_BUILD_POM, "false",
                Constants.MAVEN_CONSUMER_POM, "false");

package org.codelibs.fess.exception;

import org.apache.lucene.queryparser.classic.ParseException;

/**
 * Exception thrown when a query parsing error occurs.
 * This exception wraps Lucene's ParseException to provide consistent error handling
 * within the Fess search framework.
 *
 */
public class QueryParseException extends FessSystemException {

    /** Serial version UID for serialization compatibility */

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Base test class providing common test infrastructure and utilities.
 * All test classes should extend this to ensure consistent test setup.
 */
@ExtendWith(MockitoExtension.class)
public abstract class BaseTest {

    protected final Logger logger = LoggerFactory.getLogger(getClass());

    @BeforeEach
    void baseSetUp() {

        assertSame(invertibleCryptographer, first);
    }

    @Test
    public void test_providePrimaryInvertibleCryptographer_consistency() {
        // Test multiple calls return consistent results
        for (int i = 0; i < 10; i++) {
            InvertibleCryptographer cryptographer = securityResourceProvider.providePrimaryInvertibleCryptographer();
            assertNotNull(cryptographer);

 */
package org.codelibs.fess.exception;

/**
 * This exception is thrown when a storage-related error occurs.
 * It can be used to wrap underlying storage exceptions, providing a
 * consistent error handling mechanism for storage operations.
 */
public class StorageException extends FessSystemException {
    private static final long serialVersionUID = 1L;

    /**

      K conflict = inverse.delegate.putIfAbsent(v, k);
      if (conflict != null) {
        broken = entry;
        // We're definitely going to throw, but we'll try to keep the BiMap in an internally
        // consistent state by removing the bad entry.
        itr.remove();
      }
    }
    if (broken != null) {
      throw new IllegalArgumentException("value already present: " + broken.getValue());
    }
  }

  - type: markdown
    attributes:
      value: |
        Translations are automatized with AI and then reviewed by native speakers. 🤖 🙋

        This allows us to keep them consistent and up-to-date.

        If there are several native speakers commenting on this discussion and
        committing to help review new translations, the FastAPI team will review it

    if (value <= 0) {
      throw new IllegalArgumentException(name + " must be positive but was: " + value);
    }
  }

  /**
   * Precondition tester for {@code Iterator.remove()} that throws an exception with a consistent
   * error message.
   */
  static void checkRemove(boolean canRemove) {
    checkState(canRemove, "no calls to next() since the last call to remove()");
  }

  private CollectPreconditions() {}

        assertNotSame(item1.hashCode(), item4.hashCode());
    }

    @Test
    public void test_hashCode_withNullInput() {
        // Test hashCode with null input - should not throw, returns consistent hash for null
        StopwordsItem item1 = new StopwordsItem(1, null);
        StopwordsItem item2 = new StopwordsItem(2, null);

        // Should not throw
        int hash1 = item1.hashCode();