setupVirtualHostHelper("/Site1", "/SITE2");

        // The current implementation is case-sensitive
        Boolean result = invokeIsValidVirtualHostPath("/site1");
        assertFalse("Case mismatch should be blocked (implementation is case-sensitive)", result);
    }

    // ===================================================================================

        ScriptEngine retrieved = scriptEngineFactory.getScriptEngine("testengine");
        assertNotNull(retrieved);
        assertEquals(engine, retrieved);
    }

    // Test add method with mixed case name
    @Test
    public void test_add_mixedCaseName() {
        TestScriptEngine engine = new TestScriptEngine();
        scriptEngineFactory.add("TestEngine", engine);

        // Should be accessible with lowercase

        SmbSessionImpl session = newSession();

        // Case 1: digest already set -> false
        SMBSigningDigest dg = mock(SMBSigningDigest.class);
        setField(session, "digest", dg);
        assertFalse(session.isSignatureSetupRequired());

        // Case 2: no digest, signing enforced by transport -> true
        setField(session, "digest", null);

		for {
			q := queueItem{
				input: next,
				dst:   make(chan [][]string, 1),
				err:   nextErr,
			}
			select {
			case <-r.close:
				return
			case r.queue <- &q:
			}

			select {
			case <-r.close:
				return
			case r.input <- &q:
			}
			if nextErr != nil {
				// Exit on any error.
				return
			}

			}
		}(id, target)
	}
	wg.Wait()
	list.totalEvents.Add(1)
}

func (list *TargetList) sendAsync(event Event, targetIDset TargetIDSet) {
	select {
	case list.queue <- asyncEvent{
		ev:        event,
		targetSet: targetIDset.Clone(),
	}:
	case <-list.ctx.Done():
		list.eventsSkipped.Add(int64(len(list.queue)))
		return
	default:
		list.eventsSkipped.Add(1)

        fmt.Println("Subroute:", GetSubroute(ctx))
        for {
            select {
            case <-ctx.Done():
                return nil
            case req, ok := <-in:
                if !ok {
                    break
                }
                // Do something with payload
                out <- []byte("response")

 * address in IPv4 or IPv6 notation, or a domain name.
 *
 * <p>Because this class is intended to represent host specifiers which can reasonably be used in a
 * URI, the domain name case is further restricted to include only those domain names which end in a
 * recognized public suffix; see {@link InternetDomainName#isPublicSuffix()} for details.
 *

	h2 := StreamHandler{
		Handle: func(ctx context.Context, payload []byte, request <-chan []byte, resp chan<- []byte) *RemoteErr {
			gotCall <- struct{}{}
			select {
			case <-ctx.Done():
				gotCall <- struct{}{}
			case <-cleanReqs:
				panic("should not be called")
			}
			return nil
		},
		OutCapacity: 1,
		InCapacity:  1,
	}
	errFatal(remote.RegisterSingleHandler(handlerTest, h1))

    @Override
    protected CopyAction createCopyAction() {
        final ArchiveOutputStreamFactory compressor;
        switch (getCompression()) {
            case BZIP2:
                compressor = Bzip2Archiver.getCompressor();
                break;
            case GZIP:
                compressor = GzipArchiver.getCompressor();
                break;
            default:
                compressor = new SimpleCompressor();

├── README.md                      # Project documentation
└── CLAUDE.md                      # This file
```

## Development Commands

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

# Full build with packaging
mvn clean package

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