when:
        using m2
        run 'retrieve'

        then:
        file('build/foo-1.0.jar').assertIsCopyOf(m2Module.artifactFile)
    }

    def "does not reuse cached artifacts from maven local cache when they are different to those in the remote repository"() {
        given:
        def remoteModule = mavenHttpRepo.module('gradletest.maven.local.cache.test', "foo", "1.0").publish()

    }

    @Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = "TestKit needs a real Gradle distribution here")
    @CustomDaemonDirectory
    def "user daemon process does not reuse existing daemon process intended for test execution even when using same gradle user home"() {
        given:
        def defaultDaemonDir = testKitDir.file("daemon")

 * a lot of unnecessary and unserializable state to be dragged in.
 *
 * A better change would be to split an immutable id type out of PublishArtifactLocalArtifactMetadata (or reuse one of the existing
 * implementations). However, the Eclipse tooling model builder assumes that the id and metadata objects are the same and also that

    private static final ModelType<ModelMap<?>> MODEL_MAP_MODEL_TYPE = new ModelType<ModelMap<?>>() {
    };

    // TODO extract common stuff from this and ModelSet and reuse

    @Override
    public <T> void extract(ModelSchemaExtractionContext<T> extractionContext) {
        ModelType<T> type = extractionContext.getType();
        if (MODEL_MAP_MODEL_TYPE.isAssignableFrom(type)) {

 * system property is set to {@code true}.
 * <p>
 * Most of our samples that aren't aiming to test the configuration cache itself, do not care about
 * its output much. This normalizer allows to reuse the same "golden" output files when testing such
 * samples with the configuration cache enabled.
 */
public class ConfigurationCacheOutputCleaner implements OutputNormalizer {

	st.ss_size = CSIGSTKSZ;
	if (sigaltstack(&st, &ost) < 0) {
		perror("sigaltstack failed");
		abort();
	}

	// Call Go.
	SigStackCallback();

	// Disable signal stack and protect it so we can detect reuse.
	if (ost.ss_flags & SS_DISABLE) {
		// Darwin libsystem has a bug where it checks ss_size
		// even if SS_DISABLE is set. (The kernel gets it right.)
		ost.ss_size = CSIGSTKSZ;
	}
	if (sigaltstack(&ost, NULL) < 0) {

```Python
from starlette.exceptions import HTTPException as StarletteHTTPException
```

### Reuse **FastAPI**'s exception handlers

If you want to use the exception along with the same default exception handlers from  **FastAPI**, You can import and reuse the default exception handlers from `fastapi.exception_handlers`:

```Python hl_lines="2-5  15  21"

        def outstr = new LinePerThreadBufferingOutputStream(action)

        when:
        outstr.close()

        then:
        1 * action.endOfStream(null)
        0 * action._
    }

    def "can reuse the output stream on the same thread after it has been closed"() {
        TextStream action = Mock()
        def outstr = new LinePerThreadBufferingOutputStream(action)

        when:
        outstr.write("text".bytes)

        when:
        reserved.each { int port ->
            range.deallocate(port)
        }

        then:
        range.allocated.size() == 0
    }

    def "can reuse deallocated ports" () {
        _ * portDetector.isAvailable(_) >> { true }

        when:
        10.times {
            range.allocate()
        }

        then:
        range.allocate() == -1

        for (int i = 0; i < pos; i++) {
            newElements.add(elements.get(i));
        }
        if (pos < list.size()) {
            // If we broke out of the comparison because there was a difference, we can reuse the snapshot of the new element
            if (newElement != null) {
                newElements.add(newElement);
                pos++;
            }
            // Anything left over only exists in the new list