If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testRejectHybi00() throws Exception {
    testReject(WebsocketVersion.V00, null, 502);
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testInvalidSubProtocolHybi17() throws Exception {
    testInvalidSubProtocol(WebsocketVersion.V13);
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   public ExitCode runWithoutHelp(CommandRunnerParams params)
      throws IOException, InterruptedException {

    if (saveFilename != null && loadFilename != null) {
      params.getConsole().printErrorText("Can't use both --load and --save");
      return ExitCode.COMMANDLINE_ERROR;
    }

    if (saveFilename != null) {
      invalidateChanges(params);
      RemoteDaemonicParserState state = params.getParser().storeParserState(params.getCell());
      try (FileOutputStream fos = new FileOutputStream(saveFilename);
          ZipOutputStream zipos = new ZipOutputStream(fos)) {
        zipos.putNextEntry(new ZipEntry("parser_data"));
        try (ObjectOutputStream oos = new ObjectOutputStream(zipos)) {
          oos.writeObject(state);
        }
      }
    } else if (loadFilename != null) {
      try (FileInputStream fis = new FileInputStream(loadFilename);
          ZipInputStream zipis = new ZipInputStream(fis)) {
        ZipEntry entry = zipis.getNextEntry();
        Preconditions.checkState(entry.getName().equals("parser_data"));
        try (ObjectInputStream ois = new ObjectInputStream(zipis)) {
          RemoteDaemonicParserState state;
          try {
            state = (RemoteDaemonicParserState) ois.readObject();
          } catch (ClassNotFoundException e) {
            params.getConsole().printErrorText("Invalid file format");
            return ExitCode.COMMANDLINE_ERROR;
          }
          params.getParser().restoreParserState(state, params.getCell());
        }
      }
      invalidateChanges(params);

      ParserConfig configView = params.getBuckConfig().getView(ParserConfig.class);
      if (configView.isParserCacheMutationWarningEnabled()) {
        params
            .getConsole()
            .printErrorText(
                params
                    .getConsole()
                    .getAnsi()
                    .asWarningText(
                        "WARNING: Buck injected a parser state that may not match the local state."));
      }
    }

    return ExitCode.SUCCESS;
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/com/facebook/buck/cli/ParserCacheCommand.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:
 com/facebook/buck/jvm/java/DiagnosticCleanerTest.java::equals
com/facebook/buck/parser/AbstractParserConfig.java::isParserCacheMutationWarningEnabled
com/facebook/buck/testutil/endtoend/EndToEndTestDescriptor.java::getName
android/support/v4/app/Fragment.java::getView
com/facebook/buck/parser/Parser.java::restoreParserState
com/facebook/buck/util/Console.java::printErrorText
com/facebook/buck/parser/Parser.java::storeParserState
com/facebook/buck/parser/ParsePipelineTest.java::getCell
com/facebook/buck/util/Ansi.java::asWarningText
::getNextEntry
com/facebook/buck/util/zip/CustomZipOutputStream.java::putNextEntry
::checkState
com/facebook/buck/step/AbstractExecutionContext.java::getAnsi
com/facebook/buck/log/thrift/ProcessStatsRemoteLogEntry.java::readObject
com/facebook/buck/distributed/build_slave/AbstractDistBuildSlaveExecutorArgs.java::getParser
com/facebook/buck/ide/intellij/model/AbstractIjProjectConfig.java::getBuckConfig
com/facebook/buck/log/thrift/ProcessStatsRemoteLogEntry.java::writeObject
com/facebook/buck/cli/ParserCacheCommand.java::invalidateChanges
com/facebook/buck/android/AdbHelper.java::getConsole

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     @Test
    public void testPathParameters() throws HttpRequestParser.BadRequestException {
        byte[] in = "GET /somepath;p1 HTTP/1.1\r\n\r\n".getBytes();
        ParseState context = new ParseState();
        HttpServerExchange result = new HttpServerExchange(null);
        HttpRequestParser.instance(OptionMap.create(UndertowOptions.ALLOW_ENCODED_SLASH, true)).handle(ByteBuffer.wrap(in), context, result);
        Assert.assertSame(Methods.GET, result.getRequestMethod());
        Assert.assertEquals("/somepath", result.getRequestPath());
        Assert.assertEquals("/somepath;p1", result.getRequestURI());
        Assert.assertTrue(result.getPathParameters().containsKey("p1"));

        in = "GET /somepath;p1=v1&p2=v2?q1=v3 HTTP/1.1\r\n\r\n".getBytes();
        context = new ParseState();
        result = new HttpServerExchange(null);
        HttpRequestParser.instance(OptionMap.create(UndertowOptions.ALLOW_ENCODED_SLASH, true)).handle(ByteBuffer.wrap(in), context, result);
        Assert.assertSame(Methods.GET, result.getRequestMethod());
        Assert.assertEquals("/somepath", result.getRequestPath());
        Assert.assertEquals("/somepath;p1=v1&p2=v2", result.getRequestURI());
        Assert.assertEquals("q1=v3", result.getQueryString());
        Assert.assertEquals("v1", result.getPathParameters().get("p1").getFirst());
        Assert.assertEquals("v2", result.getPathParameters().get("p2").getFirst());
        Assert.assertEquals("v3", result.getQueryParameters().get("q1").getFirst());
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: core/src/test/java/io/undertow/server/protocol/http/SimpleParserTestCase.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testWriteFinalTextFrame() throws Exception {
    testWriteFinalFrame(false);
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     void isIgnored_allowedForSameUUID() throws Exception {
        final AgentRuntimeInfo agent = runtimeInfo(AGENT_UUID);
        final AgentRemoteInvokerServiceExporter invoker = deserializingWith(new RemoteInvocation("isIgnored", new Class[]{AgentRuntimeInfo.class, JobIdentifier.class}, new Object[]{agent, null}), target);
        invoker.handleRequest(req, res);
        verify(target, only()).isIgnored(agent, null);
        assertEquals(SC_OK, res.getStatus());
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: server/src/test-fast/java/com/thoughtworks/go/remote/AgentRemoteInvokerServiceExporterTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testClientWebsocketPingPong() {
    server = vertx.createHttpServer(new HttpServerOptions().setIdleTimeout(1).setPort(DEFAULT_HTTP_PORT).setHost(HttpTestBase.DEFAULT_HTTP_HOST));
    server.websocketHandler(ws -> {
    }).listen(onSuccess(v -> {
      client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", ws -> {
        ws.pongHandler( pong -> {
          assertEquals("ping", pong.toString());
          testComplete();
        });
        ws.writePing(Buffer.buffer("ping"));
      });
    }));
    await();
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testRejectWithStatusCode() throws Exception {
    testReject(WebsocketVersion.V08, 404, 404);
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     @Test
    public void testFullUrlRootPath() throws HttpRequestParser.BadRequestException {
        byte[] in = "GET http://myurl.com HTTP/1.1\r\n\r\n".getBytes();

        final ParseState context = new ParseState();
        HttpServerExchange result = new HttpServerExchange(null);
        HttpRequestParser.instance(OptionMap.create(UndertowOptions.ALLOW_ENCODED_SLASH, true)).handle(ByteBuffer.wrap(in), context, result);
        Assert.assertSame(Methods.GET, result.getRequestMethod());
        Assert.assertEquals("/", result.getRequestPath());
        Assert.assertEquals("http://myurl.com", result.getRequestURI());
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: core/src/test/java/io/undertow/server/protocol/http/SimpleParserTestCase.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
         public void addclass(String section, int startYear, int tutorID) {
                try {
                        stmt = c.createStatement();
                        stmt.executeUpdate("INSERT INTO klasy(oddzial,rok_rozpoczecia,id_wychowawcy) values('" + section + "'," + startYear + "," + tutorID + ");");
//                        System.out.println("success");
                        stmt.close();
                } catch (Exception e) {
                        e.printStackTrace();
                        System.err.println(e.getClass().getName() + ": " + e.getMessage());
                }
        }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/DBManager.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:
 ::getMessage
::println
::createStatement
::printStackTrace
::getClass
::close
::getName
::executeUpdate

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     public String getLiquibaseChangeLog()
    {
        // TODO: Remove once XWIKI-19399 is fixed.
        return null;
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: xwiki-platform-core/xwiki-platform-index/xwiki-platform-index-default/src/main/java/org/xwiki/index/migration/R140300000XWIKI19614DataMigration.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testServerWebsocketPongExceeds125Bytes() {
    testServerWebsocketPingPongCheck(255, ws -> {
      try {
        ws.writePong(Buffer.buffer(randomAlphaString(126)));
      } catch(Throwable expected) {
        assertEquals("Pong cannot exceed maxWebSocketFrameSize or 125 bytes", expected.getMessage());
        ws.close();
        testComplete();
      }
    });
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  // Server specifies cert that the client does not trust via a revoked certificate of the CA
  public void testTLSClientRevokedServerCert() throws Exception {
    testTLS(Cert.NONE, Trust.SERVER_PEM_ROOT_CA, Cert.SERVER_PEM_ROOT_CA, Trust.NONE, false, false, false, true, false);
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   private void testReject(WebsocketVersion version, Integer rejectionStatus, int expectedRejectionStatus) throws Exception {

    String path = "/some/path";

    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> {
      assertEquals(path, ws.path());
      if (rejectionStatus != null) {
        ws.reject(rejectionStatus);
      } else {
        ws.reject();
      }
    });

    server.listen(ar -> {
      assertTrue(ar.succeeded());
      client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null, version).
          exceptionHandler(t -> {
            assertTrue(t instanceof WebsocketRejectedException);
            assertEquals(expectedRejectionStatus, ((WebsocketRejectedException)t).getStatus());
            testComplete();
          }).
          handler(ws -> fail("Should not be called"));
    });
    await();
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     public Directory read(final ImageInputStream input) throws IOException {
        Validate.notNull(input, "input");

        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);

        try {
            // TODO: Consider parsing using SAX?
            // TODO: Determine encoding and parse using a Reader...
            // TODO: Refactor scanner to return inputstream?
            // TODO: Be smarter about ASCII-NULL termination/padding (the SAXParser aka Xerces DOMParser doesn't like it)...
            DocumentBuilder builder = factory.newDocumentBuilder();
            builder.setErrorHandler(new DefaultHandler());
            Document document = builder.parse(new InputSource(IIOUtil.createStreamAdapter(input)));

//            XMLSerializer serializer = new XMLSerializer(System.err, System.getProperty("file.encoding"));
//            serializer.serialize(document);

            String toolkit = getToolkit(document);
            Node rdfRoot = document.getElementsByTagNameNS(XMP.NS_RDF, "RDF").item(0);
            NodeList descriptions = document.getElementsByTagNameNS(XMP.NS_RDF, "Description");

            return parseDirectories(rdfRoot, descriptions, toolkit);
        }
        catch (SAXException e) {
            throw new IIOException(e.getMessage(), e);
        }
        catch (ParserConfigurationException e) {
            throw new RuntimeException(e); // TODO: Or IOException?
        }
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: imageio/imageio-metadata/src/main/java/com/twelvemonkeys/imageio/metadata/xmp/XMPReader.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:
 src/main/java/com/twelvemonkeys/servlet/ThrottleFilter.java::getMessage
imageio-metadata/src/main/java/com/twelvemonkeys/imageio/metadata/xmp/XMPReader.java::parseDirectories
::setErrorHandler
imageio-metadata/src/main/java/com/twelvemonkeys/imageio/metadata/xmp/XMPReader.java::getToolkit
::setNamespaceAware
::getElementsByTagNameNS
imageio-core/src/main/java/com/twelvemonkeys/imageio/util/IIOUtil.java::createStreamAdapter
::newInstance
common-io/src/main/java/com/twelvemonkeys/io/Win32Lnk.java::parse
common-lang/src/main/java/com/twelvemonkeys/lang/Validate.java::notNull
::item
::newDocumentBuilder

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     void shouldErrorOutIfDecryptionFails() throws CryptoException {
        GoCipher mockGoCipher = mock(GoCipher.class);
        String fakeCipherText = "fake cipher text";
        when(mockGoCipher.decrypt(fakeCipherText)).thenThrow(new CryptoException("exception"));
        TfsMaterial material = new TfsMaterial(mockGoCipher, new UrlArgument("/foo"), "username", DOMAIN, "password", "");
        ReflectionUtil.setField(material, "encryptedPassword", fakeCipherText);
        try {
            material.getPassword();
            fail("Should have thrown up");
        } catch (Exception e) {
            assertThat(e.getMessage()).isEqualTo("Could not decrypt the password to get the real password");
        }
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: common/src/test/java/com/thoughtworks/go/config/materials/tfs/TfsMaterialTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     private DefaultJpaInstanceConfiguration derbyConfig() {
        DefaultJpaInstanceConfiguration config = new DefaultJpaInstanceConfiguration();
        File dbFolder = new File(tempFolder.getRoot(), "derbyDb");

        config.transactionType(DefaultJpaInstanceConfiguration.TransactionType.RESOURCE_LOCAL)
              .db(JpaDb.DERBY_EMBEDDED)
              .autoCreate(true)
              .url(dbFolder.getAbsolutePath())
              .user("test")
              .password("test")
              .ddlGeneration(DefaultJpaInstanceConfiguration.Ddl.DROP_AND_CREATE)
              .
                      bind(OptionJpaDao_LongInt.class, DefaultOptionJpaDao_LongInt.class)
              .bind(JpaDao_LongInt.class, DefaultJpaDao_LongInt.class)
              .bind(JpaPatternDao.class, DefaultJpaPatternDao_LongInt.class);

        return config;
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/uk/q3c/krail/jpa/persist/TestJpaModule.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
 	private LikeCondition createLike(Type type, String toMatch) {
		if (notLike) {
			return new NotLikeCondition(type, selector, toMatch);
		} else {
			return new LikeCondition(type, selector, toMatch);
		}
	}
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/main/java/org/torpedoquery/jpa/internal/conditions/ConditionBuilder.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   private void configureHttp2(ChannelPipeline pipeline) {
    if (options.getIdleTimeout() > 0) {
      pipeline.addBefore("handler", "idle", new IdleStateHandler(0, 0, options.getIdleTimeout()));
    }
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/main/java/io/vertx/core/http/impl/HttpServerImpl.java.
//This function is called by other functions within the repository:
 src/main/java/io/vertx/core/http/impl/HttpServerImpl.java::HttpServerImpl.handleHttp2
src/main/java/io/vertx/core/http/impl/HttpServerImpl.java::Http2UpgradeHandler.channelRead
//This function itself calls other functions within the repository:
 src/main/java/io/vertx/core/http/CaseInsensitiveHeaders.java::addBefore
src/main/java/io/vertx/core/net/TCPSSLOptions.java::getIdleTimeout

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   private void testWSWriteStream(WebsocketVersion version) throws Exception {

    String path = "/some/path";
    String query = "handshake=bar&wibble=eek";
    String uri = path + "?" + query;

    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(ws -> {
      assertEquals(uri, ws.uri());
      assertEquals(path, ws.path());
      assertEquals(query, ws.query());
      assertEquals("upgrade", ws.headers().get("Connection"));
      ws.handler(data -> ws.write(data));
    });

    server.listen(ar -> {
      assertTrue(ar.succeeded());
      int bsize = 100;
      int sends = 10;

      client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path + "?" + query, null, version, ws -> {
        final Buffer received = Buffer.buffer();
        ws.handler(data -> {
          received.appendBuffer(data);
          if (received.length() == bsize * sends) {
            ws.close();
            testComplete();
          }
        });
        final Buffer sent = Buffer.buffer();
        for (int i = 0; i < sends; i++) {
          Buffer buff = Buffer.buffer(TestUtils.randomByteArray(bsize));
          ws.write(buff);
          sent.appendBuffer(buff);
        }
      });
    });
    await();
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testServerWebsocketPongExceedsMaxFrameSize() {
    testServerWebsocketPingPongCheck(100, ws -> {
      try {
        ws.writePong(Buffer.buffer(randomAlphaString(101)));
      } catch(Throwable expected) {
        assertEquals("Pong cannot exceed maxWebSocketFrameSize or 125 bytes", expected.getMessage());
        ws.close();
        testComplete();
      }
    });
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testRaceConditionWithWebsocketClientWorker2() throws Exception {
    int size = getOptions().getWorkerPoolSize() - 4;
    List<Context> workers = createWorkers(size + 1);
    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT));
    server.websocketHandler(ws -> {
      ws.write(Buffer.buffer("hello"));
    });
    server.listen(ar -> {
      assertTrue(ar.succeeded());
      workers.get(0).runOnContext(v -> {
        ReadStream<WebSocket> webSocketStream = client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/");
        webSocketStream.handler(ws -> {
          ws.handler(buf -> {
            assertEquals("hello", buf.toString());
            testComplete();
          });
        });
      });
    });
    await();
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     public static SubTypeValidator instance() { return instance; }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/main/java/com/fasterxml/jackson/databind/jsontype/impl/SubTypeValidator.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testSharedServersRoundRobinWithOtherServerRunningOnDifferentPort() throws Exception {
    // Have a server running on a different port to make sure it doesn't interact
    CountDownLatch latch = new CountDownLatch(1);
    HttpServer theServer = vertx.createHttpServer(new HttpServerOptions().setPort(4321));
    theServer.websocketHandler(ws -> {
      fail("Should not connect");
    }).listen(ar -> {
      if (ar.succeeded()) {
        latch.countDown();
      } else {
        fail("Failed to bind server");
      }
    });
    awaitLatch(latch);
    testSharedServersRoundRobin();
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   private void doTestClientWebsocketConnectionCloseOnBadResponse(boolean keepAliveInOptions) throws Throwable {
    final Exception serverGotCloseException = new Exception();

    netServer = vertx.createNetServer().connectHandler(sock -> {
      final Buffer fullReq = Buffer.buffer(230);
      sock.handler(b -> {
        fullReq.appendBuffer(b);
        String reqPart = b.toString();
        if (fullReq.toString().contains("\r\n\r\n")) {
          try {
            String content = "0123456789";
            content = content + content;
            content = content + content + content + content + content;
            String resp = "HTTP/1.1 200 OK\r\n";
            if (keepAliveInOptions) {
              resp += "Connection: close\r\n";
            }
            resp += "Content-Length: 100\r\n\r\n" + content;
            sock.write(Buffer.buffer(resp.getBytes("ASCII")));
          } catch (UnsupportedEncodingException e) {
            addResult(e);
          }
        }
      });
      sock.closeHandler(v -> {
        addResult(serverGotCloseException);
      });
    }).listen(ar -> {
      if (ar.failed()) {
        addResult(ar.cause());
        return;
      }
      NetServer server = ar.result();
      int port = server.actualPort();

      HttpClientOptions opts = new HttpClientOptions().setKeepAlive(keepAliveInOptions);
      client.close();
      client = vertx.createHttpClient(opts).websocket(port, "localhost", "/", ws -> {
        addResult(new AssertionError("Websocket unexpectedly connected"));
        ws.close();
      }, t -> {
        addResult(t);
      });
    });

    boolean serverGotClose = false;
    boolean clientGotCorrectException = false;
    while (!serverGotClose || !clientGotCorrectException) {
      Throwable result = resultQueue.poll(20, TimeUnit.SECONDS);
      if (result == null) {
        throw new AssertionError("Timed out waiting for expected state, current: serverGotClose = " + serverGotClose + ", clientGotCorrectException = " + clientGotCorrectException);
      } else if (result == serverGotCloseException) {
        serverGotClose = true;
      } else if (result instanceof WebsocketRejectedException
              && ((WebsocketRejectedException)result).getStatus() == 200) {
        clientGotCorrectException = true;
      } else {
        throw result;
      }
    }
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  //Client specifies cert signed by CA and it is required
  public void testTLSClientCertPEM_CARequired() throws Exception {
    testTLS(Cert.CLIENT_PEM_ROOT_CA, Trust.SERVER_JKS, Cert.SERVER_JKS, Trust.CLIENT_PEM_ROOT_CA, true, false, false, false, true);
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testCleanClientClose() {
    waitFor(2);
    server = vertx.createHttpServer();
    server.requestHandler(req -> {
      NetSocketInternal so = (NetSocketInternal) handshake(req);
      if (so != null) {
        so.channelHandlerContext().pipeline().addBefore("handler", "encoder", new WebSocket13FrameEncoder(false));
        so.channelHandlerContext().pipeline().addBefore("handler", "decoder", new WebSocket13FrameDecoder(true, false, 1000));
        Deque<Object> received = new ArrayDeque<>();
        so.messageHandler(received::add);
        int status = 4000 + TestUtils.randomPositiveInt() % 100;
        String reason = TestUtils.randomAlphaString(10);
        so.writeMessage(new CloseWebSocketFrame(status, reason));
        so.closeHandler(v -> {
          assertEquals(1, received.size());
          Object msg = received.getFirst();
          assertEquals(msg.getClass(), CloseWebSocketFrame.class);
          CloseWebSocketFrame frame = (CloseWebSocketFrame) msg;
          assertEquals(status, frame.statusCode());
          assertEquals(reason, frame.reasonText());
          complete();
        });
      }
    });
    server.listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, onSuccess(v1 -> {
      client = vertx.createHttpClient();
      client.websocket(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/chat", ws -> {
        ws.closeHandler(v -> {
          complete();
        });
      });
    }));
    await();
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     public Map listRecords(String resumptionToken)
    throws BadResumptionTokenException, OAIInternalServerError {
        Map listRecordsMap = new HashMap();
        ArrayList records = new ArrayList();
        purge(); // clean out old resumptionTokens

        /**********************************************************************
         * parse your resumptionToken and look it up in the resumptionResults,
         * if necessary
         **********************************************************************/
        StringTokenizer tokenizer = new StringTokenizer(resumptionToken, "!");
        String resumptionId;
        int oldCount;
        int numRows;
        String metadataPrefix;
        try {
            resumptionId = tokenizer.nextToken();
            oldCount = Integer.parseInt(tokenizer.nextToken());
            numRows = Integer.parseInt(tokenizer.nextToken());
            metadataPrefix = tokenizer.nextToken();
        } catch (NoSuchElementException e) {
            throw new BadResumptionTokenException();
        }

        try {
            /* Get some more records from your database */
            ResultSet rs = (ResultSet)resumptionResults.get(resumptionId);
            if (rs == null) {
                throw new BadResumptionTokenException();
            }

            if (rs.getRow() != oldCount) {
//              System.out.println("JDBCOAICatalog.listIdentifiers: reuse of old resumptionToken?");
                rs.absolute(oldCount);
            }

            int count;

            /* load the headers and identifiers ArrayLists. */
            for (count = 0; count < maxListSize && rs.next(); ++count) {
                try {
                    HashMap nativeItem = getColumnValues(rs);
                    String record = constructRecord(nativeItem, metadataPrefix);
                    records.add(record);
                } catch (CannotDisseminateFormatException e) {
                    /* the client hacked the resumptionToken beyond repair */
                    throw new BadResumptionTokenException();
                }
            }

            /* decide if you're done */
            if (oldCount+count < numRows) {
                /*****************************************************************
                 * Construct the resumptionToken String however you see fit.
                 *****************************************************************/
                StringBuffer resumptionTokenSb = new StringBuffer();
                resumptionTokenSb.append(resumptionId);
                resumptionTokenSb.append("!");
                resumptionTokenSb.append(Integer.toString(oldCount + count));
                resumptionTokenSb.append("!");
                resumptionTokenSb.append(Integer.toString(numRows));
                resumptionTokenSb.append("!");
                resumptionTokenSb.append(metadataPrefix);

                /*****************************************************************
                 * Use the following line if you wish to include the optional
                 * resumptionToken attributes in the response. Otherwise, use the
                 * line after it that I've commented out.
                 *****************************************************************/
                listRecordsMap.put("resumptionMap", getResumptionMap(resumptionTokenSb.toString(),
                        numRows,
                        oldCount));
                //          listRecordsMap.put("resumptionMap",
                //                                 getResumptionMap(resumptionTokenSb.toString()));
            }
        } catch (SQLException e) {
            e.printStackTrace();
            throw new OAIInternalServerError(e.getMessage());
        }

        listRecordsMap.put("records", records.iterator());
        return listRecordsMap;
    }

// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/ORG/oclc/oai/server/catalog/JDBCOAICatalog.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     public void corsWildCard() {
        InputStream is = getClass().getResourceAsStream("/allow-origin2.xml");
        PolicyRestrictor restrictor = new PolicyRestrictor(is);

        assertTrue(restrictor.isCorsAccessAllowed("http://bla.com"));
        assertTrue(restrictor.isCorsAccessAllowed("http://www.jolokia.org"));
        assertTrue(restrictor.isCorsAccessAllowed("http://www.consol.de"));
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: agent/core/src/test/java/org/jolokia/restrictor/PolicyBasedRestrictorTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testWSBinaryHybi17() throws Exception {
    testWSFrames(true, WebsocketVersion.V13);
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testEndHandlerCalled() {
    String path = "/some/path";
    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)).websocketHandler(WebSocketBase::close);
    AtomicInteger doneCount = new AtomicInteger();
    server.listen(ar -> {
      assertTrue(ar.succeeded());
      client.websocketStream(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path, null).
          endHandler(done -> doneCount.incrementAndGet()).
          handler(ws -> {
            assertEquals(0, doneCount.get());
            ws.closeHandler(v -> {
              assertEquals(1, doneCount.get());
              testComplete();
            });
          });
    });
    await();
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     public boolean visitFunction(Function function, Object extraData) throws IOException {
        if (function instanceof DateDifferenceFunction) {
            Expression d1 = getParameter(function, 0, true);
            Expression d2 = getParameter(function, 1, true);

            List<Expression> params = function.getParameters();
            // extract epoch returns seconds, DateDifference can be defined in
            // a different time unit instead (ms as default).
            double multiplyingFactor = 1000;
            if (params.size() == 3) {
                Expression expression = getParameter(function, 2, false);
                if (expression instanceof Literal) {
                    TimeUnit timeUnit = expression.evaluate(null, TimeUnit.class);
                    if (timeUnit != TimeUnit.MILLISECONDS) {
                        // Let's identify the multiplying factor to go from seconds to the
                        // target time unit.
                        // Doing an inverse math since convert will return 0 when converting
                        // smaller units (i.e. 1 second) to bigger units (i.e. days)
                        multiplyingFactor = 1d / TimeUnit.SECONDS.convert(1, timeUnit);
                    }
                }
            }

            out.write("(extract(epoch from ");
            d1.accept(delegate, java.util.Date.class);
            out.write("::timestamp - ");
            d2.accept(delegate, java.util.Date.class);
            out.write(") * " + multiplyingFactor + ")");
        } else if (function instanceof FilterFunction_area) {
            Expression s1 = getParameter(function, 0, true);
            out.write("ST_Area(");
            s1.accept(delegate, String.class);
            out.write(")");
        } else if (function instanceof FilterFunction_strConcat) {
            Expression s1 = getParameter(function, 0, true);
            Expression s2 = getParameter(function, 1, true);
            out.write("(");
            s1.accept(delegate, String.class);
            out.write(" || ");
            s2.accept(delegate, String.class);
            out.write(")");
        } else if (function instanceof FilterFunction_strEndsWith) {
            Expression str = getParameter(function, 0, true);
            Expression end = getParameter(function, 1, true);

            out.write("(");
            str.accept(delegate, String.class);
            out.write(" LIKE ");
            if (end instanceof Literal) {
                out.write("'%" + end.evaluate(null, String.class) + "'");
            } else {
                out.write("('%' || ");
                end.accept(delegate, String.class);
                out.write(")");
            }
            out.write(")");
        } else if (function instanceof FilterFunction_strStartsWith) {
            Expression str = getParameter(function, 0, true);
            Expression start = getParameter(function, 1, true);

            out.write("(");
            str.accept(delegate, String.class);
            out.write(" LIKE ");
            if (start instanceof Literal) {
                out.write("'" + start.evaluate(null, String.class) + "%'");
            } else {
                out.write("(");
                start.accept(delegate, String.class);
                out.write(" || '%')");
            }
            out.write(")");
        } else if (function instanceof FilterFunction_strEqualsIgnoreCase) {
            Expression first = getParameter(function, 0, true);
            Expression second = getParameter(function, 1, true);

            out.write("(lower(");
            first.accept(delegate, String.class);
            out.write(") = lower(");
            second.accept(delegate, String.class);
            out.write("::text))");
        } else if (function instanceof FilterFunction_strIndexOf) {
            Expression first = getParameter(function, 0, true);
            Expression second = getParameter(function, 1, true);

            // would be a simple call, but strIndexOf returns zero based indices
            out.write("(strpos(");
            first.accept(delegate, String.class);
            out.write(", ");
            second.accept(delegate, String.class);
            out.write(") - 1)");
        } else if (function instanceof FilterFunction_strSubstring) {
            Expression string = getParameter(function, 0, true);
            Expression start = getParameter(function, 1, true);
            Expression end = getParameter(function, 2, true);

            // postgres does sub(string, start, count)... count instead of end, and 1 based indices
            out.write("substr(");
            string.accept(delegate, String.class);
            out.write(", ");
            start.accept(delegate, Integer.class);
            out.write(" + 1, (");
            end.accept(delegate, Integer.class);
            out.write(" - ");
            start.accept(delegate, Integer.class);
            out.write("))");
        } else if (function instanceof FilterFunction_strSubstringStart) {
            Expression string = getParameter(function, 0, true);
            Expression start = getParameter(function, 1, true);

            // postgres does sub(string, start, count)... count instead of end, and 1 based indices
            out.write("substr(");
            string.accept(delegate, String.class);
            out.write(", ");
            start.accept(delegate, Integer.class);
            out.write(" + 1)");
        } else if (function instanceof FilterFunction_strTrim) {
            Expression string = getParameter(function, 0, true);

            out.write("trim(both ' ' from ");
            string.accept(delegate, String.class);
            out.write(")");
        } else if (function instanceof JsonPointerFunction) {
            encodeJsonPointer(function, extraData);
        } else if (function instanceof JsonArrayContainsFunction) {
            encodeJsonArrayContains(function);
        } else if (function instanceof FilterFunction_buffer) {
            encodeBuffer(function, extraData);
        } else {
            // function not supported
            return false;
        }

        return true;
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: modules/plugin/jdbc/jdbc-postgis/src/main/java/org/geotools/data/postgis/FilterToSqlHelper.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     private boolean exractAndLoad(ArrayList<String> errors, String version, String customPath, String resourcePath) {
        URL resource = classLoader.getResource(resourcePath);
        if( resource !=null ) {

            String libName = name + "-" + getBitModel();
            if( version !=null) {
                libName += "-" + version;
            }

            if( customPath!=null ) {
                // Try to extract it to the custom path...
                File target = file(customPath, map(libName));
                if( extract(errors, resource, target) ) {
                    if( load(errors, target) ) {
                        return true;
                    }
                }
            }

            // Fall back to extracting to the tmp dir
            customPath = System.getProperty("java.io.tmpdir");
            File target = file(customPath, map(libName));
            if( extract(errors, resource, target) ) {
                if( load(errors, target) ) {
                    return true;
                }
            }
        }
        return false;
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: hawtjni-runtime/src/main/java/org/fusesource/hawtjni/runtime/Library.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:
 src/main/java/org/fusesource/hawtjni/runtime/Library.java::Library.doLoad

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   private void configureHttp1(ChannelPipeline pipeline, HandlerHolder<HttpHandlers> holder) {
    if (logEnabled) {
      pipeline.addLast("logging", new LoggingHandler());
    }
    if (USE_FLASH_POLICY_HANDLER) {
      pipeline.addLast("flashpolicy", new FlashPolicyHandler());
    }
    pipeline.addLast("httpDecoder", new HttpRequestDecoder(options.getMaxInitialLineLength()
        , options.getMaxHeaderSize(), options.getMaxChunkSize(), false, options.getDecoderInitialBufferSize()));
    pipeline.addLast("httpEncoder", new VertxHttpResponseEncoder());
    if (options.isDecompressionSupported()) {
      pipeline.addLast("inflater", new HttpContentDecompressor(true));
    }
    if (options.isCompressionSupported()) {
      pipeline.addLast("deflater", new HttpChunkContentCompressor(options.getCompressionLevel()));
    }
    if (sslHelper.isSSL() || options.isCompressionSupported()) {
      // only add ChunkedWriteHandler when SSL is enabled otherwise it is not needed as FileRegion is used.
      pipeline.addLast("chunkedWriter", new ChunkedWriteHandler());       // For large file / sendfile support
    }
    if (options.getIdleTimeout() > 0) {
      pipeline.addLast("idle", new IdleStateHandler(0, 0, options.getIdleTimeout()));
    }
    if (!DISABLE_H2C) {
      pipeline.addLast("h2c", new Http2UpgradeHandler());
    }
    Http1xServerHandler handler;
    if (DISABLE_WEBSOCKETS) {
      // As a performance optimisation you can set a system property to disable websockets altogether which avoids
      // some casting and a header check
      handler = new Http1xServerHandler(sslHelper, options, serverOrigin, holder, metrics);
    } else {
      handler = new ServerHandlerWithWebSockets(sslHelper, options, serverOrigin, holder, metrics);
    }
    handler.addHandler(conn -> {
      connectionMap.put(pipeline.channel(), conn);
    });
    handler.removeHandler(conn -> {
      connectionMap.remove(pipeline.channel());
    });
    pipeline.addLast("handler", handler);
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/main/java/io/vertx/core/http/impl/HttpServerImpl.java.
//This function is called by other functions within the repository:
 src/main/java/io/vertx/core/http/impl/HttpServerImpl.java::HttpServerImpl.handleHttp1
//This function itself calls other functions within the repository:
 src/main/java/io/vertx/core/http/impl/VertxHttp2ConnectionHandler.java::removeHandler
src/main/java/io/vertx/core/http/HttpServerOptions.java::getMaxChunkSize
src/main/java/io/vertx/core/shareddata/impl/SharedDataImpl.java::put
src/main/java/io/vertx/core/http/impl/Http2UpgradedClientConnection.java::channel
src/main/java/io/vertx/core/http/HttpServerOptions.java::isCompressionSupported
src/main/java/io/vertx/core/http/impl/VertxHttp2ConnectionHandler.java::addHandler
src/test/java/io/vertx/test/fakecluster/FakeClusterManager.java::remove
::addLast
src/main/java/io/vertx/core/http/HttpServerOptions.java::isDecompressionSupported
src/main/java/io/vertx/core/http/HttpServerOptions.java::getMaxInitialLineLength
src/main/java/io/vertx/core/http/impl/Http2ServerRequestImpl.java::isSSL
src/main/java/io/vertx/core/http/HttpServerOptions.java::getMaxHeaderSize
src/main/java/io/vertx/core/net/TCPSSLOptions.java::getIdleTimeout
src/main/java/io/vertx/core/http/HttpServerOptions.java::getDecoderInitialBufferSize
src/main/java/io/vertx/core/http/HttpServerOptions.java::getCompressionLevel

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
     public void translate(ServerUpdateViewDistancePacket packet, GeyserSession session) {
        session.setRenderDistance(packet.getViewDistance());
    }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: connector/src/main/java/org/geysermc/connector/network/translators/java/world/JavaUpdateViewDistanceTranslator.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testSharedServersRoundRobinButFirstStartAndStopServer() throws Exception {
    // Start and stop a server on the same port/host before hand to make sure it doesn't interact
    CountDownLatch latch = new CountDownLatch(1);
    HttpServer theServer = vertx.createHttpServer(new HttpServerOptions().setPort(4321));
    theServer.websocketHandler(ws -> {
      fail("Should not connect");
    }).listen(ar -> {
      if (ar.succeeded()) {
        latch.countDown();
      } else {
        fail("Failed to bind server");
      }
    });
    awaitLatch(latch);
    CountDownLatch closeLatch = new CountDownLatch(1);
    theServer.close(ar -> {
      assertTrue(ar.succeeded());
      closeLatch.countDown();
    });
    assertTrue(closeLatch.await(10, TimeUnit.SECONDS));
    testSharedServersRoundRobin();
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testContinuationWriteFromConnectHybi08() throws Exception {
    testContinuationWriteFromConnectHandler(WebsocketVersion.V08);
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
 	private TMemory getNewMemory(TMemory memory, List<TValue> values, Map<String, TValue> namedArguments) {
		final Map<String, TValue> result = new HashMap<String, TValue>();
		int ivalue = 0;
		for (TFunctionArgument arg : args) {
			final TValue value;
			if (namedArguments.containsKey(arg.getName())) {
				value = namedArguments.get(arg.getName());
			} else if (ivalue < values.size()) {
				value = values.get(ivalue);
				ivalue++;
			} else {
				value = arg.getOptionalDefaultValue();
			}
			if (value == null) {
				throw new IllegalStateException();
			}
			result.put(arg.getName(), value);
		}
		return memory.forkFromGlobal(result);
	}
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/net/sourceforge/plantuml/tim/TFunctionImpl.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   public static String encode(String clearText, Object salt) throws IllegalArgumentException {
    if (clearText == null || salt == null)
      throw new IllegalArgumentException("clearText and salt must not be null");
    return DigestUtils.md5Hex(clearText + "{" + salt.toString() + "}");
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: None.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is:


If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   public void setUp() throws Exception {
    super.setUp();
    client = vertx.createHttpClient(new HttpClientOptions());
  }
// Code End

//To assist with your evaluation, here is some contextual information. Use the contextual information (if any) to support your evaluation of vulnerability detection.
//The function is located in the file: src/test/java/io/vertx/test/core/WebsocketTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:

//Detection
 Only reply with 'Yes' or 'No', the Answer is: