Instance 0

Class140.openConnection(String url)#2{
    if (proxy != null)
      urlConnection = (HttpURLConnection) u.openConnection(proxy);
    else
      urlConnection = (HttpURLConnection) u.openConnection();
    urlConnection.setRequestProperty("User-Agent", userAgent);
}


Instance 1

Class1470.testExtensionAuthFilter(){
    URL url = new URL("http://localhost:" + port + "/default");
    HttpURLConnection get = (HttpURLConnection) url.openConnection();
    get.setRequestProperty(DummyAuthFilter.AUTH_HDR, DummyAuthFilter.SECRET_USER);
    Assert.assertEquals(HttpServletResponse.SC_OK, get.getResponseCode());
    get = (HttpURLConnection) url.openConnection();
    get.setRequestProperty(DummyAuthFilter.AUTH_HDR, "hacker");
    Assert.assertEquals(HttpServletResponse.SC_UNAUTHORIZED, get.getResponseCode());
}


Instance 2

Class50.testEnforceSlash()#0{
        final TestWebServer testWebServer = createTestWebServer(new MyResource());
        int port = testWebServer.getPort();
        URL serverURL = new URL("http://localhost:" + port + "/foo/bar");
        HttpURLConnection connection = (HttpURLConnection) serverURL.openConnection();
        connection = (HttpURLConnection) serverURL.openConnection();
        connection.setRequestMethod("GET");
        connection.addRequestProperty("Accept", "text/html, */*; q=.2");    
        Assert.assertEquals(204, connection.getResponseCode());
}


Instance 3

Class1350.setupConnection(Context context,URL url,ConnectionCallback callback)#0{
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        conn = (HttpURLConnection)url.openConnection();
        conn.setInstanceFollowRedirects(false);
        conn.setDoInput(true);
        addAuthentication(context, conn);
}


Instance 4

Class840.verifyRedirection(URL url){
    LOG.info("Verifying redirection of " + url);
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setInstanceFollowRedirects(false);
    conn.connect();
    assertEquals(HttpURLConnection.HTTP_MOVED_TEMP, conn.getResponseCode());
    conn.disconnect();
    URL redirectedUrl = new URL(conn.getHeaderField("Location"));
    conn = (HttpURLConnection) redirectedUrl.openConnection();
    conn.connect();
    assertEquals(HttpURLConnection.HTTP_OK, conn.getResponseCode());
    conn.disconnect();
}


Instance 5

Class1300.testVaryMatchesChangedRequestHeaderField(){
        server.enqueue(new MockResponse()
                .addHeader("Cache-Control: max-age=60")
                .addHeader("Vary: Accept-Language")
                .setBody("A"));
        server.enqueue(new MockResponse().setBody("B"));
        server.play();
        URL url = server.getUrl("/");
        HttpURLConnection frConnection = (HttpURLConnection) url.openConnection();
        frConnection.addRequestProperty("Accept-Language", "fr-CA");
        assertEquals("A", readAscii(frConnection));
        HttpURLConnection enConnection = (HttpURLConnection) url.openConnection();
        enConnection.addRequestProperty("Accept-Language", "en-US");
        assertEquals("B", readAscii(enConnection));
}


Instance 6

Class790.test1()#0{
    connection = (HttpURLConnection) urlToto.openConnection();
    contents = getContents(connection).toString();
    assertEquals("tata", contents.trim());
    connection = (HttpURLConnection) urlTiti.openConnection();
    contents = getContents(connection).toString();
    assertEquals("titi", contents.trim());
}


Instance 7

Class1150.dispatchRequest(String argURL){
            URL url = new URL(argURL);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy);
            connection.setRequestProperty("Cache-Control", "no-transform");
            connection.setRequestMethod("GET");
            connection.setInstanceFollowRedirects(true);
            connection.connect();
            int responseCode = connection.getResponseCode();
            if (responseCode != HttpURLConnection.HTTP_OK) {
                Logger.logError("JGoogleAnalyticsTracker: Error requesting url '{}', received response code {}" + argURL + responseCode);
            }
            Logger.logDebug("Error making tracking request", e);
}


Instance 8

Class1220.getRequest(String path){
        URL url = new URL(path);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        conn.setConnectTimeout(5000);
        if (conn.getResponseCode() == 200) {
            return conn.getInputStream();
        }
}


Instance 9

Class1280.invoke(String method,String resource,String queryString,String contentType)#1{
        if (queryString != null) {
            s += "?" + queryString;
        }
        HttpURLConnection conn = (HttpURLConnection) new URL(s).openConnection();
        conn.setRequestProperty("content-type", contentType);
        conn.setRequestMethod(method);
        conn.connect();
        return conn.getResponseCode();
}


Instance 10

Class930.get(String url,Type type){
    URL obj = new URL(url);
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");
    if (con.getResponseCode() == 200) {
      Reader reader = new InputStreamReader(con.getInputStream(), "UTF-8");
      return GSON.fromJson(reader, type);
    }
}


Instance 11

Class1380.getImageStreamFromUrl(String path){
        URL url = new URL(path);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(12 * 1000);
        conn.setRequestMethod("GET");
        if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
            return conn.getInputStream();
        }
}


Instance 12

Class670.dispatchRequest(String argURL){
            URL url = new URL(argURL);
            HttpURLConnection connection = (HttpURLConnection)url.openConnection(proxy);
            connection.setRequestMethod("GET");
            connection.setInstanceFollowRedirects(true);
            connection.connect();
            int responseCode = connection.getResponseCode();
            if (responseCode != HttpURLConnection.HTTP_OK) {
                logger.error("JGoogleAnalyticsTracker: Error requesting url '{}', received response code {}", argURL, responseCode);
            } else {
                logger.debug("JGoogleAnalyticsTracker: Tracking success for url '{}'", new Object[]{argURL});
            }
            logger.error("Error making tracking request", e);
}


Instance 13

Class860.http(String method,String uri)#0{
      URL url = new URL(uri);
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.setRequestMethod(method);
        Object content = conn.getContent();
        if(content instanceof InputStream)
            return new Response(conn.getResponseCode(), IOUtils.toString((InputStream) content, "UTF-8"));
        else if(content instanceof String)
            return new Response(conn.getResponseCode(), (String) content);
        else
            return new Response(conn.getResponseCode(), "unknown");
}


Instance 14

Class330.readCoreStatus()#0{
        URL coreStatusURL = new URL("http://localhost:8983/solr/admin/cores?action=STATUS");
        HttpURLConnection coreStatusConn = (HttpURLConnection) coreStatusURL.openConnection();
        coreStatusConn.connect();
        if (coreStatusConn.getResponseCode() != 200) {
            throw new RuntimeException("Fetch Solr core status: expected status 200 but got: " +
                    coreStatusConn.getResponseCode());
        }
        InputStream is = coreStatusConn.getInputStream();
        Document doc = DocumentHelper.parse(is);
        is.close();
}


Instance 15

Class1340.checkTaskGraphServlet(JobID job,int jobTrackerInfoPort){
    URL url = new URL(jtURL + "/taskgraph?jobid=" + job.toString() + "&type=map");
    HttpURLConnection connection = (HttpURLConnection)url.openConnection();
    connection.setRequestMethod("GET");
    connection.connect();
    assertEquals(200, connection.getResponseCode());
    String contents = slurpContents(connection);
    if (contents.trim().length() > 0) {
      assertTrue("Bad contents for job " + job + ":\n" + contents,
          contents.contains("</svg>"));
    }
}


Instance 16

Class1450.connect(String urlStr){
        URL url = new URL(urlStr);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        conn.setRequestProperty("Connection", "Keep-Alive");
        conn.connect();
        System.out.println(conn.getResponseCode() + ":" + conn.getResponseMessage());
}


Instance 17

Class1490.isValidUrl(String name){
        if (isHttpUrl(name)) {
            String url = StringUtils.strip(name);
            try {
                HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
                connection.setRequestMethod("HEAD");
                connection.setConnectTimeout(ResourceLoader.TIMEOUT);
                connection.setReadTimeout(ResourceLoader.TIMEOUT);
                int responseCode = connection.getResponseCode();
                if (responseCode == 200) {
                    return true;
                }
            } catch (IOException e) {
                return false;
            }
        }
}


Instance 18

Class1270.awsApiCall(String url)#0{
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
            conn.setRequestMethod("GET");
            if (conn.getResponseCode() != 200)
                throw new ConfigurationException("Ec2Snitch was unable to execute the API call. Not an ec2 node?");
            int cl = conn.getContentLength();
            d = new DataInputStream((FilterInputStream) conn.getContent());
            d.readFully(b);
            return new String(b, StandardCharsets.UTF_8);
            FileUtils.close(d);
            conn.disconnect();
}


Instance 19

Class470.getResponse(String requestMethod,String path,UrlResponse response){
        URL url = new URL("http://localhost:" + PORT + path);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod(requestMethod);
        connection.connect();
        String res = IOUtils.toString(connection.getInputStream());
        response.status = connection.getResponseCode();
        response.headers = connection.getHeaderFields();
}


Instance 20

Class740.get(String uri)#0{
        URL u = new URL(uri);
        HttpURLConnection uc = (HttpURLConnection)u.openConnection();
        uc.setRequestMethod("GET");
        int status = uc.getResponseCode();
        String mediaType = uc.getContentType();
        InputStream in = uc.getInputStream();
}


Instance 21

Class420.getResponseAsStream(String url){
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setRequestProperty("User-Agent", UA_DEFAULT);
        conn.setConnectTimeout(6000);
        if (conn.getResponseCode() != 200)
            return null;
        InputStream in = conn.getInputStream();
}


Instance 22

Class1490.doInBackground(String... serverURL)#1{
                URL u = new URL(serverURL[0]);
                HttpURLConnection huc = (HttpURLConnection) u.openConnection();
                huc.setRequestMethod("GET"); // OR huc.setRequestMethod
                huc.connect();
                int code = huc.getResponseCode();
                if (code == 200) {
                    return true;
                }
}


Instance 23

Class320.delete(String murl){
    URL url = new URL(murl);
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setRequestMethod("DELETE");
    conn.setConnectTimeout(5000);
    if (conn.getResponseCode() == 204) {
      return true;
    }
}


Instance 24

Class1100.invalidRequestUri(final String path){
        final URL url = new URL(getBaseUri().toString() + path + "/resource{");
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        connection.setRequestProperty("Accept", "text/plain");
        connection.connect();
        assertEquals(400, connection.getResponseCode());
}


Instance 25

Class870.runClient(String urlStr){
        HttpURLConnection conn = (HttpURLConnection) new URL(urlStr).openConnection();
        conn.setRequestMethod("HEAD");
        int status = conn.getResponseCode();
        if (status != 200) {
            throw new RuntimeException("HEAD request doesn't return 200, but returns " + status);
        }
}


Instance 26

Class940.validateIcon(Service service,String serviceFilePath){
    String icon = service.getIcon();
    if (icon.startsWith("http")) {
      HttpURLConnection connection = (HttpURLConnection) new URL(icon).openConnection();
      connection.setRequestMethod("HEAD");
      Assert.assertEquals("The icon URL cannot establish a connection", HttpURLConnection.HTTP_OK,
          connection.getResponseCode());
      connection.disconnect();
    }else{
      File iconFile = new File(serviceFilePath, service.getIcon());
      Assert.assertTrue("Icon file not found in location: " + iconFile.getAbsolutePath(), iconFile.exists());
    }
}


Instance 27

Class880.testCallIndexPage(){
    URL url = new URL(this.baseUrl);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestProperty("Authorization", "bearer 74eccf5f-0995-4e1c-b08c-d05dd5a0f89b");
    connection.connect();
    assertEquals(200, connection.getResponseCode());
    String output = IOUtils.toString(connection.getInputStream());
    assertTrue(output.contains("emma.blunt"));
}


Instance 28

Class800.fileExistsURL(String url){
            HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
            connection.setRequestProperty(CACHE_CONTROL, "no-transform");
            connection.setRequestMethod("HEAD");
            int code = connection.getResponseCode();
}


Instance 29

Class1180.getResponseCode(String theme)#0{
            URL url = new URL(String.format("%s/VAADIN/themes/%s/favicon.ico",
                    getBaseURL(), theme));
            HttpURLConnection connection = (HttpURLConnection) url
                    .openConnection();
            connection.setRequestMethod("GET");
            connection.connect();
            return connection.getResponseCode();
}


Instance 30

Class610.isValid(String url)#0{
        URL u = new URL(url);
        HttpURLConnection huc = (HttpURLConnection) u.openConnection();
        huc.setRequestMethod("HEAD");
        huc.connect();
        isValid = huc.getResponseCode() == HttpURLConnection.HTTP_OK;
}


Instance 31

Class780.isPutIntoOven()#0{
            final URL url = new URL("https://www.google.com/search?q=potato");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.connect();
            int inOven = connection.getResponseCode();
}


Instance 32

Class60.testWrongContentType(){
        URL url = new URL(endpointAddress);
        HttpURLConnection urlConnection = (HttpURLConnection)url.openConnection();
        urlConnection.setReadTimeout(30000); // 30 seconds tops
        urlConnection.setConnectTimeout(30000); // 30 second tops
        urlConnection.addRequestProperty("Content-Type", "MissingSeparator");
        urlConnection.setRequestMethod("POST");
        assertEquals(415, urlConnection.getResponseCode());
}


Instance 33

Class340.exists(String URLName)#1{
                    (HttpURLConnection) new URL(URLName).openConnection();
            con.setRequestMethod("HEAD");
            con.setConnectTimeout(10000);
            return (con.getResponseCode() == HttpURLConnection.HTTP_OK);
}


Instance 34

Class1200.isExiste(String logoUrl){
      URL u = new URL(logoUrl);
      HttpURLConnection huc = (HttpURLConnection) u.openConnection();
      huc.setRequestMethod("GET"); // OR huc.setRequestMethod ("HEAD");
      huc.connect();
      code = huc.getResponseCode();
}


Instance 35

Class400.getURLcode(String htmlPage)#1{
            String url = "http://" + TestSuiteEnvironment.getServerAddress() + ":8080/explodedDeployment/"
            logger.infof("%s is the built URL.", url);
            HttpURLConnection urlConnection = (HttpURLConnection) new URL(url).openConnection();
            urlConnection.setRequestMethod("GET");
            urlConnection.connect();
            code = urlConnection.getResponseCode();
            logger.infof("Received response code of: " + code);
}


Instance 36

Class30.sendShutdown()#0{
        URL url = new URL(getServerUrl() + "/shutdown?token=" + _shutdownToken);
            HttpURLConnection connection = (HttpURLConnection)url.openConnection();
            connection.setRequestMethod("POST");
            connection.getResponseCode();
            LOG.info("Shutting down " + url + ": " + connection.getResponseCode() + " " + connection.getResponseMessage());
            LOG.debug("Not running");
}


Instance 37

Class1210.testUrlReachable(String strUtl){
        URL url = new URL(strUtl);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        conn.connect();
        int rc = conn.getResponseCode();
        assertEquals(HttpStatus.SC_OK, rc);
        conn.disconnect();
}


Instance 38

Class380.createLargeCacheFromNetwork(String type,String name,String url,ProgressCallback callback)#0{
    HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
    conn.setRequestMethod("GET");
    conn.setConnectTimeout(5000);
    createCacheFromStream(type, name, conn.getInputStream(), conn.getContentLength(), callback);
    conn.disconnect();
}


Instance 39

Class380.createCacheFromNetwork(String type,String name,String url,ProgressCallback callback)#0{
    HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
    conn.setRequestMethod("GET");
    conn.setConnectTimeout(5000);
    byte[] buf = readInputStream(conn.getInputStream(), conn.getContentLength(), callback);
    createCache(type, name, buf);
    conn.disconnect();
}


Instance 40

Class20.run()#0{
      URL url = new URL(HTTP_ADDR);
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
        InputStream is = conn.getInputStream();

        is.read();
      }
}


Instance 41

Class1010.testDeleteCustomer()#0{
        URL url = new URL(getURL() + "/" + 10);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("DELETE");
        int response = connection.getResponseCode();
        connection.disconnect();
        assertEquals(204, response);
}


Instance 42

Class410.retrieveSfdcSessionId()#1{
        refreshConsumerAndProvider();
        final URL loginUrl = new URL(getSfdcLoginUrl());
        request = (HttpURLConnection) loginUrl.openConnection();
        request.setRequestMethod("POST");
        consumer.sign(request);
        request.connect();
        final String loginResult = new Scanner(request.getInputStream()).useDelimiter("\\A").next();
}


Instance 43

Class970.testGetAddress()#0{
        URL url = new URL(getURL() + "/" + "2");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        connection.setRequestProperty("Accept", "application/xml");
        InputStream xml = connection.getInputStream();
}


Instance 44

Class940.proxyRequest(String uri)#0{
      connection = (HttpURLConnection) new URL(uri).openConnection();
      connection.setRequestMethod("GET");
      connection.setDoOutput(true);
      connection.setReadTimeout(10000);
      is = connection.getInputStream();
}


Instance 45

Class580.urlExists(String url){
            HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
            connection.setRequestMethod("HEAD");
            if (connection.getResponseCode() != 200) {
                throw new IOException("Couldn't find full-size image at " + url);
            }
}


Instance 46

Class140.testPutNoOperation()#1{
    URL url = new URL(TestJettyHelper.getJettyURL(),
                      MessageFormat.format("/webhdfs/v1/foo?user.name={0}", user));
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setDoInput(true);
    conn.setDoOutput(true);
    conn.setRequestMethod("PUT");
    Assert.assertEquals(conn.getResponseCode(), HttpURLConnection.HTTP_BAD_REQUEST);
}


Instance 47

Class640.verifyThatUrlIsHudson(Candidate target)#0{
            HttpURLConnection con = (HttpURLConnection) new URL(target.url).openConnection();
            con.connect();
            if (con.getResponseCode() == HttpURLConnection.HTTP_FORBIDDEN) {
                throw new RetryException(
                        "This jenkins server requires Authentication!.");
            }
            String v = con.getHeaderField("X-Hudson");
            if (v == null) {
                throw new RetryException("This URL doesn't look like Jenkins.");
            }
            throw new RetryException("Failed to connect to " + target.url, e);
}


Instance 48

Class480.testEmptyPost(){
        URL url = new URL(ADDRESS);
        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
        connection.setRequestMethod("POST");
        connection.setDoInput(true);
        int i = connection.getResponseCode();
        assertEquals(200, i);
        assertTrue(connection.getContentType().indexOf("xml") != -1);
}


Instance 49

Class970.verifyHelperForPostPutJSON(int id)#0{
        URL url = new URL(getURL() + "/" + id);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        connection.setRequestProperty("Accept", "application/json");
        InputStream inputStream = connection.getInputStream();
        StreamSource json = new StreamSource(inputStream);
}


Instance 50

Class1010.verifyHelperForPostPut(int id)#0{
        URL url = new URL(getURL() + "/" + id);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        connection.setRequestProperty("Accept", "application/xml");
        InputStream xml = connection.getInputStream();
}


Instance 51

Class560.callService(String endpoint,String signature){
        String query = rs.getCanonicalizedQueryString(attributes);
        URL url = new URL("https", endpoint, -1, "/?" + query);
        HttpURLConnection httpConnection = (HttpURLConnection) (url.openConnection());
        httpConnection.setRequestMethod(Constants.GET);
        httpConnection.setDoOutput(false);
        httpConnection.connect();
        return httpConnection.getInputStream();
}


Instance 52

Class280.getUrl(String url){
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
            conn.setRequestMethod("GET");
            conn.setReadTimeout(10000);
            conn.setConnectTimeout(10000);
            byte[] bytes = Utils.toByteArray(conn.getInputStream());
            return new String(bytes, StandardCharsets.UTF_8);
            conn.disconnect();
}


Instance 53

Class840.checkTaskGraphServlet(JobID job)#0{
    URL url = new URL(jtURL + "/taskgraph?jobid=" + job.toString() + "&type=map");
    HttpURLConnection connection = (HttpURLConnection)url.openConnection();
    connection.setRequestMethod("GET");
    connection.connect();
    assertEquals(200, connection.getResponseCode());
    String contents = slurpContents(connection);
    assertTrue("Bad contents for job " + job + ":\n" + contents,
      contents.contains("</svg>"));
}


Instance 54

Class170.downloadUrl(String urlString){
        URL url = new URL(urlString);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setReadTimeout(10000 /* milliseconds */);
        conn.setConnectTimeout(15000 /* milliseconds */);
        conn.setRequestMethod("GET");
        conn.setDoInput(true);
        conn.connect();
        InputStream stream = conn.getInputStream();
}


Instance 55

Class1300.testServletTestCase(){
        URL url = new URL(getServletURL() + "bla");
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        conn.connect();
        assertEquals(HttpURLConnection.HTTP_OK, conn.getResponseCode());
            new BufferedReader(new InputStreamReader(conn.getInputStream()));
        assertEquals("ping", reader.readLine());
        assertEquals(null, reader.readLine());
}


Instance 56

Class1390.getStatusCode(final String url){
      final URL u = new URL(url);
      final HttpURLConnection huc = (HttpURLConnection) u
          .openConnection();
      huc.setRequestMethod("GET"); // OR huc.setRequestMethod ("HEAD");
      huc.connect();
      final int code = huc.getResponseCode();
}


Instance 57

Class1080.performBackgroundOperation(MediaItem[] params)#0{
                            URL mediaUrl = new URL(mediaItem.getSource().toString());
                            HttpURLConnection connection = (HttpURLConnection) mediaUrl.openConnection();
                            connection.setRequestMethod("GET");
                            connection.connect();
                            responseCode = connection.getResponseCode();
}


Instance 58

Class330.performCoreAction(String action,String coreName,String moreParams)#1{
        URL coreActionURL = new URL(url);
        HttpURLConnection conn = (HttpURLConnection) coreActionURL.openConnection();
        conn.connect();
        int response = conn.getResponseCode();
        conn.disconnect();
        if (response != 200) {
            throw new RuntimeException("Core " + action + ": expected status 200 but got: " + response + ": "
                    + conn.getResponseMessage());
        }
}


Instance 59

Class830.exists()#0{
            HttpURLConnection con = (HttpURLConnection) new URL(path).openConnection();
            con.setRequestMethod("HEAD");
            int responseCode = con.getResponseCode();
}


Instance 60

Class1030.testGetMissingBackurl(){
        URL url = new URL(container.getServletURL("/"));
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        assertEquals(HttpServletResponse.SC_BAD_REQUEST, conn.getResponseCode());
        assertEquals("missing or invalid 'backurl' parameter", conn.getResponseMessage());
}


Instance 61

Class1000.testHeaderListMultipleHeaders()#2{
        final URL url = new URL(getBaseUri().toString() + "resource");
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        connection.setRequestProperty("hello", "world");
        connection.addRequestProperty("hello", "universe");
        connection.setDoOutput(false);
        connection.connect();
}


Instance 62

Class390.staticFileExists(String file){
            HttpURLConnection connection = (HttpURLConnection) new URL(getStaticCreeperhostLink(file)).openConnection();
            connection.setRequestProperty(CACHE_CONTROL, "no-transform");
            connection.setRequestMethod("HEAD");
            return (connection.getResponseCode() == 200);
}


Instance 63

Class1330.exists(String url)#0{
           HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection();
           con.setRequestMethod("HEAD");
           return con.getResponseCode() == HttpURLConnection.HTTP_OK;
}


Instance 64

Class790.testGetSuccess()#0{
        assertEquals(MessageFormat.format(loginPageTemplate, "", "", "http://foo:11000/oozie"), html);
        url = new URL(container.getServletURL("/") + "?backurl=http://foo:11000/oozie&username=foo");
        conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
        html = getHTML(conn);
}


Instance 65

Class790.testGetSuccess()#1{
        URL url = new URL(container.getServletURL("/") + "?backurl=http://foo:11000/oozie");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
        String html = getHTML(conn);
}


Instance 66

Class280.exists(final String path,final ProcessContext processContext)#2{
        final HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection();
        con.setRequestMethod("HEAD");
        return (con.getResponseCode() == HttpURLConnection.HTTP_OK);
}


Instance 67

Class590.call()#0{
            new URL("http://localhost:8088/ws/v1/cluster/delegation-token");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestProperty(RMWebServices.DELEGATION_TOKEN_HEADER,
          tokenString);
        setupConn(conn, "DELETE", null, null);
        InputStream response = conn.getInputStream();
        assertEquals(Status.OK.getStatusCode(), conn.getResponseCode());
}


Instance 68

Class20.main(String[] args)#1{
        while ((localPort = Redirect.listenPort) == -1) {
            Thread.sleep(1000);
        }
        URL url = new URL(page);
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        conn.connect();
        if (conn.getResponseCode() != 302) {
            throw new RuntimeException("Test failed. Should get RespCode: 302. Got:"+conn.getResponseCode());
        }
}


Instance 69

Class1140.getUrl(String path,BBuffer out){
        URL url = new URL(path);
            (HttpURLConnection) url.openConnection();
        connection.setReadTimeout(10000);
        connection.connect();
        int rc = connection.getResponseCode();
        InputStream is = connection.getInputStream();
        BufferedInputStream bis = new BufferedInputStream(is);
        while((rd = bis.read(buf)) > 0) {
            out.append(buf, 0, rd);
        }
}


Instance 70

Class430.getResponseCode(String URL){
    URL testUrl = new URL(URL);
    conn = (HttpURLConnection) testUrl.openConnection();
    conn.setConnectTimeout(connectionTimeoutInMS);
    conn.setReadTimeout(socketOperationsTimeoutInMS);
    conn.setRequestMethod("HEAD");
    int responseCode = conn.getResponseCode();
}


Instance 71

Class120.ping(String url,int timeout){
            HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
            connection.setConnectTimeout(timeout);
            connection.setReadTimeout(timeout);
            connection.setRequestMethod("GET");
            int responseCode = connection.getResponseCode();
}


Instance 72

Class1000.testInvalidContentTypeHeader()#1{
        final URL url = new URL(getBaseUri().toString() + "ContentType");
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-Type", "^^^");
        connection.setDoOutput(true);
        connection.connect();
        final OutputStream outputStream = connection.getOutputStream();
}


Instance 73

Class570.createConnection(){
    URL url = new URL(PROFILE_URL);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Content-Type", "application/json");
    connection.setConnectTimeout(15000);
    connection.setReadTimeout(15000);
    connection.setUseCaches(false);
    connection.setDoInput(true);
    connection.setDoOutput(true);
}


Instance 74

Class40.httpGet(String api)#0{
               url = new URL(api);
               conn = (HttpURLConnection) url.openConnection();
               conn.setRequestMethod("GET");
               rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
               while ((line = rd.readLine()) != null) {
                  result += line;
               }
               rd.close();
}


Instance 75

Class1380.getFromHTTP(String url){
    URL u = new URL(url);
    LOG.info("Accessing URL "+url+" as URL: "+u);
    HttpURLConnection connection = (HttpURLConnection) u.openConnection();
    connection.setConnectTimeout(100000);
    connection.connect();
    if(connection.getResponseCode() >= 400) {
      // error!
      LOG.warn("HTTP Response code when connecting to {} was {}", url, connection.getResponseCode());
      is = connection.getErrorStream();
    } else {
      is = connection.getInputStream();
    }
    return IOUtils.toString(is, connection.getContentEncoding() != null ? connection.getContentEncoding() : "UTF-8");
}


Instance 76

Class970.testGetCollectionOfObjects()#1{
        URL url = new URL(getURL() + "/" + "findCustomerByCity" + "/"
                + "Ottawa");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        connection.setRequestProperty("Accept", "application/xml");
        InputStream xml = connection.getInputStream();
}


Instance 77

Class1170.getRedirectURL(String url){
      HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
      conn.setInstanceFollowRedirects(false);
      if(conn.getResponseCode() == HttpServletResponse.SC_TEMPORARY_REDIRECT)
        redirectUrl = conn.getHeaderField("Location");
}


Instance 78

Class1090.getDocumentFromUrl(String url)#0{
    HttpURLConnection urlConnection = (HttpURLConnection) new URL(url)
        .openConnection();
    urlConnection.setRequestMethod("GET");
    urlConnection.setDoOutput(true);
    urlConnection.setDoInput(true);
    urlConnection.connect();
}


Instance 79

Class960.testPutNoOperation()#0{
    URL url = new URL(getJettyURL(), MessageFormat.format("/foo?user.name={0}", user));
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setDoInput(true);
    conn.setDoOutput(true);
    conn.setRequestMethod("PUT");
    Assert.assertEquals(conn.getResponseCode(), HttpURLConnection.HTTP_BAD_REQUEST);
}


Instance 80

Class1510.isInternetAvailable(){
      final URL url = new URL("http://www.orientechnologies.com");
      final HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
      urlConn.setConnectTimeout(1000 * 10); // mTimeout is in seconds
      urlConn.connect();
      if (urlConn.getResponseCode() == HttpURLConnection.HTTP_OK) {
        return true;
      }
}


Instance 81

Class800.assertClientSuppliedCondition(MockResponse seed,String conditionName,String conditionValue)#0{
        server.enqueue(new MockResponse().setResponseCode(HttpURLConnection.HTTP_NOT_MODIFIED));
        server.play();
        URL url = server.getUrl("/");
        assertEquals("A", readAscii(url.openConnection()));
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.addRequestProperty(conditionName, conditionValue);
        assertEquals(HttpURLConnection.HTTP_NOT_MODIFIED, connection.getResponseCode());
        assertEquals("", readAscii(connection));
        return server.takeRequest();
}


Instance 82

Class830.createCacheFromNetwork(String type,String name,String url){
    HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
    conn.setRequestMethod("GET");
    conn.setConnectTimeout(5000);
    byte[] buf = readInputStream(conn.getInputStream());
    createCache(type, name, buf);
}


Instance 83

Class270.createConnection(final String uri,final String authValue){
        final URL url = new URL(uri);
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setConnectTimeout(0);
        connection.setReadTimeout(0);
        connection.setRequestMethod("GET");
        connection.setRequestProperty("Authorization", authValue);
        connection.setDoOutput(true);
}


Instance 84

Class850.sendFileNotification(String serverBase,String fileName){
        URL url = new URL(serverBase + NOTIFICATION_PATH + fileName);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        conn.setDoOutput(true);
        BufferedReader reader = new BufferedReader(new InputStreamReader(
                conn.getInputStream()));
        while ((line = reader.readLine()) != null) {
            log.info(line);
        }
        reader.close();
}


Instance 85

Class190.testBlobRangeEndGreaterThanContentSize(@ArquillianResource URL url){
        URL pageUrl = new URL(url, "serveblob?name=testrangeend.txt&mimeType=text/plain&contents=" + CONTENTS + "&blobRange=bytes=2-1000");
        HttpURLConnection connection = (HttpURLConnection) pageUrl.openConnection();
            String response = readFullyAndClose(connection.getInputStream());
            assertEquals(PARTIAL_CONTENT, connection.getResponseCode());
            assertEquals("bytes 2-25/26", connection.getHeaderField("Content-Range"));
            assertEquals(CONTENTS.substring(2), response);
            connection.disconnect();
}


Instance 86

Class1390.download(String urlAsString){
            URL url = new URL(urlAsString);
            HttpURLConnection hConn = (HttpURLConnection) url.openConnection(Proxy.NO_PROXY);
            hConn.setRequestProperty("User-Agent", "Mozilla/5.0 (X11; Linux i686; rv:7.0.1) Gecko/20100101 Firefox/7.0.1");
            hConn.addRequestProperty("Referer", "http://jetsli.de/crawler");
            hConn.setConnectTimeout(2000);
            hConn.setReadTimeout(2000);
            InputStream is = hConn.getInputStream();
            if ("gzip".equals(hConn.getContentEncoding()))
                is = new GZIPInputStream(is);
            return getInputStream(is);
}


Instance 87

Class540.pingURL(String urlLoc)#0{
      final URL url = new URL(urlLoc);
      final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.162 Safari/535.19");
      conn.setConnectTimeout(5000);
      int response = conn.getResponseCode();
}


Instance 88

Class50.testMbw(String param){
        final TestWebServer testWebServer = createTestWebServer(new MyResource());
        int port = testWebServer.getPort();
        URL serverURL = new URL("http://localhost:" + port + "/foo/bar?name=" + param);
        HttpURLConnection connection = (HttpURLConnection) serverURL.openConnection();
        connection.setRequestMethod("GET");
        connection.addRequestProperty("Accept", "application/json, */*; q=.2");
        BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
        String line = br.readLine();
        Assert.assertEquals("{\"name\":\""+param+"\"}", line);
        testWebServer.stop();
}


Instance 89

Class550.doTestForbiddenMethods(int port,String method)#1{
    URL url = new URL("http://0.0.0.0:" + String.valueOf(port) + "/metrics");
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setRequestMethod(method);
    Assert.assertEquals(HttpServletResponse.SC_FORBIDDEN,
      conn.getResponseCode());
}


Instance 90

Class1300.testJetty()#1{
    URL url = new URL(getJettyURL(), "/bar");
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    Assert.assertEquals(conn.getResponseCode(), HttpURLConnection.HTTP_OK);
    BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
    Assert.assertEquals(reader.readLine(), "foo");
    reader.close();
}


Instance 91

Class1200.testPostInvalidUsernamePassword()#0{
        URL url = new URL(container.getServletURL("/") + "?backurl=http://foo:11000/oozie&username=foo&password=bar");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
        String html = getHTML(conn);
}


Instance 92

Class190.put(String uri){
        URL u = new URL(uri);
        HttpURLConnection uc = (HttpURLConnection)u.openConnection();
        uc.setRequestMethod("PUT");
        int status = uc.getResponseCode();
}


Instance 93

Class510.shouldAccessInitialPage(){
        URL url = new URL("http://localhost:8090/modeshape-explorer");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        int code = connection.getResponseCode();
        assertEquals(200, code);
}


Instance 94

Class740.put(String uri,String mediaType,InputStream in)#1{
        URL u = new URL(uri);
        HttpURLConnection uc = (HttpURLConnection)u.openConnection();
        uc.setRequestMethod("PUT");
        uc.setRequestProperty("Content-Type", mediaType);        
        uc.setDoOutput(true);
        OutputStream out = uc.getOutputStream();
}


Instance 95

Class150.httpPost(WebServer webServer,String path,String body)#0{
        URL url = new URL(webServer.getUri().toURL(), path);
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        urlConnection.setRequestMethod("POST");
        urlConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        urlConnection.setDoOutput(true);
}


Instance 96

Class180.main(String[] args)#1{
            server = new HttpServer (new SetChunkedStreamingMode(), 1, 10, 0);
            URL url = new URL ("http://127.0.0.1:"+server.getLocalPort()+"/");
            HttpURLConnection urlc = (HttpURLConnection)url.openConnection();
            urlc.setChunkedStreamingMode (0);
            urlc.setRequestMethod("POST");
            urlc.setDoOutput(true);
            InputStream is = urlc.getInputStream();
}


Instance 97

Class370.testPostSuccess(){
        URL url = new URL(container.getServletURL("/") + "?backurl=about:blank&username=foo&password=foo");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        assertEquals(HttpServletResponse.SC_FOUND, conn.getResponseCode());
        String cookies = getCookies(conn);
        String username = getUsernameFromCookies(cookies);
        assertEquals("foo", username);
}


Instance 98

Class730.httpRequest(String urlStr,String requestType)#1{
            URL url = new URL(urlStr);
            HttpURLConnection con = (HttpURLConnection) url.openConnection();
            con.setRequestMethod(requestType);
            return con.getResponseCode();
}


Instance 99

Class1440.postSeamReload(){
        String loopbackURL = Framework.getProperty("nuxeo.loopback.url");
        URL location = new URL(loopbackURL + "/restAPI/seamReload");
        HttpURLConnection uc = (HttpURLConnection) location.openConnection();
        uc.setRequestMethod("POST");
        return uc.getResponseCode() == HttpURLConnection.HTTP_OK;
}


Instance 100

Class520.createRequest(String endpointUrl){
    HttpURLConnection connection = (HttpURLConnection) new URL(endpointUrl).openConnection();
    connection.setRequestMethod("GET");
    connection.setAllowUserInteraction(false);
    connection.setRequestProperty("Content-Length", "0");
    return new HttpURLConnectionRequestAdapter(connection);
}


Instance 101

Class1200.createRequest(String endpointUrl){
        HttpURLConnection connection = (HttpURLConnection) new URL(endpointUrl).openConnection();
        connection.setRequestMethod("POST");
        connection.setAllowUserInteraction(false);
        connection.setRequestProperty("Content-Length", "0");
        return new HttpURLConnectionRequestAdapter(connection);
}


Instance 102

Class250.testHeaders(){
        URL url = new URL("http", "localhost", HTTP_SERVER_PORT, "/");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.addRequestProperty("X-SetHeaders", "Location: /abcd|X-Dummy: none");
        conn.connect();
        assertEquals(200, conn.getResponseCode());
        assertEquals("OK", conn.getResponseMessage());
        assertEquals("/abcd",conn.getHeaderField("Location"));
        assertEquals("none",conn.getHeaderField("X-Dummy"));
}


Instance 103

Class730.isLocalCommunityServerRunning()#0{
            HttpURLConnection conn = (HttpURLConnection) new URL("http://" + TEST_COMMUNITY_SERVER
                    + "/community").openConnection();
            if (conn.getResponseCode() == HttpServletResponse.SC_BAD_REQUEST) {
                return true;
            }
            conn.disconnect();
}


Instance 104

Class1100.testPing(){
    final URL url = new URL("http://"+ SERVER_HOST + ":" + webServerPort + "/ping");
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    Assert.assertEquals(HttpURLConnection.HTTP_OK, conn.getResponseCode());
    String response = IOUtils.toString(conn.getInputStream());
    Assert.assertEquals("pong\n", response);
}


Instance 105

Class740.downloadAndUpdate(List<String> downloadList){
        for (String filename : downloadList) {
            URL url = new URL(URL_PREFIX + filename);
            HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
            urlConnection.connect();

            if (urlConnection.getResponseCode() == HttpURLConnection.HTTP_OK) {
                FileHelper.downloadFile(filename, urlConnection);
            } else {
                System.out.println(filename + " error status : " + urlConnection.getResponseMessage());
            }
        }
}


