* implemented in terms of {@link #getIfPresent}; {@link #putAll} is implemented in terms of {@link
 * #put}, {@link #invalidateAll(Iterable)} is implemented in terms of {@link #invalidate}. The
 * method {@link #cleanUp} is a no-op. All other methods throw an {@link
 * UnsupportedOperationException}.
 *
 * @author Charles Fry
 * @since 10.0
 */
@GwtCompatible
public abstract class AbstractCache<K, V> implements Cache<K, V> {

        // Test clearing a flag
        message.setFlag(0b0001, false);
        assertEquals(0b0100, message.getFlags(), "Flag 0b0001 should be cleared.");

        message.setFlag(0b0100, false);
        assertEquals(0, message.getFlags(), "Flag 0b0100 should be cleared.");

        // Test setting a flag that is already set
        message.setFlags(0b1000);
        message.setFlag(0b1000, true);

## Development Commands

### Build and Test
```bash
# Clean build and run tests
mvn clean test

# Full build with packaging
mvn clean package

# Run tests only
mvn test

# Run specific tests
mvn test -Dtest=CurlTest
mvn test -Dtest=CurlRequestTest
mvn test -Dtest=CurlResponseTest

    }

    /**
     * Close circuit breaker and cleanup resources
     */
    public void close() {
        if (thresholdAdjustmentTask != null) {
            thresholdAdjustmentTask.cancel(false);
        }
        if (scheduler != null) {
            scheduler.shutdown();
        }
        log.info("[{}] Circuit breaker closed and resources cleaned up", name);
    }

5. **Resources**: Test resources are properly managed and cleaned up

## Contributing

When adding new tests:
1. Follow the existing naming convention: `test_<method>_<scenario>_<expectedResult>`
2. Add clear JavaDoc comments explaining the test purpose
3. Ensure tests are independent and can run in any order
4. Clean up resources in finally blocks or use try-with-resources

 * documents and converting them into a key-value structure.
 *
 * <p>This interface extends {@link java.io.Closeable}, so implementations
 * should also handle resource cleanup when the {@link #close()} method is called.</p>
 */
public interface DocumentReader extends Closeable {
    /**
     * Reads a document and returns its contents as a map.
     *

     * Default constructor.
     */
    public MailForm() {
        // Default constructor
    }

    /** The incremental crawling setting. */
    public String incrementalCrawling;

    /** The day for cleanup setting. */
    public String dayForCleanup;

    /** The crawling thread count setting. */
    public String crawlingThreadCount;

    /** The search log setting. */
    public String searchLog;

     *   <li>If this field's value == null because it originally belonged to another thread and that
     *       thread cleared it, we still know that it's not associated with our thread
     *   <li>If this field's value == null because it was associated with our thread and was
     *       cleared, we know that we're not executing inline any more
     * </ul>
     *

    // in combination with immutable cache entries, will ensure a thread-safe cache.
    CacheEntry<K, V> entry;

    // Check cache. We use == on purpose because it's cheaper and a cache miss is ok.
    entry = cacheEntry1;
    if (entry != null && entry.key == key) {
      return entry.value;
    }
    entry = cacheEntry2;
    if (entry != null && entry.key == key) {

    @DisplayName("parseURL: fragment is moved into path and ref cleared")
    void testParseURL_FragmentMovedToPath() throws MalformedURLException {
        // Arrange & Act
        Handler handler = newHandler();
        URL url = new URL(null, "smb://server/share#frag", handler);

        // Assert: ref is moved into path by Handler.parseURL
        assertNull(url.getRef(), "Ref must be cleared by Handler");