*   <li>It doesn't support backpressure and other features needed for resilience.
 *   <li>It doesn't provide much control of threading.
 *   <li>It doesn't offer much monitoring.
 *   <li>It doesn't propagate exceptions, so apps don't have a way to react to them.
 *   <li>It doesn't interoperate well with RxJava, coroutines, and other more commonly used
 *       alternatives.

          nextHeaderIndex += entriesToEvict
        }
        return entriesToEvict
      }

      /**
       * Read `byteCount` bytes of headers from the source stream. This implementation does not
       * propagate the never indexed flag of a header.
       */
      @Throws(IOException::class)
      fun readHeaders() {
        while (!source.exhausted()) {
          val b = source.readByte() and 0xff
          when {

	QueryFields bool
	// CreateBatchSize default create batch size
	CreateBatchSize int
	// TranslateError enabling error translation
	TranslateError bool
	// PropagateUnscoped propagate Unscoped to every other nested statement
	PropagateUnscoped bool

	// ClauseBuilders clause builder
	ClauseBuilders map[string]clause.ClauseBuilder
	// ConnPool db conn pool
	ConnPool ConnPool

                throw new RuntimeException("Test exception in listener");
            }
        });

        try {
            factory.destroyObject(pooledObject);
            fail("Should propagate exception from listener");
        } catch (Exception e) {
            assertTrue(e.getMessage().contains("Test exception"));
        }
    }

    /**
     * Test getter and setter for componentName

        RuntimeException thrownException = assertThrows(RuntimeException.class, () -> {
            delegatingConfig.getResponseTimeout();
        });

        assertSame(testException, thrownException, "Should propagate exception from delegate");
        verify(mockDelegate).getResponseTimeout();
    }

    @Test
    @DisplayName("Multiple method calls should result in multiple delegate calls")

            // No propagation
            int noPropagation = ACE.FLAGS_OBJECT_INHERIT | ACE.FLAGS_NO_PROPAGATE;
            assertTrue((noPropagation & ACE.FLAGS_NO_PROPAGATE) != 0, "Should include no propagate flag");
        }
    }

    @Nested
    @DisplayName("Interface Edge Case Handling")
    class InterfaceEdgeCaseTests {

        @Test

	p := Product6{
		Name: "unique_code",
		Item: &ProductItem2{},
	}
	_DB.Model(&Product6{}).Create(&p)

	if err := _DB.Unscoped().Delete(&p).Error; err != nil {
		t.Fatalf("unscoped did not propagate")
	}

replication can be viewed by doing a GET/HEAD on the object version - it will return a `X-Minio-Replication-DeleteMarker-Status` header and http response code of `405`. In the case of permanent deletes, if the delete replication is pending or failed to propagate to the target cluster, GET/HEAD will return additional `X-Minio-Replication-Delete-Status` header and a http response code of `405`.

![delete](https://raw.githubusercontent.com/minio/minio/master/docs/bucket/replication/DELETE_bucket_replication.png)...

    serverListener.assertFailure(EOFException::class.java)
    serverListener.assertExhausted()
    clientListener.assertFailure(e)
  }

  @Disabled("AsyncCall currently lets runtime exceptions propagate.")
  @Test
  @Throws(
    Exception::class,
  )
  fun throwingOnFailLogs() {
    webServer.enqueue(
      MockResponse
        .Builder()
        .code(200)
        .body("Body")

            log.error("Failed to reconnect durable handle", reconnectError);
            throw new IOException("Connection lost and reconnection failed", e);
        }
    } else {
        throw e;  // No durable handle, propagate error
    }
}
```

### 6.3 Session Integration
```java
// In SmbSession.java
private PersistentHandleManager handleManager;

public SmbSession(CIFSContext context, SmbTransport transport) {