Instance 106

Class1080.execute()#1{
        if (url != null) {
            try {
                URL url = new URL(this.url);
                HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
                if (urlConn.getResponseCode() != HttpURLConnection.HTTP_OK) {
                    handleRetry();
                }
            }
            catch (IOException ex) {
                handleRetry();
            }
        }
}


Instance 107

Class40.httpGet(String urlString)#0{
        url = new URL(urlString);
        conn = (HttpURLConnection)url.openConnection();
        conn.setRequestMethod("GET");
        br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        while ((line = br.readLine()) != null) {
          doc += line;
        }
        br.close();
}


Instance 108

Class1510.testSuccess()#0{
    HttpURLConnection c = (HttpURLConnection)new URL("http://localhost:" + PORT + "/foobar").openConnection();
    assertEquals(c.getResponseCode(), RestStatus.OK);
    InputStream in = c.getInputStream();
}


Instance 109

Class690.testGet(@ArquillianResource URL url)#1{
        URL testURL = new URL(url, "simple");
        HttpURLConnection conn = (HttpURLConnection) testURL.openConnection();
        conn.setRequestMethod("GET");
        conn.setDoInput(true);
        conn.setDoOutput(false);
        conn.connect();
}


Instance 110

Class730.testDoPost()#1{
        url=new URL("http://127.0.0.1:"+connector.getLocalPort()+"/test/dump/info?query=foo");
        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
        connection.setRequestMethod("POST");
        connection.setDoOutput(true);
        connection.setDoInput(true);
        connection.addRequestProperty(HttpHeaders.CONTENT_LENGTH, "10");
}


Instance 111

Class1430.getUrlBytes(String urlToRead)#0{
            URL url = new URL(urlToRead);
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            InputStream in = conn.getInputStream();
                return IOUtils.toByteArray(in);
                in.close();
}


Instance 112

Class630.httpPostCompressed(WebServer webServer,String path,String body)#2{
        URL url = new URL(webServer.getUri().toURL(), path);
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        urlConnection.addRequestProperty("Content-Encoding", "gzip");
        urlConnection.setRequestMethod("POST");
        urlConnection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        urlConnection.setDoOutput(true);
}


Instance 113

Class740.sendMessageByHttp(int port,String topic,int partition,byte[] data)#0{
        URL url = new URL(String.format("http://127.0.0.1:%s/",port));
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("partition",""+partition);
        conn.setDoInput(true);
        conn.setDoOutput(true);
        conn.getOutputStream().write(data);
        conn.getOutputStream().flush();
        conn.getOutputStream().close();
}


Instance 114

Class600.checkURLisReachable(String url)#0{
            HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
            connection.setConnectTimeout(timeout);
            connection.setReadTimeout(timeout);
            int responseCode = connection.getResponseCode();
            if (200 <= responseCode && responseCode <= 399) {
                return null;
            }
            return String.format("The update server is unreachable: The attempt to connect to the update server has resulted in %d code.", responseCode);
}


Instance 115

Class660.getConnection(String urlString,String username,String password)#0{
    URL url = new URL(urlString);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod("POST");
    connection.setReadTimeout(1000 * 60 * 60);
    connection.setConnectTimeout(1000 * 10);
}


Instance 116

Class80.testOnlyPartOfBlobServedWhenResponseContainsBlobRangeHeader(@ArquillianResource URL url){
        URL pageUrl = new URL(url, "serveblob?name=testrange.txt&mimeType=text/plain&contents=" + CONTENTS + "&blobRange=bytes=2-5");
        HttpURLConnection connection = (HttpURLConnection) pageUrl.openConnection();
            String response = readFullyAndClose(connection.getInputStream());
            assertEquals(PARTIAL_CONTENT, connection.getResponseCode());
            assertEquals("bytes 2-5/26", connection.getHeaderField("Content-Range"));
            assertEquals(CONTENTS.substring(2, 5 + 1), response);
            assertNull("header should have been removed from response", connection.getHeaderField("X-AppEngine-BlobRange"));
            connection.disconnect();
}


Instance 117

Class320.createConnection(int page){
        URL url = new URL(PROFILE_URL+page);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("POST");
        connection.setRequestProperty("Content-Type", "application/json");
        connection.setUseCaches(false);
        connection.setDoInput(true);
        connection.setDoOutput(true);
}


Instance 118

Class850.perform()#0{
                    final HttpURLConnection conn = (HttpURLConnection)new URL(baseURL, "auth").openConnection();
                    conn.setRequestProperty("Referer", "http:/geekseek.com");
                    conn.setInstanceFollowRedirects(false);
                    Assert.assertEquals(302, conn.getResponseCode());
                    Assert.assertEquals(conn.getHeaderField("Location"), "http:/geekseek.com");
}


Instance 119

Class1050.waitForServerToBack()#0{
                HttpURLConnection con = (HttpURLConnection)new URL(hudsonUrl,"tcpSlaveAgentListener/").openConnection();
                con.connect();
                if(con.getResponseCode()==200)
                    return;
}


Instance 120

Class750.sendAction(String action){
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        if (conn.getResponseCode() != HttpServletResponse.SC_OK) {
            throw new IOException("Bad status: " + conn.getResponseCode() + " for action: "
                    + action);
        }
}


Instance 121

Class140.httpClientTest()#0{
            URL url = new URL("http://www.google.com");
            urlConnection = (HttpURLConnection) url.openConnection();
            if (urlConnection.getResponseCode() == 200) {
                mHttpClientTestResult = "Pass";
            } else {
                mHttpClientTestResult = "Fail: Code: " + urlConnection.getResponseMessage();
            }
}


Instance 122

Class1200.testStatus(){
        URL url = new URL("http", "localhost", HTTP_SERVER_PORT, "/");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.addRequestProperty("X-ResponseStatus", "302 Temporary Redirect");
        conn.connect();
        assertEquals(302, conn.getResponseCode());
        assertEquals("Temporary Redirect", conn.getResponseMessage());
}


Instance 123

Class960.testHdfsAccess()#0{
    URL url = new URL(getJettyURL(), MessageFormat.format("/?user.name={0}&op=list", user));
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    Assert.assertEquals(conn.getResponseCode(), HttpURLConnection.HTTP_OK);
    BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
    reader.readLine();
    reader.close();
}


Instance 124

Class1080.testGetAuthorizationUrl()#0{
      assertNotNullOrEmpty(String.format(RESOURCE_MISSING_MESSAGE, "Test callback URL."), TestConstants.TEST_CALLBACK_URL);
    String authorizationUrl = service.getAuthorizationUrl(TestConstants.TEST_CALLBACK_URL);
    assertNotNullOrEmpty("Authorization URL should not be null.", authorizationUrl);
            URL               url     = new URL(authorizationUrl);
            HttpURLConnection request = (HttpURLConnection) url.openConnection();
      if (request.getResponseCode() != HttpURLConnection.HTTP_OK) {
        fail(convertStreamToString(request.getErrorStream()));
      }
}


Instance 125

Class1390.testNotAuthenticated()#2{
    auth.start();
      URL url = new URL(auth.getBaseURL());
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.connect();
      Assert.assertEquals(HttpURLConnection.HTTP_UNAUTHORIZED, conn.getResponseCode());
      Assert.assertTrue(conn.getHeaderField(KerberosAuthenticator.WWW_AUTHENTICATE) != null);
      auth.stop();
}


Instance 126

Class250.testGlobFilter()#1{
    URL url = new URL(getJettyURL(), MessageFormat.format("/?user.name={0}&op=list&filter=f*", user));
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    Assert.assertEquals(conn.getResponseCode(), HttpURLConnection.HTTP_OK);
    BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
    reader.readLine();
    reader.close();
}


Instance 127

Class140.testHdfsAccess()#0{
    URL url = new URL(TestJettyHelper.getJettyURL(),
                      MessageFormat.format("/webhdfs/v1/?user.name={0}&op=liststatus", user));
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    Assert.assertEquals(conn.getResponseCode(), HttpURLConnection.HTTP_OK);
    BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
    reader.readLine();
    reader.close();
}


Instance 128

Class1400.connect(){
      URL url = new URL(URL);
      HttpURLConnection conn = (HttpURLConnection) url.openConnection(); //sink, leak
        conn.setRequestMethod("GET");
        conn.setDoInput(true);
        conn.connect();
}


Instance 129

Class20.ga(final Map<String,Object> prop)#1{
        final String ua="User-Agent: Java/"+prop.get("java.version")
                + " (" +prop.get("os.name")
                + " )" + "batoo/"+prop.get("batoojpa.build");
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();
        con.setRequestProperty("User-Agent", ua);
        return con.getResponseCode();
}


Instance 130

Class720.get(final String path){
        final InetSocketAddress address = new InetSocketAddress(getPort());
        final URL url = new URL("http://" + address.getHostName() + ":" + address.getPort() + path);
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        connection.connect();
}


Instance 131

Class430.executeHttpPost(InputStream data,String url)#0{
    HttpURLConnection http = (HttpURLConnection) new URL(url).openConnection();
    http.setChunkedStreamingMode(1024 * 1024);
    http.setRequestMethod("POST");
    http.setRequestProperty("Content-Type", "application/octet-stream");
    http.setDoOutput(true);
    IOUtils.copy(data, http.getOutputStream());
    http.getOutputStream().flush();
    http.getOutputStream().close();
}


Instance 132

Class900.hasOsmTileETag(String eTag){
            url = new URL(tile.getUrl());
            HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
            prepareHttpUrlConnection(urlConn);
            urlConn.setRequestMethod("HEAD");
            urlConn.setReadTimeout(30000); // 30 seconds read timeout
            String osmETag = urlConn.getHeaderField("ETag");
            if (osmETag == null)
                return true;
            return (osmETag.equals(eTag));
}


Instance 133

Class350.post(String urlString,String xmlRequest)#0{
        URL url = new URL(urlString);
        HttpURLConnection  conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Type", "text/xml");
        conn.setDoOutput(true);
        OutputStreamWriter wr = new OutputStreamWriter(conn.getOutputStream(), UTF8.UTF8);
        wr.write(xmlRequest);
        wr.flush();
}


Instance 134

Class540.testAnonymousAllowed(){
    setAuthenticationHandlerConfig(getAuthenticationHandlerConfiguration(true));
    start();
      URL url = new URL(getBaseURL());
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.connect();
      assertEquals(HttpURLConnection.HTTP_OK, conn.getResponseCode());
      stop();
}


Instance 135

Class1450.shouldAllow404ReturnCodeOnAcceptHeaderRequests(){
        HttpURLConnection con = (HttpURLConnection)new URL(base, "app/MISSING_RESOURCES").openConnection();
        con.setRequestProperty("Accept", "application/vnd.ced+json");
        int response = con.getResponseCode();
        con.disconnect();
        Assert.assertEquals(404, response);
}


Instance 136

Class190.simpleGetRequest(String url)#0{
      connection = (HttpURLConnection) new URL(url).openConnection();
      prepareConnection(connection, null);
            return parseResponseWrapper(connection);
      if (connection != null) {
        try {
          return new DfeResponse<T>(connection.getResponseCode(), connection.getResponseMessage(), e);
        } catch (IOException ignored) {
        }
      }
}


Instance 137

Class1180.call(WorkflowStore store)#0{
        if (url != null) {
            try {
                URL url = new URL(this.url);
                HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
                if (urlConn.getResponseCode() != HttpURLConnection.HTTP_OK) {
                    handleRetry();
                }
            }
            catch (IOException ex) {
                handleRetry();
            }
        }
}


Instance 138

Class250.cacheTile(String aURL)#0{
            URL url = new URL(aURL);
            HttpURLConnection uc = (HttpURLConnection) url.openConnection();
            int status = uc.getResponseCode();
            if (status == 200) {
                int contentLength = uc.getContentLength();

                if (contentLength == -1) {
                    // LOGGER.debug("Tile '{}' content length: -1", aURL);
                }
            } else if (LOGGER.isErrorEnabled()) {
                LOGGER.error("Problem caching '{}' tile (status: {})", aURL, status);
            }
}


Instance 139

Class630.call()#0{
      URL url = new URL(this.url);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestProperty("User-Agent", userAgent);
        conn.setConnectTimeout(15000);
        conn.setReadTimeout(15000);
        return new VerificationResponseImpl(conn.getInputStream());
}


Instance 140

Class310.getHttpStatusCode(String urlstring,String userName){
    URL url = new URL(urlstring + "?user.name=" + userName);
    HttpURLConnection connection = (HttpURLConnection)url.openConnection();
    connection.connect();
    return connection.getResponseCode();
}


Instance 141

Class1200.callPingBack()#0{
            String pingServerURL = defaultPingBackUrl.concat("-ent");
                url = new URL(pingServerURL);
                urlConn = (HttpURLConnection) url.openConnection();
                urlConn.connect();
                return (HttpURLConnection.HTTP_NOT_FOUND != urlConn.getResponseCode());
}


Instance 142

Class440.testPathParam()#0{
    assertNotNull(url);
    URL url = new URL(AbstractResponseViewActionTestCase.url);
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    conn.setInstanceFollowRedirects(false);
    conn.connect();
    assertEquals(302, conn.getResponseCode());
    Map<String, String> headers = Tools.responseHeaders(conn);
    String redirect = headers.get("Location");
    driver.get(redirect);
}


Instance 143

Class0.prepareRequest(){
        HttpURLConnection conn = (HttpURLConnection) new URL(URL).openConnection();
        conn.setRequestMethod(HTTP_POST_METHOD);
        conn.setRequestProperty("Content-Type", CONTENT_TYPE);
        request = new HttpURLConnectionRequestAdapter(conn);
}


Instance 144

Class160.doRequest(OAuthClientRequest req){
        URL url = new URL(req.getLocationUri());
        HttpURLConnection c = (HttpURLConnection)url.openConnection();
        c.setInstanceFollowRedirects(true);
        c.connect();
        c.getResponseCode();
}


Instance 145

Class0.testPathParam()#0{
    assertNotNull(url);
    URL url = new URL(AbstractResponseViewNoRedirectActionTestCase.url);
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    conn.setInstanceFollowRedirects(false);
    conn.connect();
    assertEquals(200, conn.getResponseCode());
    assertEquals("bar_value", bar);
}


Instance 146

Class1100.perform()#0{
                    final HttpURLConnection conn = (HttpURLConnection)new URL(baseURL, "auth").openConnection();
                    conn.setInstanceFollowRedirects(false);
                    Assert.assertEquals(400, conn.getResponseCode());
}


Instance 147

Class690.execute()#0{
                AuthorizationRequest authorizationRequest = (AuthorizationRequest) request;
                String locationURL = authorizationRequest.getLocation() + "?" + authorizationRequest.asQueryParams();
                URL url = new URL(locationURL);
                HttpURLConnection c = (HttpURLConnection) url.openConnection();
                c.setInstanceFollowRedirects(true);
                c.connect();
                response.setStatusCode(c.getResponseCode());
                response.setResponseMessage(c.getResponseMessage());
}


Instance 148

Class510.createConnection(){
        URL url = new URL(domainApiUrl);
        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
        connection.setDoOutput(true);
        connection.setRequestMethod("POST");
        connection.addRequestProperty("Accept", APPLICATION_DMR_ENCODED);
        connection.setRequestProperty("Content-Type", APPLICATION_DMR_ENCODED);
}


Instance 149

Class400.getConnection(String query){
        postURL = new URL(query);
        HttpURLConnection conn = (HttpURLConnection) postURL.openConnection();
        conn.setRequestMethod("POST");
        conn.setDoInput(true);
        conn.setDoOutput(true);
        conn.setUseCaches(false);
        conn.setAllowUserInteraction(false);
}


Instance 150

Class490.getConnection(String urlString,String username,String password)#0{
      URL url = new URL(urlString);
      HttpURLConnection connection = (HttpURLConnection) url.openConnection();
      connection.setRequestMethod("DELETE");
      connection.setReadTimeout(1000 * 60 * 60);
      connection.setConnectTimeout(1000 * 10);
}


Instance 151

Class550.connect(String url)#1{
        connection = (HttpURLConnection) new URL(url).openConnection();
        connection.setRequestMethod("GET");
        connection.setUseCaches(false);
}


Instance 152

Class690.execute(ClientRequest request)#0{
    String uri = request.getUri();
    String httpMethod = request.getHttpMethod();
    HttpURLConnection connection = (HttpURLConnection) new URL(uri).openConnection();
    connection.setRequestMethod(httpMethod);
}


Instance 153

Class490.get(String request,IOUtils.LineRead callback,int timeout)#1{
        URL url = new URL(request);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setInstanceFollowRedirects(false);
            connection.setRequestMethod("GET");
            connection.setUseCaches(false);
}


Instance 154

Class760.get(String urlS){
        URL url = new URL(urlS);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("GET");
        return getResponseBody(connection);
}


Instance 155

Class140.getBitmapFromURL(String source){
            URL url = new URL(source);
            HttpURLConnection httpConnection = (HttpURLConnection) url.openConnection();
            httpConnection.setDoInput(true);
            httpConnection.connect();
            InputStream inputStream = httpConnection.getInputStream();
            return BitmapFactory.decodeStream(inputStream);
            Log.e(TAG, "getBitmapFromUrl: " + source, e);
}


Instance 156

Class1460.getBitmapFromURL(String src)#0{
      URL url = new URL(src);
      HttpURLConnection connection = (HttpURLConnection) url
          .openConnection();
      connection.setDoInput(true);
      connection.connect();
      InputStream input = connection.getInputStream();
      return BitmapFactory.decodeStream(input);
}


Instance 157

Class620.testNoCacheHeader(){
    URL url = new URL(baseUrl, "/echo?a=b&c=d");
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    assertEquals(HttpURLConnection.HTTP_OK, conn.getResponseCode());
    assertEquals("no-cache", conn.getHeaderField("Cache-Control"));
    assertEquals("no-cache", conn.getHeaderField("Pragma"));
    assertNotNull(conn.getHeaderField("Expires"));
    assertNotNull(conn.getHeaderField("Date"));
    assertEquals(conn.getHeaderField("Expires"), conn.getHeaderField("Date"));
}


Instance 158

Class1050.checkThatWeHaveLocalGeoServer()#0{
        URL url = new URL( getCapabilities );
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            int responseCode = connection.getResponseCode();
            if( responseCode == 200 ){
                localGeoserver = true;
            }
}


Instance 159

Class1090.init()#1{
      URL url = new URL(urlstr);
      HttpURLConnection connection = (HttpURLConnection) url
          .openConnection();
      connection.setConnectTimeout(30000);
      connection.setRequestMethod("GET");
      fileSize = connection.getContentLength();
}


Instance 160

Class540.testNotAuthenticated(){
    setAuthenticationHandlerConfig(getAuthenticationHandlerConfiguration());
    start();
      URL url = new URL(getBaseURL());
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.connect();
      assertEquals(HttpURLConnection.HTTP_UNAUTHORIZED, conn.getResponseCode());
      assertTrue(conn.getHeaderField(KerberosAuthenticator.WWW_AUTHENTICATE) != null);
      stop();
}


Instance 161

Class760.execute(String method,String urlS,String body)#0{
        URL url = new URL(urlS);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod(method);
}


Instance 162

