@Test
  fun testRequestUsesPlayProvider() {
    assumeNetwork()

    try {
      try {
        ProviderInstaller.installIfNeeded(InstrumentationRegistry.getInstrumentation().targetContext)
      } catch (gpsnae: GooglePlayServicesNotAvailableException) {
        throw TestAbortedException("Google Play Services not available", gpsnae)
      }

      val clientCertificates =
        HandshakeCertificates.Builder()

        if (errorCode != 0)
            return 4;

        try {
            securityDescriptor = new SecurityDescriptor();
            bufferIndex += securityDescriptor.decode(buffer, bufferIndex, len);
        } catch (IOException ioe) {
            throw new RuntimeException(ioe.getMessage());
        }

        return bufferIndex - start;
    }
    public String toString() {

*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+
| <<<test-jar>>>        | <<<tests>>>   | <<<jar>>>  | java      | classes, patch module |                       |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+

            }
        };

        Set<String> roleSet;

        try {
            roleSet = buildByHeader(roleQueryHelperImpl, getMockRequest());
            fail();
        } catch (final NullPointerException e) {
            //ok
        }

        roleQueryHelperImpl.headerKey = "fess1";

        getMockRequest().addHeader("aaa", "bbb");

def test_get_redirect():
    response = client.get("/portal", params={"teleport": True}, follow_redirects=False)
    assert response.status_code == 307, response.text
    assert response.headers["location"] == "https://www.youtube.com/watch?v=dQw4w9WgXcQ"


def test_openapi_schema():
    response = client.get("/openapi.json")
    assert response.status_code == 200, response.text
    assert response.json() == {
        "openapi": "3.1.0",

            throw new IllegalArgumentException(error);
        }

        final Deferred<T> deferred = new Deferred<>();
        try {
            processRequest(client, deferred);
        } catch (final Exception e) {
            throw new SuggesterException(e);
        }
        return deferred.promise();
    }

    protected abstract void processRequest(Client client, Deferred<T> deferred);

            if (mimetype != null) {
                return mimetype;
            }
            return URLConnection.guessContentTypeFromName(path);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        } finally {
            CloseableUtil.close(is);
        }
    }

        setEncoding((String) src.get(ENCODING));
        final String dataStr = (String) src.get(DATA);
        if (dataStr != null) {
            try {
                setData(Base64Util.decode(dataStr));
            } catch (final Exception e) {
                throw new OpenSearchAccessException("data: " + dataStr, e);
            }
        }
    }

    @Override

    public OptionalEntity<ScheduledJob> selectByPK(final String id) {
        Exception lastException = null;
        for (int i = 0; i < 30; i++) {
            try {
                return super.selectByPK(id);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to select a job by {}", id, e);
                }
                lastException = e;

        }
        ResultData target = resultData;
        for (final Ingester ingester : ingestFactory.getIngesters()) {
            try {
                target = ingester.process(target, responseData);
            } catch (final Exception e) {
                logger.warn("Failed to process Ingest[{}]", ingester.getClass().getSimpleName(), e);
            }
        }
        return target;
    }