ignoreIoExceptions {
      shutdown(connectionCode)
    }

    var streamsToClose: Array<Http2Stream>? = null
    withLock {
      if (streams.isNotEmpty()) {
        streamsToClose = streams.values.toTypedArray()
        streams.clear()
      }
    }

    streamsToClose?.forEach { stream ->
      ignoreIoExceptions {
        stream.close(streamCode, cause)
      }
    }

    public void handleChannelFailure(ChannelInfo channel, Exception error) {
        failover.handleFailure(channel, error);
    }
    
    private void performHealthCheck() {
        for (ChannelInfo channel : channels.values()) {
            if (channel.getIdleTime() > 60000) {  // 1 minute idle
                // Send keep-alive
                try {
                    sendKeepAlive(channel);
                } catch (Exception e) {

        String scriptType = "test";
        String script = "test script";
        Object result = jobExecutor.execute(scriptType, script);
        assertEquals("Executed: test test script", result);

        // Test with null values
        result = jobExecutor.execute(null, "script");
        assertEquals("Executed: null script", result);

        result = jobExecutor.execute("type", null);
        assertEquals("Executed: type null", result);

      doExpectCollects(expectedResult, list);
    }
    return this;
  }

  private void doExpectCollects(R expectedResult, List<T> inputs) {
    for (CollectStrategy scheme : CollectStrategy.values()) {
      A finalAccum = scheme.result(collector, inputs);
      if (collector.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {

        // When assigned to a long field, it gets sign-extended
        int readLen = response.readParameterWordsWireFormat(bytes, 0);
        long expectedOffset = expectedInt; // Sign extension happens here for negative values
        assertEquals(expectedOffset, response.getOffset(), "Offset should match decoded value");
        assertEquals(4, readLen, "Byte count returned should be 4");
    }

    @Test

* testing (as in software testing): escribir pruebas (do not translate to "probar")
* code base: code base (do not translate to "base de código")
* default: por defecto (do not translate to "predeterminado")
* default values: valores por defecto (do not translate to "valores predeterminados")
* media type: media type (do not translate to "tipo de medio")
* instantiate: crear un instance (do not translate to "instanciar")

			header: http.Header{
				"x-amz-meta-appid": []string{"amz-meta"},
			},
			metadata: map[string]string{
				"x-amz-meta-appid": "amz-meta",
			},
			shouldFail: false,
		},
		// Support multiple values
		{
			header: http.Header{
				"x-amz-meta-key": []string{"amz-meta1", "amz-meta2"},
			},
			metadata: map[string]string{
				"x-amz-meta-key": "amz-meta1,amz-meta2",
			},
			shouldFail: false,

                                }
                            } catch (final NumberFormatException e) {
                                // ignore invalid crawl-delay values
                            }
                        }
                    } else if ((value = getValue(SITEMAP_RECORD, line)) != null && value.length() > 0) {
                        robotsTxt.addSitemap(value);

        ThumbnailGenerator generator = new ThumbnailGenerator();
        assertNotNull(generator);
    }

    public void test_Options_defaultValues() {
        // Test Options class default values
        ThumbnailGenerator.Options options = new ThumbnailGenerator.Options();
        assertNull(options.sessionId);
        assertNull(options.name);
        assertNull(options.propertiesPath);

        queryCommand.setLowercaseWildcard(true);
        assertTrue(queryCommand.lowercaseWildcard);
    }

    public void test_convertWildcardQuery_withBoost() throws Exception {
        // Test with different boost values
        QueryContext queryContext = new QueryContext("test*", false);
        WildcardQuery wildcardQuery = new WildcardQuery(new Term("title", "test*"));

        // Test with boost = 0.5