Class610.makePreSignedRequest(String method,String preSignedUrl,Map headers){
            URL url = new URL(preSignedUrl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod(method);
            addHeaders(connection, headers);
}


Instance 163

Class1380.loadInBackground()#0{
        final URL url = new URL(mUrl);
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setDoInput(true);
        connection.connect();
        final InputStream input = connection.getInputStream();
        final Bitmap myBitmap = BitmapFactory.decodeStream(input);
}


Instance 164

Class910.testResponseLength(){
        URL url = new URL("http", "localhost", HTTP_SERVER_PORT, "/");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.addRequestProperty("X-ResponseLength", "10");
        conn.connect();
        final InputStream inputStream = conn.getInputStream();
        assertEquals(10, IOUtils.toByteArray(inputStream).length);
        inputStream.close();
}


Instance 165

Class80.googleIsReachable()#0{
            URL url = new URL("http://www.google.com");
                    (HttpURLConnection) url.openConnection();
            httpURLConnection.connect();
            return HttpURLConnection.HTTP_OK == httpURLConnection
                    .getResponseCode();
}


Instance 166

Class1390.testAnonymousDisallowed()#0{
    auth.start();
      URL url = new URL(auth.getBaseURL());
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.connect();
      Assert.assertEquals(HttpURLConnection.HTTP_UNAUTHORIZED, conn.getResponseCode());
      Assert.assertTrue(conn.getHeaderFields().containsKey("WWW-Authenticate"));
      Assert.assertEquals("Authentication required", conn.getResponseMessage());
      auth.stop();
}


Instance 167

Class990.doPost(String request)#2{
    URL url = new URL("http://localhost:8080/exist/rest" + XmldbURI.ROOT_COLLECTION);
    HttpURLConnection connect = (HttpURLConnection) url.openConnection();
    connect.setRequestMethod("POST");
    connect.setDoOutput(true);
    OutputStream os = connect.getOutputStream();
}


Instance 168

Class620.test8(String u)#0{
        URL url = new URL (u);
        HttpURLConnection urlc = (HttpURLConnection)url.openConnection ();
        urlc.setFixedLengthStreamingMode (0);
        urlc.setDoOutput(true);
        urlc.setRequestMethod ("POST");
        OutputStream os = urlc.getOutputStream ();
        os.close();
}


Instance 169

Class1170.getVersion()#1{
            HttpURLConnection con = (HttpURLConnection) new URL(URL).openConnection();
            con.setDoOutput(true);
            con.setRequestMethod("POST");
}


Instance 170

Class10.httpCall(String url,String method,String params)#4{
    HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
    connection.setRequestMethod(method);
    connection.setDoOutput(true);
}


Instance 171

Class1390.testAnonymousAllowed()#0{
    auth.start();
      URL url = new URL(auth.getBaseURL());
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.connect();
      Assert.assertEquals(HttpURLConnection.HTTP_OK, conn.getResponseCode());
      auth.stop();
}


Instance 172

Class700.testPingUsingHttpURLConnection(){
    final URL url = new URL("http://"+ SERVER_HOST + ":" + webServerPort + "/ping");
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    Assert.assertEquals(HttpURLConnection.HTTP_UNAUTHORIZED, conn.getResponseCode());
    String errorMessage = IOUtils.toString(conn.getErrorStream());
    Assert.assertTrue(errorMessage.contains("Authentication required"));
}


Instance 173

Class430.getUrlInfos(String urlAsString,int timeout){
            URL url = new URL(urlAsString);
            HttpURLConnection hConn = (HttpURLConnection) url.openConnection(Proxy.NO_PROXY);
            hConn.setRequestProperty("User-Agent", "Mozilla/5.0 Gecko/20100915 Firefox/3.6.10");
            hConn.setConnectTimeout(timeout);
            hConn.setReadTimeout(timeout);
            BufferedInputStream in = new BufferedInputStream(hConn.getInputStream(), arr.length);
            in.read(arr);
            return getUrlInfosFromText(arr);
}


Instance 174

Class1310.isConnectedToInternet()#0{
        String pingServerURL = pingBackUrl.substring(0, pingBackUrl.indexOf("/", "http://url".length()));
            URL url = new URL(pingServerURL);
            HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
            urlConn.connect();
            return (HttpURLConnection.HTTP_NOT_FOUND != urlConn.getResponseCode());
}


Instance 175

Class660._getImageAsStream(String urlStr){
    URL url = new URL(urlStr);
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.connect();
    return conn.getInputStream();
}


Instance 176

Class1190.getHTTPConnection(String urlString,String httpMethod)#0{
        URL url = new URL(urlString);
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        conn.setDoInput(true);
        conn.setDoOutput(true);
        conn.setAllowUserInteraction(true);
        conn.addRequestProperty("Cookie", cookie);
        conn.setRequestMethod(httpMethod);
        connectWithRetry(conn);
}


Instance 177

Class780.testProxy(InetSocketAddress proxySocketAddress,String fetchUrl)#1{
    URL url = new URL(fetchUrl);
    HttpURLConnection uc = (HttpURLConnection) url.openConnection(proxy);
    uc.connect();
    InputStream is = uc.getInputStream();
    String html = IoUtils.readAll(is);
    is.close();
}


Instance 178

Class950.getData(String urlString)#0{
        URL url = new URL(urlString);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.connect();
        InputStream is = connection.getInputStream();
        while ((i = is.read()) != -1) {
            incomingMessage = incomingMessage + (char) i;
        }
        is.close();
}


Instance 179

Class50.getCurrentCIDR(){
      URL url = new URL("http://checkip.amazonaws.com/");
      HttpURLConnection connection = (HttpURLConnection) url.openConnection();
      connection.connect();
      return Strings2.toStringAndClose(connection.getInputStream()).trim() + "/32";
}


Instance 180

Class90.testPathParam()#0{
    WebElement link = driver.findElement(By.id("link"));
    URL url = new URL(link.getAttribute("href"));
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    assertEquals(500, conn.getResponseCode());
}


Instance 181

Class750.testAdmin(@ArquillianResource URL url)#0{
        URLConnection uc = new URL(url, "_ah/admin").openConnection();
        HttpURLConnection conn = (HttpURLConnection) uc;
        conn.connect();
        conn.getInputStream().read();
}


Instance 182

Class1450.HttpContinueStackOverflow()#1{
        URL url = new URL("http", "localhost", s.getLocalPort(), "anything.html");
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        conn.getResponseCode();
}


Instance 183

Class520.testWeather7()#0{
    WebElement link = driver.findElement(By.tagName("link"));
    String href = link.getAttribute("href");
    url = new URL(href);
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    assertEquals(200, conn.getResponseCode());
}


Instance 184

Class580.makeHttpCall()#1{
            URL url = new URL("http" , InetAddress.getLocalHost().getHostAddress(),
                                server.getLocalPort(), "/");
            HttpURLConnection uc = (HttpURLConnection)url.openConnection();
            System.out.println(uc.getResponseCode());
}


Instance 185

Class1140.testServerStartSequence()#1{
        server.start();
        waitForStart(server);
        int port = server.httpPort();
        URL url = new URL("http://localhost:" + port + "/test");
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        assertThat(connection.getResponseCode()).isEqualTo(404);
}


Instance 186

Class850.doWork()#0{
            URL url = new URL("http://localhost:" + port + "/?id=" + id);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            assertThat(connection.getResponseCode()).isEqualTo(200);
}


Instance 187

Class80.main(String[] args)#0{
        ExecutorService s =  Executors.newCachedThreadPool();
        server.setExecutor (s);
        server.start ();
        URL url = new URL ("http://localhost:" + server.getAddress().getPort()+
                "/Foo/bar/test.html");
        HttpURLConnection urlc = (HttpURLConnection)url.openConnection();
        int r = urlc.getResponseCode();
}


Instance 188

Class190.getResponseCode(String url)#0{
      HttpURLConnection c = (HttpURLConnection)new URL(url).openConnection();
      return c.getResponseCode();
}


Instance 189

Class590.doClientSide()#1{
        URL url = new URL("https://localhost:" + serverPort + "/");
        HttpURLConnection urlc = (HttpURLConnection) url.openConnection();
        System.out.println("response is " + urlc.getResponseCode());
}


Instance 190

Class1470.createConnection(String urlStr){
        URL url = new URL(urlStr);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setDoOutput(true);
        conn.setUseCaches(true);
        conn.setRequestProperty("Accept-Encoding", acceptEncoding);
        conn.setReadTimeout(timeout);
        conn.setConnectTimeout(timeout);
}


Instance 191

Class710.getUrlAsDocument(String urlAsString,int timeout)#1{
        URL url = new URL(urlAsString);
        HttpURLConnection hConn = (HttpURLConnection) url.openConnection();
        hConn.setReadTimeout(timeout);
        hConn.setConnectTimeout(timeout);
        InputStream is = hConn.getInputStream();
}


Instance 192

Class1050.call()#0{
        for (UUID uuid : uuids) {
            HttpURLConnection connection = (HttpURLConnection) new URL(PROFILE_URL + uuid.toString().replace("-", "")).openConnection();
            JSONObject response = (JSONObject) jsonParser.parse(new InputStreamReader(connection.getInputStream()));
            String name = (String) response.get("name");
            if (name == null) {
                continue;
            }
            String cause = (String) response.get("cause");
            String errorMessage = (String) response.get("errorMessage");
            if (cause != null && cause.length() > 0) {
                throw new IllegalStateException(errorMessage);
            }
            uuidStringMap.put(uuid, name);
        }
}


Instance 193

Class500.doInBackground(ApiPacket... params)#1{
        url = new URL(getString(R.string.djImageApiURL) + pack.main.dj.id);
        HttpURLConnection conn = (HttpURLConnection) url
            .openConnection();
        conn.setDoInput(true);
        conn.connect();
        InputStream is = conn.getInputStream();
        image = BitmapFactory.decodeStream(is);
}


Instance 194

Class1040.getBitmapFromWeb(String src)#1{
            URL url = new URL(src);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoInput(true);
            connection.connect();
            InputStream input = connection.getInputStream();
            Bitmap myBitmap = BitmapFactory.decodeStream(input);
}


Instance 195

Class1190.getBitmapFromUrl(String urlSource)#1{
      URL url = new URL(urlSource);
      HttpURLConnection connection = (HttpURLConnection) url
          .openConnection();
      connection.setDoInput(true);
      connection.connect();
      InputStream input = connection.getInputStream();
      Bitmap myBitmap = BitmapFactory.decodeStream(input);
}


Instance 196

Class1000.readUrl(String urlAsString,int timeout){
        URL url = new URL(urlAsString);
        HttpURLConnection hConn = (HttpURLConnection) url.openConnection();
        hConn.setReadTimeout(timeout);
        hConn.setConnectTimeout(timeout);
        return readInputStream(hConn.getInputStream());
}


Instance 197

Class1520.testExecute_methodUnchanged()#0{
          (HttpURLConnection) new URL("http://www.google.com").openConnection();
      connection.setRequestMethod(method);
      NetHttpRequest request = new NetHttpRequest(connection);
      setContent(request, "text/html", "");
        request.execute().getContent().close();
      assertEquals(method, connection.getRequestMethod());
}


Instance 198

Class590.post(String url,Map<String,Object> parts){
    HttpURLConnection post = (HttpURLConnection) new URL(url)
        .openConnection();
    post.setRequestMethod("POST"); //$NON-NLS-1$
    return post(post, parts);
}


Instance 199

Class860.getURLReader(final String uri)#0{
      URL url = new URL( uri );
      HttpURLConnection connection = (HttpURLConnection) url.openConnection();
      connection.connect();
      InputStream in = connection.getInputStream();
      return new InputStreamReader( in );
}


Instance 200

Class830.getResourceLength(String path){
        URL url = new URL(path);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(12 * 1000);
        conn.setRequestMethod("GET");
        return conn.getContentLength();
}


Instance 201

Class1270.openConnection(String url){
        HttpURLConnection hConn = (HttpURLConnection) new URL(url).openConnection();
        hConn.setRequestProperty("content-charset", "UTF-8");
        hConn.setConnectTimeout(timeoutInMillis);
        hConn.setReadTimeout(timeoutInMillis);
        hConn.connect();
}


Instance 202

Class910.doInBackground(Void... params)#2{
                    URL imageUrl = new URL(mUrl);
                    HttpURLConnection connection = (HttpURLConnection) imageUrl.openConnection();
                    connection.setConnectTimeout(TIMEOUT);
                    connection.setReadTimeout(TIMEOUT);
                    connection.setInstanceFollowRedirects(true);
                    InputStream inputStream = connection.getInputStream();
}


Instance 203

Class330.openUrlConnection(String url){
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setUseCaches(false);
        conn.setChunkedStreamingMode(0);
        conn.setRequestProperty("User-Agent", USER_AGENT);
        conn.connect();
}


Instance 204

Class980.getCopyOfBitmap()#0{
                URL url = new URL(TULIP_IMG_URL);
                HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                connection.setDoInput(true);
                connection.connect();
                InputStream input = connection.getInputStream();
                sBitmap = ShadowBitmapFactory.decodeStream(input);
}


Instance 205

Class80.doInBackground(Void... params)#0{
            URL urlConnection = new URL(url);
            HttpURLConnection connection = (HttpURLConnection) urlConnection
                    .openConnection();
            connection.setDoInput(true);
            connection.connect();
            InputStream input = connection.getInputStream();
            Bitmap myBitmap = BitmapFactory.decodeStream(input);
}


Instance 206

Class1210.createConnection(ClientRequest request){
      String uri = request.getUri();
      String httpMethod = request.getHttpMethod();
      HttpURLConnection connection = (HttpURLConnection) new URL(uri).openConnection();
      connection.setRequestMethod(httpMethod);
}


Instance 207

Class1160.setupSignRequestTest(String urlStr,String method){
        final URL url = new URL(urlStr);
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod(method);
}


Instance 208

Class390.testFoo()#1{
    WebElement trigger = driver.findElement(By.id("trigger"));
    url = new URL(trigger.getAttribute("href"));
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    conn.setInstanceFollowRedirects(false);
    assertEquals(302, conn.getResponseCode());
    Map<String, String> headers = Tools.responseHeaders(conn);
    assertTrue(headers.containsKey("Location"));
    assertEquals("http://www.foobar.com", headers.get("Location"));
}


Instance 209

Class290.testGetBookNotExistent(){
        URL url = new URL(endpointAddress);
        HttpURLConnection connect = (HttpURLConnection)url.openConnection();
        connect.addRequestProperty("Accept", "application/xml");
        assertEquals(405, connect.getResponseCode());
        InputStream in = connect.getErrorStream();
        assertNotNull(in);           
        assertEquals("Exception is not mapped correctly", 
                     "StringTextWriter - Nonexistent method",
                     getStringFromInputStream(in).trim());
}


Instance 210

Class410.loadImage(String url)#0{
            connection = (HttpURLConnection) new URL(url).openConnection();
            connection.setConnectTimeout(15000);
            is = new BufferedInputStream(connection.getInputStream());
}


Instance 211

Class290.isw3OrgReachable()#0{
            HttpURLConnection connection = (HttpURLConnection) new URL("http://www.w3.org")
                    .openConnection();
            connection.setConnectTimeout(5000);
            connection.connect();
            connection.disconnect();
}


Instance 212

Class380.getHttpURLConnection(String urlAsString){
        URL url = new URL(urlAsString);
        HttpURLConnection hConn = (HttpURLConnection) url.openConnection(Proxy.NO_PROXY);
        hConn.setInstanceFollowRedirects(false);
        hConn.setRequestMethod("HEAD");
}


Instance 213

Class1420.checkLatestVersion(){
            URL url = new URL(VERSION_URL + REALM_VERSION);
            HttpURLConnection conn = (HttpURLConnection)url.openConnection();
            conn.setConnectTimeout(CONNECT_TIMEOUT);
            conn.setReadTimeout(READ_TIMEOUT);
            BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            result = rd.readLine();
            rd.close();
}


Instance 214

Class460.testRender()#0{
    assertEquals(applicationURL("/foo").getPath(), url.getPath());
    assertNull(url.getQuery());
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    conn.setInstanceFollowRedirects(false);
    conn.setRequestMethod("POST");
    conn.connect();
    assertEquals(302, conn.getResponseCode());
    url = new URL(Tools.responseHeaders(conn).get("Location"));
    assertEquals(applicationURL("/foo").getPath(), url.getPath());
}


Instance 215

Class560.testURL(String wicketId,String uri)#1{
        if (uri!=null) 
            urlString+=uri;
        URL url = new URL(urlString);        
        HttpURLConnection con = (HttpURLConnection) url.openConnection();
        con.getInputStream().close();
}


Instance 216

Class1310.postProperty()#1{
    URL url = new URL("http://localhost:8080/jabylon/api/apiproject/master/folder/test11.properties");
    HttpURLConnection httpCon = (HttpURLConnection) url.openConnection();
    httpCon.setDoOutput(true);
    httpCon.setRequestMethod("PUT");
    PrintStream printStream = new PrintStream(httpCon.getOutputStream());
    printStream.println("narf = blah");
    printStream.close();
}


Instance 217

Class860.getURLContent_old(final String uri,final StringBuffer content)#0{
    URL url = new URL( uri );
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.connect();
    InputStream in = connection.getInputStream();
}


Instance 218

Class630.test9(String u)#1{
        URL url = new URL (u);
        HttpURLConnection urlc = (HttpURLConnection)url.openConnection ();
        urlc.setChunkedStreamingMode (-1);
        urlc.setDoOutput(true);
        urlc.setRequestMethod ("POST");
        OutputStream os = urlc.getOutputStream ();
}


Instance 219

Class830.drawableFromUrl(Context context,String url)#0{
        HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
        connection.connect();
        InputStream input = connection.getInputStream();
        x = BitmapFactory.decodeStream(input);
}


Instance 220

Class550.fetchXml(String doi){
    URL url = new URL(doi);
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.connect();
    InputStream is = conn.getInputStream();
    String result = IOUtils.toString(is);
    is.close();
}


Instance 221

Class1440.invokeServer(String uri)#0{
    URL url = new URL("http://localhost:" + RANDOM_SERVER_PORT + uri);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setDoInput(true);
    Util.readToString(connection.getInputStream());
}


Instance 222

Class260.getOriginatingIp(){
    URL url = new URL("http://checkip.amazonaws.com/");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.connect();
    return IOUtils.toString(connection.getInputStream()).trim() + "/32";
}


Instance 223

Class900.createUrlConnection(String urlAsStr,int timeout){
        URL url = new URL(urlAsStr);
        HttpURLConnection hConn = (HttpURLConnection) url.openConnection(Proxy.NO_PROXY);
        hConn.setRequestProperty("Accept-Encoding", "gzip, deflate");
        hConn.setConnectTimeout(timeout);
        hConn.setReadTimeout(timeout);
}


Instance 224

Class1170.testInvalidadHttpFSAccess()#0{
    URL url = new URL(TestJettyHelper.getJettyURL(),
                      "/webhdfs/v1/?op=GETHOMEDIRECTORY");
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    Assert.assertEquals(conn.getResponseCode(),
                        HttpURLConnection.HTTP_UNAUTHORIZED);
}


Instance 225

Class1120._getImageAsStream(String urlStr){
        URL url = new URL(urlStr);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.connect();
        return conn.getInputStream();
}


