// with the approach we took for returning first ip from multiple
		// params.
		if match := forRegex.FindStringSubmatch(proto); len(match) > 1 {
			if match = protoRegex.FindStringSubmatch(match[2]); len(match) > 1 {
				scheme = strings.ToLower(match[2])
			}
		}
	}

	return scheme
}

// GetSourceIPFromHeaders retrieves the IP from the X-Forwarded-For, X-Real-IP

labels.reqheader_web_crawling_config=Web Config
labels.key_match_configuration=Key Match
labels.key_match_list_term=Term
labels.key_match_list_query=Query
labels.key_match_term=Term
labels.key_match_query=Query
labels.key_match_size=Size
labels.key_match_boost=Boost
labels.key_match_urls=Urls
labels.key_match_title_details=Key Match
labels.design_configuration=Page Design
labels.design_title_file_upload=File Upload

    IOException exception = new IOException();

    try {
      try {
        throw exception;
      } catch (Throwable e) {
        throw closer.rethrow(e);
      } finally {
        closer.close();
      }
    } catch (Throwable expected) {
      assertSame(exception, expected);
    }

    assertTrue(c1.isClosed());
    assertTrue(c2.isClosed());

    }
    void connect0() throws SmbException {
        try {
            connect();
        } catch( UnknownHostException uhe ) {
            throw new SmbException( "Failed to connect to server", uhe );
        } catch( SmbException se ) {
            throw se;
        } catch( IOException ioe ) {
            throw new SmbException( "Failed to connect to server", ioe );
        }
    }

            }
            catch ( SmbUnsupportedOperationException e ) {
                Assume.assumeTrue("No Ntsmbs", false);
            }
            finally {
                try {
                    f.setAttributes(f.getAttributes() & ~SmbConstants.ATTR_READONLY);
                }
                catch ( Exception e ) {
                    // ignore
                }

      putMethod.invoke(null, sslSocket, alpnProvider)
    } catch (e: InvocationTargetException) {
      throw AssertionError("failed to set ALPN", e)
    } catch (e: IllegalAccessException) {
      throw AssertionError("failed to set ALPN", e)
    }
  }

  override fun afterHandshake(sslSocket: SSLSocket) {
    try {
      removeMethod.invoke(null, sslSocket)
    } catch (e: IllegalAccessException) {

    with warnings.catch_warnings(record=True):
        warnings.simplefilter("always")
        monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)
    with pytest.raises(RuntimeError, match=multipart_incorrect_install_error):
        app = FastAPI()

        @app.post("/")
        async def root(username: str = Form()):
            return username  # pragma: nocover

            handshake();
        } catch (IOException ex) { }
        return connection.getContentEncoding();
    }

    public long getExpiration() {
        try {
            handshake();
        } catch (IOException ex) { }
        return connection.getExpiration();
    }

    public long getDate() {
        try {
            handshake();
        } catch (IOException ex) { }

      collection.add(sampleElement);
      fail("add succeeded on unmodifiable collection");
    } catch (UnsupportedOperationException expected) {
    }

    assertCollectionsAreEquivalent(copy, collection);

    try {
      collection.addAll(siblingCollection);
      fail("addAll succeeded on unmodifiable collection");
    } catch (UnsupportedOperationException expected) {
    }

                } catch (final Exception e) {
                    responseData.setMimeType(mimeTypeHelper.getContentType(null, statObject.object()));
                }
            }
        } catch (final CrawlerSystemException e) {
            CloseableUtil.closeQuietly(responseData);
            throw e;
        } catch (final Exception e) {