Instance 226

Class1490.getURLInputStream(final String uri)#2{
      URL url = new URL( uri );
      HttpURLConnection connection = (HttpURLConnection) url.openConnection();
      connection.connect();
      InputStream in = connection.getInputStream();
}


Instance 227

Class1380.testSecurePing(@ArquillianResource URL url)#0{
        URLConnection uc = new URL(url, "secure").openConnection();
        HttpURLConnection conn = (HttpURLConnection) uc;
        conn.connect();
            conn.getInputStream();
}


Instance 228

Class610.testDoubleCompression(){
        for (String endpoint : Arrays.asList("autoZip","ownZip")) {
            HttpURLConnection con = (HttpURLConnection) new URL(this.url, endpoint).openConnection();
            con.setRequestProperty("Accept-Encoding","gzip");
            byte[] data = IOUtils.toByteArray(con.getInputStream());
            data = IOUtils.toByteArray(new GZIPInputStream(new ByteArrayInputStream(data)));
            assertEquals(new String(data), CONTENT);
        }
}


Instance 229

Class520.createConnection(UUID id){
    URL url = new URL(PROFILE_URL + id.toString().replace("-", ""));
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setConnectTimeout(15000);
    connection.setReadTimeout(15000);
    connection.setUseCaches(false);
    connection.setDoInput(true);
    connection.setDoOutput(true);
}


Instance 230

Class1000.eventGoesToAppenders()#0{
    URL url = new URL(JETTY_FIXTURE.getUrl());
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setDoInput(true);
    String result = Util.readToString(connection.getInputStream());
    assertEquals("hello world", result);
}


Instance 231

Class590.makeHttpCall()#0{
            URL url = new URL("https" , firstNonLoAddress.getHostAddress(),
                                server.getLocalPort(), "/");
            HttpURLConnection uc = (HttpURLConnection)url.openConnection();
            System.out.println(uc.getResponseCode());
}


Instance 232

Class720.download(String uri,String filePath)#1{
      URL url = new URL(uri);
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.setRequestProperty("User-Agent", AGENT);
      readStreamToFile(conn.getInputStream(), filePath);
}


Instance 233

Class1360.openHttpURLConnection(String url){
        URL submitURL = new URL(url);
        HttpURLConnection httpURLConnection = (HttpURLConnection) submitURL.openConnection();
        httpURLConnection.setConnectTimeout(3000);
        httpURLConnection.setReadTimeout(3000);
        httpURLConnection.setRequestProperty("Content-Language", "utf-8");
}


Instance 234

Class1350.makeRequest(){
        HttpURLConnection connection = (HttpURLConnection) new URL("http://localhost:8092/").openConnection();
        connection.addRequestProperty("Connection", "keep-alive");
        InputStream in = connection.getInputStream();
        while (in.available() > 0) {
            in.read();
        }
        in.close();
}


Instance 235

Class750.getResponse(URL contextUrl,String uri){
        URL url = new URL(contextUrl, uri);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            byte[] bytes = IOUtils.toBytes(connection.getInputStream(), true);
            return new String(bytes, "UTF-8");
            connection.disconnect();
}


Instance 236

Class1100.connectTo(String url){
    String encodedUrl = Uri.encode(url, ALLOWED_URI_CHARS);
    HttpURLConnection conn = (HttpURLConnection) new URL(encodedUrl).openConnection();
    conn.setConnectTimeout(connectTimeout);
    conn.setReadTimeout(readTimeout);
    conn.connect();
}


Instance 237

Class100.getConnection(String alias,int timeout){
        HttpURLConnection urlConn = (HttpURLConnection) new URL("http", "localhost", PORT, alias).openConnection();
        urlConn.setConnectTimeout(5 * 1000);
        urlConn.setReadTimeout(timeout);
        urlConn.connect();
}


Instance 238

Class1510.testException(){
    HttpURLConnection c2 = (HttpURLConnection)new URL("http://localhost:" + PORT + "/error").openConnection();
    assertEquals(c2.getResponseCode(), RestStatus.INTERNAL_SERVER_ERROR);
}


Instance 239

Class180.HttpContinueStackOverflow(int port)#2{
        URL url = new URL("http", "localhost", port, "anything.html");
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        int respCode = conn.getResponseCode();
}


Instance 240

Class720.execUrl(String uri)#1{
      URL url = new URL(uri);
      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
      conn.setRequestProperty("User-Agent", AGENT);
      res = readStream(conn.getInputStream());
}


Instance 241

Class960.CheckUrl(String urlvalue)#0{
      URL url = new URL(urlvalue);
      HttpURLConnection urlConnection = (HttpURLConnection) url
          .openConnection();
      BufferedReader in = new BufferedReader(new InputStreamReader(
          urlConnection.getInputStream()));
      inputLine = in.readLine().toString();
}


Instance 242

Class90.readData(String dest)#0{
            HttpURLConnection con = (HttpURLConnection) new URL(dest).openConnection();
                BufferedReader reader = new BufferedReader(new InputStreamReader(con.getInputStream()));
                return reader.readLine();
}


Instance 243

Class840.testQuery(){
        URL url = new URL("http://localhost:" + port + path);
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        conn.setDefaultUseCaches(false);
        BufferedReader in = new BufferedReader(
                new InputStreamReader(
                conn.getInputStream()));
        String s = in.readLine();
        assertTrue(s.contains("~kilim"));
        assertTrue(s.contains("desc:Rolls Royce"));
        in.close();
}


Instance 244

Class880.queryBing(String query){
        String urlString = "http://dev.virtualearth.net/REST/v1/Locations?query=" + URLEncoder.encode(query, "utf-8") + "&output=json&key=" + URLEncoder.encode(key, "utf-8");
        URL url = new URL(urlString);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setDoOutput(true);
        String responseText = IOUtils.toString(connection.getInputStream(), "UTF-8");
        JSONObject responseJson = new JSONObject(responseText);
        return toLumifyGeocodeJson(responseJson);
}


Instance 245

Class1150.getInputStreamFromUrl(String urlStr){
    URL url = new URL(urlStr);
    HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();  
      urlConn.setConnectTimeout(5000); 
      urlConn.setReadTimeout(70000);
      InputStream inputStream = urlConn.getInputStream();
}


Instance 246

Class470.readUrlAsDocument(String urlAsString,int timeout)#0{
        URL url = new URL(urlAsString);
        HttpURLConnection hConn = (HttpURLConnection) url.openConnection();
        hConn.setReadTimeout(timeout);
        hConn.setConnectTimeout(timeout);
        return newDocumentBuilder().parse(hConn.getInputStream());
}


Instance 247

Class930.testCookieEcho(){
    HttpURLConnection c = (HttpURLConnection)new URL("http://localhost:" + PORT + "/headerEcho").openConnection();
    c.setRequestProperty(HttpConstants.REQUEST_COOKIE_HEADER_NAME, cookie);
    assertEquals(c.getHeaderField(HttpConstants.RESPONSE_COOKIE_HEADER_NAME), cookie);
}


Instance 248

Class510.makeConnection(String contextPath){
    URL url = new URL(contextPath);
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.setConnectTimeout(CONNECTION_TIMEOUT);
    conn.connect();
}


Instance 249

Class860.doInBackground(View[] params)#0{
        URL url = new URL(((EditText) params[0]).getText().toString());
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        String header = conn.getHeaderField("Content-Disposition");
        if (header != null && header.indexOf("=") != -1) {
          return new Object[]{params[1], header.split("=")[1].replace("\"", "")};
        }
}


Instance 250

Class850.sendSolrUpdateRequest(String request,String core)#0{
        URL url = new URL("http://localhost:8983/solr/" + core + "/update");
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        conn.setDoOutput(true);
        conn.setRequestProperty("Content-Type", "text/xml");
        OutputStream os = conn.getOutputStream();
}


Instance 251

Class1460.httpCall(){
      URL url1 = new URL(url);
      connection = (HttpURLConnection)url1.openConnection();
      System.out.println("using proxy: " + connection.usingProxy());
      if (connection != null) {
        connection.disconnect();
      }
}


Instance 252

Class1350.performRequest(String urlString){
        URL url = new URL(urlString);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.connect();
        conn.disconnect();
}


Instance 253

Class80.testBlobServedWhenResponseContainsBlobKeyHeader(@ArquillianResource URL url){
        URL pageUrl = new URL(url, "serveblob?name=testblob.txt&mimeType=" + MIME_TYPE + "&contents=" + CONTENTS);
        HttpURLConnection connection = (HttpURLConnection) pageUrl.openConnection();
            String response = readFullyAndClose(connection.getInputStream());
            assertEquals(MIME_TYPE, connection.getContentType());
            assertEquals(CONTENTS, response);
            assertNull("header should have been removed from response", connection.getHeaderField("X-AppEngine-BlobKey"));
            connection.disconnect();
}


Instance 254

Class450.main(String[] args)#0{
            server = new HttpServer (new RelativeRedirect(), 1, 10, 0);
            URL url = new URL("http://localhost:"+server.getLocalPort());
            HttpURLConnection urlc = (HttpURLConnection)url.openConnection ();
            InputStream is = urlc.getInputStream ();
            is.close();
}


Instance 255

Class1240.checkSSLServer()#0{
        URL testSSLURL = new URL(getProxyCallbackURLPrefix().getProtocol(),
                getProxyCallbackURLPrefix().getHost(),getProxyCallbackURLPrefix().getPort(),"/test");
        HttpURLConnection con = (HttpURLConnection) testSSLURL.openConnection();
        con.getInputStream().close();
}


Instance 256

Class1510.getInputStream(){
        URL url = new URL("http://developer.usa.gov/1usagov");
        HttpURLConnection request = (HttpURLConnection) url.openConnection();
        return request.getInputStream();
}


Instance 257

Class30.onCreate(Bundle savedInstanceState)#0{
      URL url = new URL("http://www.vogella.de");
      HttpURLConnection con = (HttpURLConnection) url.openConnection();
      readStream(con.getInputStream());
}


Instance 258

Class1400.get(String url){
    HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
    printResponse(connection.getInputStream());
}


Instance 259

Class280.fetchJson(@NotNull final String url)#1{
            c = (HttpURLConnection)new URL(url).openConnection();
            return objectMapper.readTree(c.getInputStream());
}


Instance 260

Class230.doRequest(String uri)#2{
        URL url = new URL(uri + "?foo="+reqnum);
        HttpURLConnection http = (HttpURLConnection)url.openConnection();
        InputStream in = http.getInputStream();
}


Instance 261

Class450.runClient(Proxy proxy,int serverPort)#0{
            URL url = new URL(urlStr);
            HttpURLConnection uc = (HttpURLConnection) url.openConnection(proxy);
            uc.getInputStream();
}


Instance 262

Class270.testSleep()#1{
        URL url = new URL("http", "localhost", HTTP_SERVER_PORT, "/");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.addRequestProperty("X-Sleep", "1000");
        conn.connect();
}


Instance 263

Class260.getRequest()#1{
    URL url = new URL("http://localhost:" + RANDOM_SERVER_PORT + "/");
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setDoInput(true);
    String result = Util.readToString(connection.getInputStream());
    assertEquals("hello world", result);
}


Instance 264

Class440.openConnection(String url){
        URL u = new URL(url);
        urlConnection = (HttpURLConnection)u.openConnection();
        urlConnection.setRequestProperty("User-Agent", userAgent);
        urlConnection.setUseCaches(true);
}


Instance 265

Class420.openConnection(String url){
    HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
    connection.setConnectTimeout(DEFAULT_CONNECT_TIMEOUT_MILLIS);
    connection.setReadTimeout(DEFAULT_READ_TIMEOUT_MILLIS);
    connection.setDoInput(true);
}


Instance 266

Class1060.serializeResource(String resourceURL){
    URL url = new URL(resourceURL);
    HttpURLConnection con = (HttpURLConnection) url.openConnection();
    con.addRequestProperty("Cache-Control", "max-age=0");
    mediaContainer = serializer.read(MediaContainer.class,
        con.getInputStream(), false);
}


Instance 267

Class600.testPathParam()#1{
    WebElement trigger = driver.findElement(By.tagName("body"));
    URL url = new URL(trigger.getText());
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    conn.connect();
}


Instance 268

Class1060.testHeaderEcho(){
    HttpURLConnection c = (HttpURLConnection)new URL("http://localhost:" + PORT + "/headerEcho").openConnection();
    c.setRequestProperty("Header2", "bar");
    assertEquals(c.getHeaderField("header1"), "foo");
    assertEquals(c.getHeaderField("header2"), "bar");
}


Instance 269

Class1320.openUrlConnection(String url)#0{
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
        conn.setUseCaches(false);
        conn.setChunkedStreamingMode(0);
        conn.setRequestProperty("connection", "close");    // Disable keep-alive because of issues with it
}


Instance 270

Class1030.getConnection(String path){
        logger.log(Level.INFO, "sending request to {0}", path);
        URL url = new URL("http", "localhost", PORT, path);
        HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
        urlConn.connect();
}


Instance 271

Class1140.openConnectionInternal()#0{
        String params = getParameterString();
        if (params != null && params.length() > 0) {
            url = url + "?" + params;
        }
        URL getUrl = new URL(url);
        HttpURLConnection conn = (HttpURLConnection) getUrl.openConnection();
}


Instance 272

Class590.openConnection(Uri path){
    HttpURLConnection connection = (HttpURLConnection) new URL(path.toString()).openConnection();
    connection.setConnectTimeout(Utils.DEFAULT_CONNECT_TIMEOUT);
    connection.setReadTimeout(Utils.DEFAULT_READ_TIMEOUT);
}


Instance 273

Class300.createConnection(String url,Object extra){
    String encodedUrl = Uri.encode(url, ALLOWED_URI_CHARS);
    HttpURLConnection conn = (HttpURLConnection) new URL(encodedUrl).openConnection();
    conn.setConnectTimeout(connectTimeout);
    conn.setReadTimeout(readTimeout);
}


Instance 274

Class170.loadDataFromNetwork()#0{
            final HttpURLConnection httpURLConnection = (HttpURLConnection) new URL(url).openConnection();
            return processStream(httpURLConnection.getContentLength(), httpURLConnection.getInputStream());
}


Instance 275

Class740.testApp()#0{
    HttpURLConnection conn = (HttpURLConnection) new URL(url)
        .openConnection();
    InputStream in = conn.getInputStream();
    BufferedImage src = ImageIO.read(in);
    in.close();
}


Instance 276

Class1290.doClientSide()#0{
        URL url = new URL("https://"+host+":"+serverPort+"/index.html");
        HttpURLConnection urlc = (HttpURLConnection)url.openConnection();
        InputStream is = urlc.getInputStream();
        is.close();
}


Instance 277

Class20.main(String[] args)#0{
            URL u = new URL ("http://127.0.0.1:"+port+"/foo\nbar");
            HttpURLConnection urlc = (HttpURLConnection)u.openConnection ();
            InputStream is = urlc.getInputStream();
}


Instance 278

Class1060.makeRemoteRequest(String baseURL,String relativePath)#0{
      URL url = new URL(baseURL + "/" + relativePath);
      HttpURLConnection connection = (HttpURLConnection) url.openConnection();
      return readResponse(connection.getInputStream());
}


Instance 279

Class30.doDownload(String from)#1{
        URL url = new URL(from);
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
            InputStream in = conn.getInputStream();
}


Instance 280

Class1510.getInputStream(){
        URL url = new URL("http://stream.meetup.com/2/rsvps");
        HttpURLConnection request = (HttpURLConnection) url.openConnection();
        return request.getInputStream();
}


Instance 281

Class40.makeConnection(String resource){
    HttpURLConnection conn = (HttpURLConnection)(new URL(resource).openConnection());
        conn.setDoOutput(true);
}


Instance 282

Class700.connect(String url,String sessionId)#0{
        HttpURLConnection huc = (HttpURLConnection)new URL(url).openConnection();
        huc.setInstanceFollowRedirects(false);
        huc.setDoOutput(false);
}


Instance 283

Class1470.Encode()#3{
        String url = "http://localhost:" + Integer.toString(ss.getLocalPort()) +
        HttpURLConnection uc =  (HttpURLConnection)new URL(url).openConnection();
        uc.connect();
}


Instance 284

Class60.createConnection(String alias,int port){
        URL url = new URL("http", "localhost", port, alias);
        HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
        urlConn.setReadTimeout(10 * 1000);
}


Instance 285

Class930.ConnBuilder(Credentials credentials,String container,String object)#0{
                if (object != null) {
                    url = url + "/" + object;
                }
                con = (HttpURLConnection) new URL(url).openConnection();
}


Instance 286

Class930.ConnBuilder(Credentials credentials,String container,String object)#0{
                    if (object != null) {
                        url = url + "/" + object;
                    }
                    con = (HttpURLConnection) new URL(url).openConnection();
                    con.addRequestProperty(ACCEPT_HEADER, "*/*");
}


Instance 287

Class220.createConnection(String uri)#0{
        URL url = new URL(uri);
            (HttpURLConnection) url.openConnection();
        connection.setRequestProperty("Connection", "close");
}


Instance 288

Class950.executeGet(String urlString,JSONHandler handler,boolean authenticated)#1{
        LOGD(TAG, "Requesting URL: " + urlString);
        URL url = new URL(urlString);
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();
        urlConnection.setRequestProperty("User-Agent", mUserAgent);
}


Instance 289

Class880.open(String base,FormValues fv)#1{
        if (fv != null) {
            String url = base + "?" + fv.queryString();
            conn = (HttpURLConnection) new URL(url).openConnection();
        } else {
            conn = (HttpURLConnection) new URL(base).openConnection();
        }
}


Instance 290

Class830.openUrlConnection(String url)#2{
        HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
        connection.setConnectTimeout(connectTimeout);
        connection.setReadTimeout(readTimeout);
}


Instance 291

Class1010.createConnection(String url){
    HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
    connection.setConnectTimeout(3000);
    connection.setReadTimeout(3000);
}


Instance 292

Class680.postRequest(String address)#1{
        URL url = new URL(address);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setDoOutput(true);
}


Instance 293

Class1520.check(final String containerId)#2{
        final URL url = new URL("http", dockerHost.address(), port, healthCheck.getPath());
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(CONNECT_TIMEOUT_MILLIS);
}


Instance 294

Class40.setupConnection(String url,String authHeaderValue)#0{
        logger.debug("Intitiating connection to URL: " + url);
        HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection();
}


Instance 295

Class1490.ServiceConnectionSE(String url){
        connection = (HttpURLConnection) new URL(url).openConnection();
        connection.setUseCaches(false);
        connection.setDoOutput(true);
        connection.setDoInput(true);
}


Instance 296

Class400.HttpRequest(final CharSequence url,final String method)#0{
      connection = (HttpURLConnection) new URL(url.toString())
          .openConnection();
      connection.setRequestMethod(method);
}


Instance 297

Class1170.createHttpConnection(Uri uri)#0{
        return (HttpURLConnection)new URL(uri.toString()).openConnection();
}


Instance 298

Class1420.uploadDeviceConfig(UploadDeviceConfigRequest request,String deviceConfigToken)#4{
            connection = (HttpURLConnection) new URL(UPLOAD_DEVICE_CONFIG_URL).openConnection();
}


Instance 299

Class1420.Net(String urlStr,boolean useCache,Context ctxt)#1{
        URL url = new URL(urlStr);
        mUrlConnection = (HttpURLConnection) url.openConnection();
        mUrlConnection.setRequestProperty("User-Agent", USERAGENT);
        mUrlConnection.setUseCaches(useCache);
}


Instance 300

Class1120.getConnection(String urlString){
    URL url = new URL(urlString);
    return (HttpURLConnection) url.openConnection();
}


Instance 301

Class1290.pingLink(String Url)#2{
      URL url = new URL(Url);
      HttpURLConnection con = (HttpURLConnection)(url.openConnection());
}


Instance 302

Class1290.updateMirrorsYMLCache()#2{
        URL url = new URL("http://get.spout.org/mirrors.yml");
        HttpURLConnection con = (HttpURLConnection) (url.openConnection());
}


Instance 303

Class430.ProxyableConnection(Proxy proxy,String repo)#0{
        conn = (HttpURLConnection) new URL(repo).openConnection(proxy);
}


Instance 304

Class50.testServerOk()#0{
        URL server = new URL(SERVER_URL);
        HttpURLConnection conn = (HttpURLConnection) server.openConnection();
}


Instance 305

Class940.createConnection()#1{
                this.connection = (HttpURLConnection) new URL(completeUrl).openConnection(proxy);
}


Instance 306

Class440.getConnection(String spec){
    return (HttpURLConnection) new URL(spec).openConnection();
}


Instance 307

Class1040.connectTo(String endpoint){
        URL url = new URL(endpoint);
        return (HttpURLConnection) url.openConnection();
}


Instance 308

Class710.test4(String u)#2{
        URL url = new URL (u);
        HttpURLConnection urlc = (HttpURLConnection)url.openConnection ();
}


Instance 309

Class1080.openConnection(String url){
        return (HttpURLConnection) new URL(url).openConnection();
}


Instance 310

Class1130.getConnection(String url){
        HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
}


Instance 311

Class1450.connnectTo(String path)#0{
            URL test = new URL(url, path);
            return (HttpURLConnection) test.openConnection();
}


Instance 312

Class560.getRawHTTPConnection(String urlString)#1{
      URL url = new URL(urlString);      
      return (HttpURLConnection)url.openConnection();
}


Instance 313

Class570.Request(String url,int connectTimeout,int readTimeout)#1{
            connection = (HttpURLConnection) new URL(url).openConnection();
            connection.setConnectTimeout(connectTimeout);
            connection.setReadTimeout(readTimeout);
}


Instance 314

Class600.createConnection(){
    return (HttpURLConnection) new URL(url).openConnection();
}


Instance 315

Class420.buildConnection(RequestMethod requestMethod,String urlString)#0{
        URL url = new URL(configuration.getBaseURL() + urlString);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
}


Instance 316

Class490.get(String url,Map<String,String> headers,boolean allowRedirect)#1{
        HttpURLConnection urlConnection = (HttpURLConnection) new URL(url).openConnection();
        setCommonProperties(headers, urlConnection, allowRedirect);
            in = readInputStream(urlConnection);
}


Instance 317

Class1520.testLongHeader()#2{
    URL url = new URL(baseUrl, "/longheader");
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
}


Instance 318

Class1520.HttpTestClient(String host,int port,byte[] object)#0{
            connection = (HttpURLConnection)new URL(url).openConnection();
}


Instance 319

Class1370.method1()#0{
    String imei = TelephonyManager.getDeviceId();
      URL url = new URL(imei);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
}


Instance 320

Class830.openConnection(String url)#1{
      return (HttpURLConnection) new URL(url).openConnection();
}


Instance 321

Class1380.testMultiValuedHeaderEcho()#2{
    HttpURLConnection c = (HttpURLConnection)new URL("http://localhost:" + PORT + "/headerEcho").openConnection();
}


Instance 322

Class70.setupHTTPConnection(String url)#1{
    HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection(Proxy.NO_PROXY);
}


Instance 323

Class930.pingUrl(String Url)#1{
      URL url = new URL(Url);
      HttpURLConnection con = (HttpURLConnection)(url.openConnection());
}


Instance 324

Class1220.request_id_header_01(){
        String qs = Convert.encWWWForm("ASK{}") ;
        URL u = new URL(serviceQuery+"?query="+qs);
        HttpURLConnection conn = (HttpURLConnection) u.openConnection();
        Assert.assertTrue(conn.getHeaderField("Fuseki-Request-ID") != null);
}


Instance 325

Class90.createURLConnection(String url,boolean dev)#0{
        HttpURLConnection connection = (HttpURLConnection)new URL(url).openConnection();
        connection.setInstanceFollowRedirects(false);
}


Instance 326

Class180.syndFeed()#2{
        URL feedUrl = new URL(_url);
        HttpURLConnection feedConn = (HttpURLConnection) feedUrl.openConnection();
        feedConn.addRequestProperty("User-Agent", "Mozilla/5.001 (windows; U; NT4.0; en-us) Gecko/25250101");
}


Instance 327

Class1280.call(Server server){
                    url = new URL("http://" + server.getHost() + ":" + server.getPort() + path);
                    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                    return Observable.just(conn.getResponseMessage());
                    return Observable.error(e);
}


Instance 328

Class760.testOpenSslConnection_http(){
        final URL httpUrl = new URL("http://example.com");
        final HttpURLConnection connection = (HttpURLConnection) httpUrl.openConnection();
        client.openSslConnection(connection);
        assertFalse(connection instanceof HttpsURLConnection);
}


Instance 329

Class480.ObaDefaultConnection(Uri uri)#0{
            Log.d(TAG, uri.toString());
        URL url = new URL(uri.toString());
        mConnection = (HttpURLConnection) url.openConnection();
        mConnection.setReadTimeout(30 * 1000);
}


Instance 330

Class420.openConnection(String uri){
                String cleanUri = uri.substring(0, uri.indexOf(";deviceside=true"));
                URL url = new URL(cleanUri);
                return new HttpConnectionWrapper((HttpURLConnection) url.openConnection());
}


Instance 331

Class430.isInternetReachable(){
            URL url = new URL("http://checkstyle.sourceforge.net/");
            HttpURLConnection urlConnect = (HttpURLConnection) url.openConnection();
            Object objData = urlConnect.getContent();
}


Instance 332

Class860.test()#1{
        URL url = new URL("http://www.naver.com");
        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
        connection.getHeaderFields();
}


Instance 333

Class1170.deleteFile(long fileId,String fileType)#0{
            HttpURLConnection conn = (HttpURLConnection) new URL(deleteUrl).openConnection();
}


Instance 334

Class1410.getConnection(String url){
        URL u = new URL(url);
        return (HttpURLConnection) u.openConnection();
}


Instance 335

Class160.createConnection()#0{
      connection = (HttpURLConnection) new URL(completeUrl).openConnection();
}


Instance 336

Class20.create(URL otherUrl){
        return (HttpURLConnection) new URL(url).openConnection();
}


Instance 337

Class100.createConnection(String uri){
    URL url = new URL(createUri(uri));
    return (HttpURLConnection) url.openConnection();
}


Instance 338

Class310.open(MethodType methodType,String url,Charset charset)#1{
        HttpURLConnection con = (HttpURLConnection) new URL(url).openConnection();
}


Instance 339

Class430.ProxyableConnection(Proxy proxy,String repo)#2{
        conn = (HttpURLConnection) new URL(repo).openConnection();
}


Instance 340

Class1510.getConnection(final String url){
        final URL u = new URL(url);
        return (HttpURLConnection) u.openConnection();
}


Instance 341

Class1510.getHttpURLConnection(String strUrl){
    URL url = new URL(strUrl);
    HttpURLConnection httpURLConnection = (HttpURLConnection) url
        .openConnection();
}


Instance 342

Class940.createConnection()#2{
                this.connection = (HttpURLConnection) new URL(completeUrl).openConnection();
}


Instance 343

Class440.connect(){
    URL url = new URL(address);
    conn = (HttpURLConnection) url.openConnection();
    conn.setConnectTimeout(CONNECT_TIMEOUT);
    conn.setReadTimeout(READ_TIMEOUT);
    conn.setDoInput(true);
    conn.setDoOutput(true);
    conn.setRequestMethod("POST");
    conn.setRequestProperty("Accept", "*/*");
}


Instance 344

Class340.getRawHTTPConnection(String urlString){
        URL url = new URL(urlString);
        return (HttpURLConnection)url.openConnection();
}


Instance 345

Class1240.getConnection(URI uri){
        String s = uri.toString();
        LOGGER.log(Level.INFO, s);
        URL url = new URL(s);
        return (HttpURLConnection) url.openConnection();
}


Instance 346

Class150.getGDataUrlConnection(String urlString)#1{
    URL url = new URL(urlString);
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
}


Instance 347

Class250.AndroidHttpConnection(final String name,final int mode,final boolean timeouts)#1{
      final URL url = new URL(name);
      connection = (HttpURLConnection) url.openConnection();
}


Instance 348

Class120.openConnection(String urlString){
        URL url = new URL(urlString);
        HttpURLConnection uc = (HttpURLConnection) url.openConnection();
}


Instance 349

Class120.connect(String url){
        HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
}


Instance 350

Class970.httpGet(final String httpurl,final Map<String,String>... requestProperties)#0{
        HttpURLConnection connection = (HttpURLConnection) new URL(httpurl).openConnection();
}


Instance 351

Class370.getConnection(String url){
    HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
}


Instance 352

Class1330.createConnection(final String uri,final String contentType,final String accept)#2{
        final URL url = new URL(safeUri(uri));
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
}


Instance 353

Class540.simplePostRequest(String url,String postType,byte[] data)#0{
            HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
      prepareConnection(connection, postType);
      writeData(connection, data, false);
            return parseResponseWrapper(connection);
}


Instance 354

Class1070.testLongHeader(){
    URL url = new URL(baseUrl, "/longheader");
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    testLongHeader(conn);
}


Instance 355

Class1380.testMultipleCookiesEcho()#2{
    HttpURLConnection c = (HttpURLConnection)new URL("http://localhost:" + PORT + "/headerEcho").openConnection();
}


Instance 356

Class1350.createConnection(final String method,final String testName)#1{
        URL testURL = new URL(createTestUri(testName));
        HttpURLConnection conn = (HttpURLConnection) testURL.openConnection();
}


Instance 357

Class70.getUrlConnection(final String url){
        return (HttpURLConnection) new URL( url ).openConnection();
}


Instance 358

Class900.havingEmptyQueryString()#0{
        final URL url = new URL("http://localhost:" + port() + "/?");
        final HttpURLConnection c = (HttpURLConnection) url.openConnection();
}


Instance 359

Class880.open(String base,FormValues fv)#0{
            conn = (HttpURLConnection) new URL(base).openConnection();
}


Instance 360

Class690.getStringFromUrl(String url,int connectTimeout,int readTimeout)#0{
    URL urlObject = new URL(url);
    HttpURLConnection urlConn = (HttpURLConnection)urlObject.openConnection();
}


Instance 361

Class790.call()#0{
                params.put("user", getTestUser());
                URL url = createURL("", params);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("POST");
                conn.setRequestProperty("content-type", RestConstants.XML_CONTENT_TYPE);
                conn.setDoOutput(true);
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
                JSONObject obj = (JSONObject) JSONValue.parse(new InputStreamReader(conn.getInputStream()));
                assertEquals("Valid workflow-app", obj.get(JsonTags.VALIDATE));
}


Instance 362

Class570.deleteFile(ActiveMQBlobMessage message){
        URL url = createMessageURL(message);
        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
        connection.setRequestMethod("DELETE");
        connection.connect();
        connection.disconnect();
        if (!isSuccessfulCode(connection.getResponseCode())) {
            throw new IOException("DELETE was not successful: " + connection.getResponseCode() + " "
                                  + connection.getResponseMessage());
        }
}


Instance 363

Class1280.call(){
                Map<String, String> params = new HashMap<String, String>();
                URL url = createURL("", params);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
                assertTrue(conn.getHeaderField("content-type").startsWith(RestConstants.JSON_CONTENT_TYPE));
                JSONArray array = (JSONArray) JSONValue.parse(new InputStreamReader(conn.getInputStream()));
                assertEquals(2, array.size());
                assertEquals(OozieClient.WS_PROTOCOL_VERSION, array.get(1));
}


Instance 364

Class230.call()#0{
                final String id = bundleJobBean.getId();
                URL url = createURL(id, params);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
                assertTrue(conn.getHeaderField("content-type").startsWith(RestConstants.JSON_CONTENT_TYPE));
                JSONObject obj = (JSONObject) JSONValue.parse(new InputStreamReader(conn.getInputStream()));
                assertEquals(id, obj.get("bundleJobId"));
}


Instance 365

Class0._requestToServer(String bulkRequest){
        Map<String, String> params = new HashMap<String, String>();
        params.put(RestConstants.LEN_PARAM, "5");
        URL url = createURL("", params);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
        assertTrue(conn.getHeaderField("content-type").startsWith(RestConstants.JSON_CONTENT_TYPE));
        JSONObject json = (JSONObject) JSONValue.parse(new InputStreamReader(conn.getInputStream()));
        JSONArray array = (JSONArray) json.get(JsonTags.BULK_RESPONSES);
}


Instance 366

Class840.call(){
                Map<String, String> map = new HashMap<String, String>();
                map.put(RestConstants.SHARE_LIB_REQUEST_KEY, "pig");
                URL url = createURL(RestConstants.ADMIN_LIST_SHARELIB, map);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
                assertTrue(conn.getHeaderField("content-type").startsWith(RestConstants.JSON_CONTENT_TYPE));
                JSONObject json = (JSONObject) JSONValue.parse(new InputStreamReader(conn.getInputStream()));
                assertEquals(null, json.get(JsonTags.SHARELIB_LIB));
}


Instance 367

Class260.call()#0{
                URL url = createURL(RestConstants.ADMIN_OS_ENV_RESOURCE, Collections.EMPTY_MAP);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
                assertTrue(conn.getHeaderField("content-type").startsWith(RestConstants.JSON_CONTENT_TYPE));
                JSONObject json = (JSONObject) JSONValue.parse(new InputStreamReader(conn.getInputStream()));
}


Instance 368

Class90.call(){
                URL url = createURL(RestConstants.ADMIN_JAVA_SYS_PROPS_RESOURCE, Collections.EMPTY_MAP);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
                assertTrue(conn.getHeaderField("content-type").startsWith(RestConstants.JSON_CONTENT_TYPE));
                JSONObject json = (JSONObject) JSONValue.parse(new InputStreamReader(conn.getInputStream()));
                assertTrue(json.containsKey("java.version"));
}


Instance 369

Class1030.call(){
                URL url = createURL(RestConstants.ADMIN_TIME_ZONES_RESOURCE, Collections.EMPTY_MAP);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
                assertTrue(conn.getHeaderField("content-type").startsWith(RestConstants.JSON_CONTENT_TYPE));
                JSONObject json = (JSONObject) JSONValue.parse(new InputStreamReader(conn.getInputStream()));
                assertTrue(json.containsKey(JsonTags.AVAILABLE_TIME_ZONES));
                JSONArray array = (JSONArray) json.get(JsonTags.AVAILABLE_TIME_ZONES);
                assertFalse(array.isEmpty());
}


Instance 370

Class420.call()#0{
                URL url = createURL(RestConstants.ADMIN_BUILD_VERSION_RESOURCE, Collections.EMPTY_MAP);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
                assertTrue(conn.getHeaderField("content-type").startsWith(RestConstants.JSON_CONTENT_TYPE));
                JSONObject json = (JSONObject) JSONValue.parse(new InputStreamReader(conn.getInputStream()));
                             json.get(JsonTags.BUILD_VERSION));
}


Instance 371

Class360.call()#1{
                final String id = bundleJobBean.getId();
                URL url = createURL(id, params);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
                String ct = conn.getHeaderField("content-type");
                assertTrue(ct.startsWith(RestConstants.XML_CONTENT_TYPE));
                String response = IOUtils.getReaderAsString(new InputStreamReader(conn.getInputStream()), -1);
                assertTrue(response!= null && response.length() > 0);
}


Instance 372

Class480.getSLAJSONResponse(Map<String,String> queryParams){
        URL url = createURL("", queryParams);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
        assertTrue(conn.getHeaderField("content-type").startsWith(RestConstants.JSON_CONTENT_TYPE));
        JSONObject json = (JSONObject) JSONValue.parse(new InputStreamReader(conn.getInputStream()));
        JSONArray array = (JSONArray) json.get(JsonTags.SLA_SUMMARY_LIST);
}


Instance 373

Class500.checkWsdl(URL wsdlURL,String hostOrPort)#0{
        HttpURLConnection connection = (HttpURLConnection) wsdlURL.openConnection();
            connection.connect();
            Assert.assertEquals(200, connection.getResponseCode());
            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            while ((line = in.readLine()) != null) {
                if (line.contains("address location")) {
                    Assert.assertTrue(line.contains(hostOrPort));
                    return;
                }
            }
}


Instance 374

Class160.delete(String mapName,String key)#0{
            HttpURLConnection urlConnection = (HttpURLConnection) (new URL(url)).openConnection();
            urlConnection.setRequestMethod("DELETE");
            urlConnection.setDoOutput(true);
            urlConnection.setDoInput(true);
            urlConnection.setUseCaches(false);
            urlConnection.setAllowUserInteraction(false);
            urlConnection.setRequestProperty("Content-type", "text/xml; charset=" + "UTF-8");
            return urlConnection.getResponseCode();
}


Instance 375

Class1360.deleteAll(String mapName)#1{
            HttpURLConnection urlConnection = (HttpURLConnection) (new URL(url)).openConnection();
            urlConnection.setRequestMethod("DELETE");
            urlConnection.setDoOutput(true);
            urlConnection.setDoInput(true);
            urlConnection.setUseCaches(false);
            urlConnection.setAllowUserInteraction(false);
            urlConnection.setRequestProperty("Content-type", "text/xml; charset=" + "UTF-8");
            return urlConnection.getResponseCode();
}


Instance 376

Class500.checkWsdl(URL wsdlURL,String host)#0{
        HttpURLConnection connection = (HttpURLConnection) wsdlURL.openConnection();
            connection.connect();
            Assert.assertEquals(200, connection.getResponseCode());
      BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
      while ((line = in.readLine()) != null) {
        if (line.contains("address location")) {
          Assert.assertTrue(line.contains(host));
          return;
        }
      }
}


Instance 377

Class520.testInjection(){
    URL url = applicationURL();
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    conn.setRequestProperty("Accept-Language", "fr-FR");
    conn.connect();
    assertEquals(200, conn.getResponseCode());
    String result = Tools.read(conn.getInputStream());
    assertTrue("Was expecting <" + result + "> to contain def", result.contains("def"));
}


Instance 378

Class400.downloadUrl(final URL url){
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setReadTimeout(NET_READ_TIMEOUT_MILLIS /* milliseconds */);
        conn.setConnectTimeout(NET_CONNECT_TIMEOUT_MILLIS /* milliseconds */);
        conn.setRequestMethod("GET");
        conn.setDoInput(true);
        conn.connect();
        return conn.getInputStream();
}


Instance 379

Class1430.call()#0{
                params.put("user", getTestUser());
                URL url = createURL("", params);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("POST");
                conn.setRequestProperty("content-type", RestConstants.XML_CONTENT_TYPE);
                conn.setDoOutput(true);
                assertEquals(HttpServletResponse.SC_BAD_REQUEST, conn.getResponseCode());
                String message = conn.getHeaderField(RestConstants.OOZIE_ERROR_MESSAGE);
                assertEquals("E0701", error);
}


Instance 380

Class1190.getInputStreamFromUrl(URL url){
    logger.debug("Connecting to URL " + url.toString());
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod("GET");
    connection.addRequestProperty("User-Agent", USER_AGENT);
    connection.connect();
    return new Buffe
}


Instance 381

Class960.testHelloWorld(){
        URL getUrl = UriBuilder.fromUri(getBaseUri()).path(App.ROOT_PATH).build().toURL();
        HttpURLConnection connection = (HttpURLConnection) getUrl.openConnection();
            connection.setDoOutput(true);
            connection.setInstanceFollowRedirects(false);
            connection.setRequestMethod("GET");
            connection.setRequestProperty("Content-Type", "text/plain");
            assertEquals(HttpURLConnection.HTTP_OK, connection.getResponseCode());
            connection.disconnect();
}


Instance 382

Class230.call()#0{
                Map<String, String> params = new HashMap<String, String>();
                params.put(RestConstants.ACTION_PARAM, RestConstants.JOB_ACTION_START);
                URL url = createURL(MockCoordinatorEngineService.JOB_ID + 1, params);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("PUT");
                conn.setRequestProperty("content-type", RestConstants.XML_CONTENT_TYPE);
                conn.setDoOutput(true);
                assertEquals(HttpServletResponse.SC_BAD_REQUEST, conn.getResponseCode());
                assertEquals(null, MockCoordinatorEngineService.did);
}


Instance 383

Class200.verifyHttpResponseCode(int expectedCode,URL url){
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod("GET");
    connection.connect();
    assertEquals(expectedCode, connection.getResponseCode());
}


Instance 384

Class1120.exists(Path path){
    URL url = makeUrl( path );
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod( "HEAD" );
    connection.connect();
    debugConnection( connection );
    return connection.getResponseCode() == 200;
}


Instance 385

Class1110.open(Path path,int i)#0{
    URL url = makeUrl( path );
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod( "GET" );
    connection.connect();
    debugConnection( connection );
    return new FSDataInputStream( new FSDigestInputStream( connection.getInputStream(), getMD5SumFor( getConf(), path ) ) );
}


Instance 386

Class100.getRemoteFileSize(final URL downloadUrl){
        final URLConnection urlConn = downloadUrl.openConnection();
        final HttpURLConnection httpConn = (HttpURLConnection)urlConn;
        httpConn.setRequestMethod("HEAD");
        if (httpConn.getResponseCode() == 200) {
            return urlConn.getContentLengthLong();
        } else {
            throw new IOException("Url not reachable : " + downloadUrl.toString());
        }
}


Instance 387

Class270.verifyURLAvailable(URL url){
    if (null == url)
      return false;
      connection = (HttpURLConnection) url.openConnection();
      connection.setRequestMethod("HEAD");
      return (200 == connection.getResponseCode());
}


Instance 388

Class270.openConnection(URL url){
            if (logger.isFinestEnabled()) {
                logger.finest("Opening collector connection:" + url);
            }
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoOutput(true);
            connection.setConnectTimeout(CONNECTION_TIMEOUT_MILLIS);
            connection.setReadTimeout(CONNECTION_TIMEOUT_MILLIS);
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestMethod("POST");
}


Instance 389

Class280.doesUrlExistAndIsImage(URL url)#0{
            HttpURLConnection con = (HttpURLConnection) url.openConnection();
            con.setRequestMethod("HEAD");
            boolean result = (con.getResponseCode() == HttpURLConnection.HTTP_OK)
                    && con.getContentType().contains("image");
            con.disconnect();
}


Instance 390

Class1100.createGETRequestConnection(URL website){
        HttpURLConnection connection = (HttpURLConnection) website.openConnection();
        connection.setRequestMethod("GET");
        connection.setConnectTimeout(5000);
        connection.setReadTimeout(5000);
        connection.connect();
}


Instance 391

Class230.call()#0{
                Map<String, String> params = new HashMap<String, String>();
                params.put(RestConstants.JOB_SHOW_PARAM, RestConstants.JOB_SHOW_GRAPH);
                URL url = createURL(MockDagEngineService.JOB_ID + 1 + MockDagEngineService.JOB_ID_END, params);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                assertEquals(HttpServletResponse.SC_BAD_REQUEST, conn.getResponseCode());
                assertEquals(ErrorCode.E0306.name(), conn.getHeaderField(RestConstants.OOZIE_ERROR_CODE));
}


Instance 392

Class950.testGetResponseCodeNoResponseBody()#0{
        server.enqueue(new MockResponse()
                .addHeader("abc: def"));
        server.play();
        URL url = server.getUrl("/");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setDoInput(false);
        assertEquals("def", conn.getHeaderField("abc"));
        assertEquals(200, conn.getResponseCode());
            conn.getInputStream();
}


Instance 393

Class430.isUrlValid(URL url)#0{
      HttpURLConnection connection = (HttpURLConnection)url.openConnection();
      connection.setRequestMethod("HEAD");
      int responseCode = connection.getResponseCode();
}


Instance 394

Class790.call()#0{
                final String id = bundleJobBean.getId();
                URL url = createURL(id, params);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("PUT");
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
}


Instance 395

Class1460.existsHttpURL(URL url)#0{
      HttpURLConnection con = (HttpURLConnection) url.openConnection();
      con.setRequestMethod("HEAD");
      return (con.getResponseCode() == HttpURLConnection.HTTP_OK);
}


Instance 396

Class150.getHttpCode(URL resource)#0{
    HttpURLConnection con = (HttpURLConnection) resource.openConnection();
    con.setRequestMethod("HEAD");
    return con.getResponseCode();
}


Instance 397

Class1030.call()#1{
                final String id = bundleJobBean.getId();
                URL url = createURL(id, params);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                assertEquals(HttpServletResponse.SC_OK, conn.getResponseCode());
}


Instance 398

Class180.exists()#1{
            HttpURLConnection con = (HttpURLConnection) URL.openConnection();
            con.setRequestMethod("HEAD");
            return (con.getResponseCode() == HttpURLConnection.HTTP_OK);
}


Instance 399

Class340.getFileSize(URL url)#0{
            conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("HEAD");
            conn.getInputStream();
            return conn.getContentLength();
}


Instance 400

Class1360.openPostResponseConnection()#0{
            if (logger.isFinestEnabled()) {
                logger.finest("Opening sendResponse connection:" + url);
            }
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoOutput(true);
            connection.setRequestMethod("POST");
            connection.setConnectTimeout(CONNECTION_TIMEOUT_MILLIS);
            connection.setReadTimeout(CONNECTION_TIMEOUT_MILLIS);
}


Instance 401

Class760.getUrlConnection(URL url){
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestMethod("POST");
        connection.setUseCaches(false);
        connection.setDoOutput(true);
        connection.connect();
}


Instance 402

Class300.createConnection(URL url,int timeout)#0{
    HttpURLConnection connection = (HttpURLConnection)url.openConnection();
    connection.setDoInput(true);
    connection.setDoOutput(true);
    connection.setRequestMethod("POST");
    connection.setConnectTimeout(timeout);
    connection.setReadTimeout(timeout);
    connection.setRequestProperty("User-Agent", "Die Fledermaus/11");
}


Instance 403

Class700.testQueryRedirect(){
        URL url = new URI("http",null,"localhost",HTTP_SERVER_PORT,"/path","redirect=/a/b/c/d?q",null).toURL();
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setInstanceFollowRedirects(false);
        conn.connect();
        assertEquals(302, conn.getResponseCode());
        assertEquals("Temporary Redirect", conn.getResponseMessage());
        assertEquals("/a/b/c/d?q",conn.getHeaderField("Location"));
}


Instance 404

Class360.openConnection(String path,String query){
    query = addDelegationTokenParam(query);
    final URL url = getNamenodeURL(path, query);
    final HttpURLConnection connection = (HttpURLConnection)url.openConnection();
      connection.setRequestMethod("GET");
      connection.connect();
      throwIOExceptionFromConnection(connection, ioe);
}


Instance 405

Class480.createPostConnection(String url)#0{
    conn = (HttpURLConnection) (new URL(url)).openConnection();
    conn.setDoInput(true);
    conn.setDoOutput(true);
    conn.setRequestMethod(LumongoConstants.POST);
    conn.connect();
}


Instance 406

Class240.doGet(URL url){
      HttpURLConnection urlc = (HttpURLConnection) url.openConnection();
      if (HttpURLConnection.HTTP_OK != urlc.getResponseCode()) {
        fatal("Solr returned an error #" + urlc.getResponseCode() + 
            " " + urlc.getResponseMessage());
      }
      fatal("An error occured posting data to "+url+". Please check that Solr is running.");
}


Instance 407

Class1380.getHttpURLConnection(URL url,int timeout){
                HttpURLConnection httpURLConnection = (HttpURLConnection) url.openConnection();
                httpURLConnection.setConnectTimeout(40000);
                httpURLConnection.setReadTimeout(timeout);
                httpURLConnection.setDoOutput(true);
                httpURLConnection.setDoInput(true);
                httpURLConnection.setUseCaches(false);
                httpURLConnection.setAllowUserInteraction(false);
                httpURLConnection.setRequestMethod("POST");
}


Instance 408

Class570.testPathParam()#0{
    URL url = applicationURL();
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    conn.setInstanceFollowRedirects(false);
    conn.connect();
    assertEquals(302, conn.getResponseCode());
    Map<String, String> headers = Tools.responseHeaders(conn);
    String redirect = headers.get("Location");
    driver.get(redirect);
}


Instance 409

Class980.testPathParam(){
    URL url = applicationURL();
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    conn.setInstanceFollowRedirects(false);
    conn.connect();
    assertEquals(200, conn.getResponseCode());
    assertEquals("bar_value", bar);
}


Instance 410

Class670.getHttpURLConnection(URL requestUrl)#0{
      conn = (HttpURLConnection)requestUrl.openConnection();
      conn.setRequestMethod("POST");
      conn.setRequestProperty("Content-Type", "application/json");
      conn.setUseCaches (false);
      conn.setDoOutput(true);
}


Instance 411

Class560.testQueryStatus(){
        URL url = new URI("http",null,"localhost",HTTP_SERVER_PORT,"/path","status=303 See Other",null).toURL();
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.connect();
        assertEquals(303, conn.getResponseCode());
        assertEquals("See Other", conn.getResponseMessage());
}


Instance 412

Class360.createConnection(URL url,String method)#0{
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod(method);
        if (method.equals("POST") || method.equals("PUT")) {
            conn.setDoOutput(true);
        }
}


Instance 413

Class600.testRender()#0{
    URL url = applicationURL();
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    conn.connect();
    assertEquals(404, conn.getResponseCode());
    url = applicationURL("/foo");
    driver.get(url.toString());
}


Instance 414

Class1290.POST(Object json,URL url){
    HttpURLConnection connection = (HttpURLConnection)url.openConnection();
    connection.setDoOutput(true);
    connection.setInstanceFollowRedirects(false);
    connection.setRequestMethod("POST");
    connection.setRequestProperty("Content-Type", "application/json");
    OutputStream output = connection.getOutputStream();
    m_jsonMapper.writeValue(output, json);
}


Instance 415

Class1250.isNotFound(URL url){
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.connect();
        return connection.getResponseCode() == HttpURLConnection.HTTP_NOT_FOUND;
}


Instance 416

Class500.checkWsdl(URL wsdlURL)#0{
        HttpURLConnection connection = (HttpURLConnection) wsdlURL.openConnection();
            connection.connect();
            Assert.assertEquals(proxyUsed.toString(), HttpServletResponse.SC_OK, connection.getResponseCode());
}


Instance 417

Class1110.getTotalBytes(URL url)#0{
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("HEAD");
        conn.setRequestProperty("accept",  "*/*");
}


Instance 418

Class1280.sendRequest(String method,URL url,String cookie,boolean followRedirects)#0{
        HttpURLConnection conn = (HttpURLConnection)url.openConnection();
        conn.setRequestMethod(method);
        conn.setDoInput(true);
        conn.setInstanceFollowRedirects(followRedirects);
}


Instance 419

Class600.httpSend(URL url)#0{
  (HttpURLConnection) url.openConnection();
conn.setRequestMethod("POST");
conn.setDoOutput(true);
}


Instance 420

Class10.downloadTempLocally(URL url)#0{
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            if (connection.getResponseCode() == 200) {
                java.io.File temp = java.io.File.createTempFile("urlToVfs", "tmp");
                FileOutputStream out = new FileOutputStream(temp);
                DataInputStream in = new DataInputStream(connection.getInputStream());

                int len; byte ch[] = new byte[1024];
                while ((len = in.read(ch)) != -1) {out.write(ch, 0, len);}

                connection.disconnect();
                return temp;
            }
}


Instance 421

Class50.getGzipResult(final String url)#0{
        final HttpURLConnection conn = (HttpURLConnection) (new URL(url)).openConnection();
        conn.setRequestProperty("Accept-Encoding", "gzip,deflate");
        conn.setDoInput(true);
        InputStream in = conn.getInputStream();
        Assert.assertTrue(conn.getContentEncoding().contains("gzip"));
        in = new GZIPInputStream(in);
        String result = read(in);
        in.close();
}


Instance 422

Class380.connectToPath(final String path){
    final URL url = url(path);
    final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod("GET");
}


Instance 423

Class610.assertServletReturnsResponseCode(int responseCode,URL pageUrl){
        HttpURLConnection connection = (HttpURLConnection) pageUrl.openConnection();
            assertEquals(responseCode, connection.getResponseCode());
            connection.disconnect();
}


Instance 424

Class520.openConnection(final URL url){
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setDoInput(true);
        connection.setDoOutput(true);
        connection.setRequestMethod("POST");
}


Instance 425

Class960.pushData(URL target,String data)#0{
    HttpURLConnection c = (HttpURLConnection) target.openConnection();
    c.setDoOutput(true);
    c.setRequestMethod("PUT");
    c.addRequestProperty("Content-type", "application/json");
    OutputStreamWriter wr = new OutputStreamWriter(c.getOutputStream());
    wr.write(data);
    wr.flush();
}


Instance 426

Class880.test(URL initialURL){
    HttpURLConnection conn = (HttpURLConnection)initialURL.openConnection();
    conn.addRequestProperty("Accept-Language", "fr-FR");
    assertEquals(200, conn.getResponseCode());
    assertEquals(Locale.FRANCE, locale);
}


Instance 427

Class760.assertResponseCode(int expected,URL url){
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            assertEquals(expected, conn.getResponseCode());
            conn.disconnect();
}


Instance 428

Class970.load(URL url)#0{
            HttpURLConnection c = (HttpURLConnection) url.openConnection();
            c.setConnectTimeout(2000);
            c.connect();
            String headerField = c.getHeaderField(0);
            return headerField.endsWith("200 OK");
}


Instance 429

Class1100.performGetRequest(URL url)#1{
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestProperty("Referer", REFERRER);
            return readFullyAndClose(connection.getInputStream()).trim();
}


Instance 430

Class600.testPathParam()#2{
    String pass = driver.findElement(By.tagName("body")).getText();
    assertEquals("juu", pass);
    url = applicationURL("/foo/bar");
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    assertEquals(200, conn.getResponseCode());
}


Instance 431

Class460.testWith(String expected,Charset charset)#2{
    URL url = applicationURL();
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    assertEquals(200, conn.getResponseCode());
    Map<String, String> headers = Tools.responseHeaders(conn);
    String contentType = headers.get("Content-Type");
    assertNotNull(contentType);
}


Instance 432

Class470.getNotificationsJsonData()#0{
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setConnectTimeout(8000);
            return connection.getInputStream();
}


Instance 433

Class1350.testStatus(){
    URL url = applicationURL("/status");
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    assertEquals(200, conn.getResponseCode());
    Map<String, String> headers = Tools.responseHeaders(conn);
    assertEquals("Juzu/1.0.0", headers.get("X-Powered-By"));
}


Instance 434

Class1160.call(){
                Map<String, String> params = new HashMap<String, String>();
                params.put(RestConstants.LEN_PARAM, "5");
                URL url = createURL("", params);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();
                assertEquals(HttpServletResponse.SC_BAD_REQUEST, conn.getResponseCode());
}


Instance 435

Class0.testPathParam(){
    URL url = applicationURL();
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
    assertEquals(500, conn.getResponseCode());
}


Instance 436

Class1210.run(){
        final URL url = mockWebServer.getUrl(path);
          conn = (HttpURLConnection) url.openConnection();
          responseCode.set(conn.getResponseCode()); // Force the connection to hit the "server".
}


Instance 437

Class1150.simpleDispatch()#4{
    mockWebServer.setDispatcher(dispatcher);
    final URL url = mockWebServer.getUrl("/");
    final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.getResponseCode(); // Force the connection to hit the "server".
}


Instance 438

Class530.urlGetBytes(URL url)#0{
    URLConnection conn = url.openConnection();
    HttpURLConnection hc = (HttpURLConnection)conn;
    assertEquals(HttpURLConnection.HTTP_OK, hc.getResponseCode());
}


Instance 439

Class790.testOriginServerSends407()#0{
        server.enqueue(new MockResponse().setResponseCode(407));
        server.play();
        URL url = server.getUrl("/");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.getResponseCode();
}


Instance 440

Class360.openConnection(URL url){
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestProperty(HDR_X_FORWARDED_SSL, "on");
        conn.connect();
}


Instance 441

Class240.getInputStream(String path,List<Parameter> parameters)#1{
            logger.debug("GET URL: {}", url.toString());
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.addRequestProperty("Pragma", "no-cache"); 
        conn.setRequestMethod("GET");
}


Instance 442

Class440.getInputStream(String path,List<Parameter> parameters)#0{
      LOG.debug("GET URL: {}", url.toString());
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    conn.addRequestProperty("Pragma", "no-cache");
    conn.setRequestMethod("GET");
}


Instance 443

Class290.getWebContent(URL url)#0{
    HttpURLConnection con = (HttpURLConnection) url.openConnection();
    con.setInstanceFollowRedirects(true) ;
    BufferedReader input = new BufferedReader(new InputStreamReader(con.getInputStream(), "UTF-8")) ;
}


Instance 444

Class1270.connectToUrl(URL url){
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setConnectTimeout(CONNECT_TIMEOUT_MS);
    connection.setReadTimeout(READ_TIMEOUT_MS);
    connection.connect();
}


Instance 445

Class1370.getConnectedDownloadConnection(URL downloadURL)#0{
            connection = (HttpURLConnection) downloadURL.openConnection();
            connection.setConnectTimeout(CONNECT_TIMEOUT);
            connection.setReadTimeout(READ_TIMEOUT);
            connection.connect();
}


Instance 446

Class890.openConnection(URL url)#1{
        if (conn == null) {
            conn = (HttpURLConnection) url.openConnection();
        }
        conn.setConnectTimeout(5000);
        conn.setReadTimeout(25000);
}


Instance 447

Class1290.buildHttpConnection(URL url){
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestProperty("User-Agent", USER_AGENT);
        connection.setConnectTimeout(20000);
        connection.setReadTimeout(20000);
}


Instance 448

Class490.doGet(final String url)#2{
                HttpURLConnection httpUrlConnection = (HttpURLConnection) (new URL(url)).openConnection();
                BufferedReader rd = new BufferedReader(new InputStreamReader(httpUrlConnection.getInputStream()));
}


Instance 449

Class420.getSensorDetails(URL target,String url)#2{
    HttpURLConnection c = (HttpURLConnection) target.openConnection();
    BufferedReader in = new BufferedReader(new InputStreamReader(c.getInputStream()));
}


Instance 450

Class510.getPDFContent(URL url)#2{
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        InputStream is = connection.getInputStream();
        PDDocument pdd = PDDocument.load(is);
}


Instance 451

Class10.getUrl(HttpRequest request){
        URL url = request.getUrl();
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        copyHeadersExceptEncoding(request, conn);
        return ioUtils.toString(conn.getInputStream());
}


Instance 452

Class350.ssoLogout()#0{
        URL logoutUrl = createURLFromCasURI(GeoServerCasConstants.LOGOUT_URI);
        HttpURLConnection conn = (HttpURLConnection) logoutUrl.openConnection();
        addCasCookies(conn);
        conn.getInputStream().close();
}


Instance 453

Class1340.testGetContentLength()#0{
            conn = (HttpURLConnection) (new URL(broadURLString)).openConnection();
            String contentLength = conn.getHeaderField("Content-length");
            assertEquals("249250621", contentLength);
            if (conn != null) {
                conn.disconnect();  // <- this really doesn't do anything (see Sun documentation)
            }
}


Instance 454

Class700.openDefaultConnection(URL url,int connectTimeOut,int readTimeOut){
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setConnectTimeout(connectTimeOut);
        connection.setReadTimeout(readTimeOut);
        connection.setUseCaches(false);
        connection.addRequestProperty("User-Agent", "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/29.0.1547.66 Safari/537.36");
}


Instance 455

Class20.performPostRequest(URL url)#1{
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoOutput(true);
            connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
            PrintWriter out = new PrintWriter(connection.getOutputStream());
                out.println("foo=bar");
                out.close();
}


Instance 456

Class630.getConnection(URL url,int timeout){
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    connection.setInstanceFollowRedirects(true);
    connection.setConnectTimeout(timeout);
}


Instance 457

Class30.connect(final String path,final int timeout_seconds)#0{
        final URI uri = new URI("http", null, host, port, path, null, null);
        final URL url = uri.toURL();
        final HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestProperty("Content-Type", "text/xml");
}


Instance 458

Class260.performHeadHTTPMethod(URL url)#0{
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setUseCaches(false);
        conn.setAllowUserInteraction(true);
        conn.setRequestProperty("Connection", "Keep-Alive");
}


Instance 459

Class1490.open(URL url){
        HttpURLConnection c = (HttpURLConnection)url.openConnection();
        c.setReadTimeout(TIMEOUT);
        c.setConnectTimeout(TIMEOUT);
}


Instance 460

Class20.newHttpConnection(URL url)#1{
      HttpURLConnection connection = (HttpURLConnection)url.openConnection();
      connection.setRequestProperty("User-Agent", userAgent);
}


Instance 461

Class1060.HttpFileDownloadInputStream(URL url)#0{
        if (!url.getProtocol().equals("http")) { 
            throw new MalformedURLException("URL is not a http URL"); 
        }
        connection = (HttpURLConnection) url.openConnection();
        connection.setDoInput(true);
        connection.setDoOutput(false);
        connection.setUseCaches(false);
        connection.setRequestMethod("GET"); 
        connection.connect();
        input = connection.getInputStream();
}


Instance 462

Class240.openHttpConnection(URL url)#0{
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setDoInput(true);
        conn.setDoOutput(false);
}


Instance 463

Class750.getHttpURLConnection(URL url)#1{
    if (proxy != null) {
      return (HttpURLConnection) url.openConnection(proxy);
    } else {
      return (HttpURLConnection) url.openConnection();
    }
}


Instance 464

Class1130.getXML(String url,XMLHandler handler)#0{
            Proxy proxy = DefaultToolOptions.getDefaultProxy();
            if (proxy != null) {
                connection = (HttpURLConnection) endpoint.openConnection(proxy);
            } else {
                connection = (HttpURLConnection) endpoint.openConnection();
            }
}


Instance 465

Class1210.openConnection(URL url)#0{
    if (proxy != null) {
      return (HttpURLConnection) url.openConnection(proxy);
    } else {
      return (HttpURLConnection) url.openConnection();
    }
}


Instance 466

Class1030.createConnection(String uri)#2{
    if ( null == proxy )     {
      return (HttpURLConnection) url.openConnection();
    } else {
      return (HttpURLConnection) url.openConnection( proxy );
    }
}


Instance 467

Class780.createConnection(URL url)#0{
      Proxy proxy = getProxy();
      if (proxy != null)
            return (HttpURLConnection) url.openConnection(proxy);
        else
          return (HttpURLConnection) url.openConnection();
}


Instance 468

Class190.initConnection(HttpRequest request)#0{
      URL url = request.getEndpoint().toURL();
      HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxyForURI.apply(request.getEndpoint()));
      if (connection instanceof HttpsURLConnection) {
         HttpsURLConnection sslCon = (HttpsURLConnection) connection;
         if (utils.relaxHostname())
            sslCon.setHostnameVerifier(verifier);
         if (sslContextSupplier != null) {
             // used for providers which e.g. use certs for authentication (like FGCP)
             // Provider provides SSLContext impl (which inits context with key manager)
             sslCon.setSSLSocketFactory(sslContextSupplier.get().getSocketFactory());
         } else if (utils.trustAllCerts()) {
             sslCon.setSSLSocketFactory(untrustedSSLContextProvider.get().getSocketFactory());
         }
      }
}


Instance 469

Class360.openConnection(String path,String query)#0{
      if (LOG.isTraceEnabled()) {
        LOG.trace("url=" + url);
      }
      return (HttpURLConnection)url.openConnection();
}


Instance 470

Class600.testMethods()#0{
      HttpURLConnection conn = (HttpURLConnection)url.openConnection();
      conn.setDoOutput(doOutput[i]);
}


Instance 471

Class1360.createConnection(URL url)#0{
      HttpURLConnection connection = (HttpURLConnection) url.openConnection();
      connection.addRequestProperty("User-Agent", "HockeySDK/Android");
      connection.setInstanceFollowRedirects(true);
}


Instance 472

Class370.testRedirectUnsecuredRoot()#3{
        URL url = serverHttpUri.resolve("/").toURL();
        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
        connection.setInstanceFollowRedirects(false);
        connection.setAllowUserInteraction(false);
}


Instance 473

Class1240.testRedirectSecuredRoot()#1{
        URL url = serverHttpsUri.resolve("/").toURL();
        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
        connection.setInstanceFollowRedirects(false);
        connection.setAllowUserInteraction(false);
}


Instance 474

Class480.testAccessSecured404()#0{
        URL url = serverHttpsUri.resolve("/nothing/here").toURL();
        HttpURLConnection connection = (HttpURLConnection)url.openConnection();
        connection.setInstanceFollowRedirects(false);
        connection.setAllowUserInteraction(false);
}


Instance 475

Class830.getConnection(URL url){
        HttpURLConnection c = (HttpURLConnection) url.openConnection();
        c.setInstanceFollowRedirects(followRedirects);
}


Instance 476

Class1520.fetchResource(URL actualUrl,RDFFormat rdfFormat)#0{
      org.openrdf.model.URI foafdocUri = vf.createURI(base.toString());
      HttpURLConnection conn = (HttpURLConnection) base.openConnection();
}


Instance 477

Class1050.checkHttpURL(URL url)#1{
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        String contentType = connection.getContentType();
}


Instance 478

Class1120.getRequest(String redirectUrl)#0{
                URL targetUrl = URI.create((redirectUrl != null) ? redirectUrl : url).toURL();
                urlConnection = (HttpURLConnection)targetUrl.openConnection();
                setParameters(context, urlConnection, fParameters);
                urlConnection.setDoOutput(true);
                urlConnection.setRequestProperty("Content-Type", "text/xml; charset=utf-8");
}


Instance 479

Class920.getRequest(String redirectUrl)#1{
                URL targetUrl = URI.create((redirectUrl != null) ? redirectUrl : url).toURL();
                urlConnection = (HttpURLConnection)targetUrl.openConnection();
                setParameters(context, urlConnection, fParameters);
}


Instance 480

Class1330.sendRequestViaProxy(URL url){
        Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress(System.getProperty("http.proxyHost"), Integer.parseInt(System.getProperty("http.proxyPort"))));
        return (HttpURLConnection) url.openConnection(proxy);
}


Instance 481

Class1170.doGet(URL url)#1{
      HttpURLConnection urlc = (HttpURLConnection) url.openConnection();
}


Instance 482

Class520.createConnection(URL url)#2{
        connection = (HttpURLConnection) url.openConnection();
}


Instance 483

Class810.create(URL url){
        return (HttpURLConnection) url.openConnection();
}


Instance 484

Class760.getHttpURLConnection(URL url)#0{
            (HttpURLConnection) (new URL(url.toString() + tokenString)).openConnection();
        this.connectionConf.configure(httpURLConnection);
}


Instance 485

Class1060.JDKHttpConnection(URL url){
    this.wrappedUrlConnection = (HttpURLConnection) url.openConnection();
}


Instance 486

Class230.openConnection(URL url){
    return (HttpURLConnection) url.openConnection();
}


Instance 487

Class440.create(URL url,Proxy proxy){
                return (HttpURLConnection) url.openConnection(proxy);
}


Instance 488

Class440.create(URL url){
                return (HttpURLConnection) url.openConnection();
}


Instance 489

Class1210.openConnection(URL url)#1{
      return (HttpURLConnection) url.openConnection();
}


Instance 490

Class10.connect(URL url){
                return (HttpURLConnection) url.openConnection(p);
}


Instance 491

Class140.openHttpConnection(URL httpURL)#1{
            Main.debug("Opening HTTP connection to "+httpURL.toExternalForm());
        HttpURLConnection connection = (HttpURLConnection) httpURL.openConnection();
}


Instance 492

Class750.getHttpURLConnection(URL url)#0{
      return (HttpURLConnection) url.openConnection();
}


Instance 493

Class1160.getHttpURLConnection(URL url){
            return (HttpURLConnection)url.openConnection(proxy);
}


Instance 494

Class1130.getJsonRpcConnection(URL url,String request,String auth){
    return getJsonRpcConnection((HttpURLConnection) url.openConnection(), request, auth);
}


Instance 495

Class1130.Work(URL url,URL mainUrl,String auth){
    this((HttpURLConnection) url.openConnection(), url, auth);
}


Instance 496

Class1130.getXML(String url,XMLHandler handler)#3{
                connection = (HttpURLConnection) endpoint.openConnection();
}


Instance 497

Class570.testRouteToMethod()#3{
      HttpURLConnection conn = (HttpURLConnection)url.openConnection();
}


Instance 498

Class500.getHttpUrlConnection(URL urlForServlet){
    return (HttpURLConnection) urlForServlet.openConnection();
}


Instance 499

Class470.ConnBuilder(URL url)#0{
                con = (HttpURLConnection) url.openConnection();
}


Instance 500

Class1030.createConnection(String uri)#0{
      return (HttpURLConnection) url.openConnection();
}


Instance 501

Class150.createConnection(URL url)#3{
        connection = (HttpURLConnection) url.openConnection();
}


Instance 502

Class210.connect(MockWebServer server,URL url)#1{
                return (HttpURLConnection) url.openConnection();
}


Instance 503

Class210.connect(MockWebServer server,URL url)#0{
                return (HttpURLConnection) url.openConnection();
}


Instance 504

Class210.connect(MockWebServer server,URL url){
                return (HttpURLConnection) url.openConnection(server.toProxyAddress());
}


Instance 505

Class420.testMethodNotMapped()#1{
    URL url = applicationURL();
    HttpURLConnection conn = (HttpURLConnection)url.openConnection();
}


Instance 506

Class250.testBasicAuthentication(final String user,final String key)#1{
    URL retrievalURL = JConfig.getURL("http://localhost:9909/services/sqsurl");
    HttpURLConnection huc = (HttpURLConnection) retrievalURL.openConnection();
}


Instance 507

Class1490.JDKHttpConnection(URL url,Proxy proxy){
    this.wrappedUrlConnection = (HttpURLConnection) url
        .openConnection(proxy);
}


Instance 508

Class1490.makeRequest(URL url)#1{
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
}


Instance 509

Class130.getIPPConnection(URL url)#0{
            connection = (HttpURLConnection)url.openConnection();
}


Instance 510

Class410.isAddressReachable(String url,int timeout)#1{
      HttpURLConnection urlConnect = (HttpURLConnection) test.openConnection();
}


Instance 511

Class410.create(URL url,Proxy proxy){
        return (HttpURLConnection) url.openConnection(proxy);
}


Instance 512

Class780.createConnection(URL url)#1{
          return (HttpURLConnection) url.openConnection();
}


Instance 513

Class1530.httpOpen(String method,URL u)#1{
    final Proxy proxy = HttpSupport.proxyFor(proxySelector, u);
    HttpURLConnection conn = (HttpURLConnection) u.openConnection(proxy);
}


Instance 514

Class890.openConnection(URL url)#1{
        HttpURLConnection con = (HttpURLConnection) url.openConnection();
}


Instance 515

Class890.createConnection(URL endpoint){
        return (HttpURLConnection) endpoint.openConnection();
}


Instance 516

Class1100.getServedImage(URL imageUrl)#0{
        HttpURLConnection connection = (HttpURLConnection) imageUrl.openConnection();
}


Instance 517

Class1370.getConnection(URL url){
                    return (HttpURLConnection) url.openConnection(proxy);
}


Instance 518

Class540.openConnection(URL requestTokenURL)#2{
      HttpURLConnection connection = (HttpURLConnection) requestTokenURL.openConnection(selectProxy(requestTokenURL));
}


Instance 519

Class830.connectForMultipart()#0{
    con = (HttpURLConnection) ( new URL(url)).openConnection();
    con.setRequestMethod("POST");
    con.setDoInput(true);
    con.setDoOutput(true);
    con.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
    con.connect();
    os = con.getOutputStream();
}


Instance 520

Class290.openConnection(URL targetUrl)#3{
        HttpURLConnection conn = (HttpURLConnection) targetUrl.openConnection();
}


Instance 521

Class220.getHttpURLConnection(URL url)#2{
      return (HttpURLConnection) (new URL(url.toString() + tokenString)).openConnection();
}


Instance 522

Class220.open(URL url){
            return (HttpURLConnection) url.openConnection();
}


Instance 523

Class1430.openConnection(URL url)#0{
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
}


Instance 524

Class1110.getAsyncUrlRangeInputStream(URL url,ByteRange byteRange)#0{
    connection = (HttpURLConnection) url.openConnection();
}


Instance 525

Class60.getAsyncUrlRangeInputStream(URL url,ByteRange byteRange,int index,SpeedListener networkSpeedListener)#1{
    connection = (HttpURLConnection) url.openConnection();
}


Instance 526

Class60.openConnection(URL url)#1{
    return sClient != null ? sClient.open(url) : (HttpURLConnection) url.openConnection();
}


Instance 527

Class70.create(URL url){
        return (HttpURLConnection) url.openConnection();
}


Instance 528

Class70.openServerConnection(URL loc){
        return (HttpURLConnection) loc.openConnection();
}


Instance 529

Class70.create(URL url,Proxy proxy){
        return (HttpURLConnection) url.openConnection(proxy);
}


Instance 530

Class900.sendString(final URL url,final String dataString,final String userAgent)#2{
      connection = (HttpURLConnection) url.openConnection();
      setUserAgent(connection, userAgent);
      return sendString(connection, dataString);
}


Instance 531

Class900.getConnection(URL endpointUrl){
                HttpURLConnection result = (HttpURLConnection) endpointUrl.openConnection();
                return wrapRedirectedHttp(result);
}


Instance 532

Class900.getConnection(final URL url){
            return (HttpURLConnection) url.openConnection();
}


Instance 533

Class1020.getResponse(URL url,int numberOfRetries){
    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
    return getResponse(connection, numberOfRetries);
}


Instance 534

Class620.getSyncUrlRangeInputStream(URL url,ByteRange byteRange,int index,SpeedListener networkSpeedListener)#2{
    connection = (HttpURLConnection) url.openConnection();
}


Instance 535

Class0.createConnection(URL url){
        return (HttpURLConnection) url.openConnection();
}


Instance 536

Class240.openURLConnection(URL url){
    return (HttpURLConnection) url.openConnection();
}


Instance 537

Class800.openConnection(URL url){
        return (HttpURLConnection) url.openConnection();
}


Instance 538

Class690.grab(URL url)#1{
        wmsInterface.urlConn = (HttpURLConnection)url.openConnection();
        wmsInterface.urlConn.setRequestProperty("Connection", "close");
        wmsInterface.urlConn.setRequestMethod("GET");
}


Instance 539

Class1330.getLocation(final URL url){
    URLConnection connection = url.openConnection();
    if(connection instanceof HttpURLConnection){
      int responseCode = ((HttpURLConnection)connection).getResponseCode();
      if (responseCode == HttpURLConnection.HTTP_MOVED_TEMP
        || responseCode == HttpURLConnection.HTTP_MOVED_PERM
          || responseCode == HttpURLConnection.HTTP_SEE_OTHER){
        String redirectUrl = connection.getHeaderField("Location");
        return getLocation(new URL(redirectUrl));
      }
    }
}


Instance 540

Class10.copy(InputStream in,URL out,String method){
    URLConnection c = out.openConnection();
    if (c instanceof HttpURLConnection && method != null) {
      HttpURLConnection http = (HttpURLConnection) c;
      http.setRequestMethod(method);
    }
    c.setDoOutput(true);
    OutputStream os = c.getOutputStream();
      copy(in, os);
      os.close();
}


Instance 541

Class1470.createConnection(URI uri){
    URL url = uri.toURL();
    URLConnection connection = url.openConnection();
    if (!(connection instanceof HttpURLConnection)) {
      throw new HttpTransportException("URI [" + uri + "] is not an HTTP URL");
    }
    else {
      HttpURLConnection httpURLConnection = (HttpURLConnection) connection;
      prepareConnection(httpURLConnection);
      return new HttpUrlConnection(httpURLConnection);
    }
}


Instance 542

Class1430.getArchiveReader(final URL f,final long offset)#1{
        URLConnection connection = f.openConnection();
        if (connection instanceof HttpURLConnection) {
          addUserAgent((HttpURLConnection)connection);
        }
}


Instance 543

Class1360.slurp(final URL url){
        final HttpURLConnection urlConnection = HttpURLConnection.class.cast(url.openConnection());
            urlConnection.setRequestProperty("Accept", "text/plain");
            return IO.slurp(urlConnection.getInputStream());
            urlConnection.disconnect();
}