If the following code snippet has any vulnerabilities, output 'Yes'; otherwise, output 'No'.
//The function being analyzed is:
 //Code Start
   @Test
  public void testWriteFromConnectHybi00() throws Exception {
    testWriteFromConnectHandler(WebsocketVersion.V00);
  }
// 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 Data canonicalize(Data data, XMLCryptoContext xc)
        throws TransformException
    {
        return canonicalize(data, xc, 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: src/main/java/org/apache/jcp/xml/dsig/internal/dom/ApacheCanonicalizer.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 testUpgradeInvalidRequest() {
    server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT));
    server.requestHandler(request -> {
      try {
        request.upgrade();
        fail("Should throw exception");
      } catch (IllegalStateException e) {
        // OK
      }
      testComplete();
    });
    server.listen(ar -> {
      assertTrue(ar.succeeded());
      client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, "/", resp -> {
      }).end();
    });
    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 testStaticFilePagesIndexHtml() throws Exception {
        SparkTestUtil.UrlResponse response = testUtil.doMethod("GET", "/pages/index.html", null);
        Assert.assertEquals(200, response.status);
        Assert.assertEquals("Hello Static World!", response.body);

        testGet();
    }
// 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/spark/StaticFilesTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:
 src/test/java/spark/StaticFilesTest.java::testGet
src/test/java/spark/BooksIntegrationTest.java::doMethod
::assertEquals

//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
     @Override
    public void messageReceived( IoSession session, Object message ) throws Exception
    {
        // Feed the response and store it into the session
        Message response = ( Message ) message;
        LOG.debug( "-------> {} Message received <-------", response );
        int messageId = response.getMessageId();

        // this check is necessary to prevent adding an abandoned operation's
        // result(s) to corresponding queue
        ResponseFuture<? extends Response> responseFuture = peekFromFutureMap( messageId );

        boolean isNoD = isNoticeOfDisconnect( response );

        if ( ( responseFuture == null ) && !isNoD )
        {
            LOG.info( "There is no future associated with the messageId {}, ignoring the message", messageId );
            return;
        }

        if ( isNoD )
        {
            // close the session
            session.closeNow();

            return;
        }

        switch ( response.getType() )
        {
            case ADD_RESPONSE:
                // Transform the response
                AddResponse addResponse = ( AddResponse ) response;

                AddFuture addFuture = ( AddFuture ) responseFuture;

                // remove the listener from the listener map
                if ( LOG.isDebugEnabled() )
                {
                    if ( addResponse.getLdapResult().getResultCode() == ResultCodeEnum.SUCCESS )
                    {
                        // Everything is fine, return the response
                        LOG.debug( "Add successful : {}", addResponse );
                    }
                    else
                    {
                        // We have had an error
                        LOG.debug( "Add failed : {}", addResponse );
                    }
                }

                // Store the response into the future
                addFuture.set( addResponse );

                // Remove the future from the map
                removeFromFutureMaps( messageId );

                break;

            case BIND_RESPONSE:
                // Transform the response
                BindResponse bindResponse = ( BindResponse ) response;

                BindFuture bindFuture = ( BindFuture ) responseFuture;

                // remove the listener from the listener map
                if ( bindResponse.getLdapResult().getResultCode() == ResultCodeEnum.SUCCESS )
                {
                    authenticated.set( true );

                    // Everything is fine, return the response
                    LOG.debug( "Bind successful : {}", bindResponse );
                }
                else
                {
                    // We have had an error
                    LOG.debug( "Bind failed : {}", bindResponse );
                }

                // Store the response into the future
                bindFuture.set( bindResponse );

                // Remove the future from the map
                removeFromFutureMaps( messageId );

                break;

            case COMPARE_RESPONSE:
                // Transform the response
                CompareResponse compareResponse = ( CompareResponse ) response;

                CompareFuture compareFuture = ( CompareFuture ) responseFuture;

                // remove the listener from the listener map
                if ( LOG.isDebugEnabled() )
                {
                    if ( compareResponse.getLdapResult().getResultCode() == ResultCodeEnum.SUCCESS )
                    {
                        // Everything is fine, return the response
                        LOG.debug( "Compare successful : {}", compareResponse );
                    }
                    else
                    {
                        // We have had an error
                        LOG.debug( "Compare failed : {}", compareResponse );
                    }
                }

                // Store the response into the future
                compareFuture.set( compareResponse );

                // Remove the future from the map
                removeFromFutureMaps( messageId );

                break;

            case DEL_RESPONSE:
                // Transform the response
                DeleteResponse deleteResponse = ( DeleteResponse ) response;

                DeleteFuture deleteFuture = ( DeleteFuture ) responseFuture;

                if ( LOG.isDebugEnabled() )
                {
                    if ( deleteResponse.getLdapResult().getResultCode() == ResultCodeEnum.SUCCESS )
                    {
                        // Everything is fine, return the response
                        LOG.debug( "Delete successful : {}", deleteResponse );
                    }
                    else
                    {
                        // We have had an error
                        LOG.debug( "Delete failed : {}", deleteResponse );
                    }
                }

                // Store the response into the future
                deleteFuture.set( deleteResponse );

                // Remove the future from the map
                removeFromFutureMaps( messageId );

                break;

            case EXTENDED_RESPONSE:
                // Transform the response
                ExtendedResponse extendedResponse = ( ExtendedResponse ) response;

                ExtendedFuture extendedFuture = ( ExtendedFuture ) responseFuture;

                // remove the listener from the listener map
                if ( LOG.isDebugEnabled() )
                {
                    if ( extendedResponse.getLdapResult().getResultCode() == ResultCodeEnum.SUCCESS )
                    {
                        // Everything is fine, return the response
                        LOG.debug( "Extended successful : {}", extendedResponse );
                    }
                    else
                    {
                        // We have had an error
                        LOG.debug( "Extended failed : {}", extendedResponse );
                    }
                }

                // Store the response into the future
                extendedFuture.set( extendedResponse );

                // Remove the future from the map
                removeFromFutureMaps( messageId );

                break;

            case INTERMEDIATE_RESPONSE:
                IntermediateResponse intermediateResponse;

                if ( responseFuture instanceof SearchFuture )
                {
                    intermediateResponse = new IntermediateResponseImpl( messageId );
                    addControls( intermediateResponse, response );
                    ( ( SearchFuture ) responseFuture ).set( intermediateResponse );
                }
                else if ( responseFuture instanceof ExtendedFuture )
                {
                    intermediateResponse = new IntermediateResponseImpl( messageId );
                    addControls( intermediateResponse, response );
                    ( ( ExtendedFuture ) responseFuture ).set( intermediateResponse );
                }
                else
                {
                    // currently we only support IR for search and extended operations
                    throw new UnsupportedOperationException( "Unknown ResponseFuture type "
                        + responseFuture.getClass().getName() );
                }

                intermediateResponse.setResponseName( ( ( IntermediateResponse ) response ).getResponseName() );
                intermediateResponse.setResponseValue( ( ( IntermediateResponse ) response ).getResponseValue() );

                break;

            case MODIFY_RESPONSE:
                // Transform the response
                ModifyResponse modifyResponse = ( ModifyResponse ) response;

                ModifyFuture modifyFuture = ( ModifyFuture ) responseFuture;

                if ( LOG.isDebugEnabled() )
                {
                    if ( modifyResponse.getLdapResult().getResultCode() == ResultCodeEnum.SUCCESS )
                    {
                        // Everything is fine, return the response
                        LOG.debug( "ModifyFuture successful : {}", modifyResponse );
                    }
                    else
                    {
                        // We have had an error
                        LOG.debug( "ModifyFuture failed : {}", modifyResponse );
                    }
                }

                // Store the response into the future
                modifyFuture.set( modifyResponse );

                // Remove the future from the map
                removeFromFutureMaps( messageId );

                break;

            case MODIFYDN_RESPONSE:
                // Transform the response
                ModifyDnResponse modifyDnResponse = ( ModifyDnResponse ) response;

                ModifyDnFuture modifyDnFuture = ( ModifyDnFuture ) responseFuture;

                if ( LOG.isDebugEnabled() )
                {
                    if ( modifyDnResponse.getLdapResult().getResultCode() == ResultCodeEnum.SUCCESS )
                    {
                        // Everything is fine, return the response
                        LOG.debug( "ModifyDN successful : {}", modifyDnResponse );
                    }
                    else
                    {
                        // We have had an error
                        LOG.debug( "ModifyDN failed : {}", modifyDnResponse );
                    }
                }

                // Store the response into the future
                modifyDnFuture.set( modifyDnResponse );

                // Remove the future from the map
                removeFromFutureMaps( messageId );

                break;

            case SEARCH_RESULT_DONE:
                // Store the response into the responseQueue
                SearchResultDone searchResultDone = ( SearchResultDone ) response;

                SearchFuture searchFuture = ( SearchFuture ) responseFuture;

                if ( LOG.isDebugEnabled() )
                {
                    if ( searchResultDone.getLdapResult().getResultCode() == ResultCodeEnum.SUCCESS )
                    {
                        // Everything is fine, return the response
                        LOG.debug( "Search successful : {}", searchResultDone );
                    }
                    else
                    {
                        // We have had an error
                        LOG.debug( "Search failed : {}", searchResultDone );
                    }
                }

                // Store the response into the future
                searchFuture.set( searchResultDone );

                // Remove the future from the map
                removeFromFutureMaps( messageId );

                break;

            case SEARCH_RESULT_ENTRY:
                // Store the response into the responseQueue
                SearchResultEntry searchResultEntry = ( SearchResultEntry ) response;

                if ( schemaManager != null )
                {
                    searchResultEntry.setEntry( new DefaultEntry( schemaManager, searchResultEntry.getEntry() ) );
                }

                searchFuture = ( SearchFuture ) responseFuture;

                if ( LOG.isDebugEnabled() )
                {
                    LOG.debug( "Search entry found : {}", searchResultEntry );
                }

                // Store the response into the future
                searchFuture.set( searchResultEntry );

                break;

            case SEARCH_RESULT_REFERENCE:
                // Store the response into the responseQueue
                SearchResultReference searchResultReference = ( SearchResultReference ) response;

                searchFuture = ( SearchFuture ) responseFuture;

                if ( LOG.isDebugEnabled() )
                {
                    LOG.debug( "Search reference found : {}", searchResultReference );
                }

                // Store the response into the future
                searchFuture.set( searchResultReference );

                break;

            default:
                throw new IllegalStateException( "Unexpected response type " + response.getType() );
        }
    }
// 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: ldap/client/api/src/main/java/org/apache/directory/ldap/client/api/LdapNetworkConnection.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:
 ldap/model/src/test/java/org/apache/directory/api/ldap/model/message/LdapResultImplTest.java::getResultCode
ldap/model/src/test/java/org/apache/directory/api/ldap/model/message/AddRequestImplTest.java::setEntry
ldap/model/src/test/java/org/apache/directory/api/ldap/model/message/ModifyRequestImplTest.java::getMessageId
ldap/model/src/main/java/org/apache/directory/api/ldap/model/filter/AbstractExprNode.java::set
ldap/model/src/main/java/org/apache/directory/api/ldap/model/message/IntermediateResponseImpl.java::setResponseValue
ldap/model/src/test/java/org/apache/directory/api/ldap/model/message/ModifyRequestImplTest.java::getName
::debug
ldap/client/api/src/main/java/org/apache/directory/ldap/client/api/LdapNetworkConnection.java::isNoticeOfDisconnect
::closeNow
ldap/client/api/src/main/java/org/apache/directory/ldap/client/api/LdapNetworkConnection.java::peekFromFutureMap
ldap/client/api/src/main/java/org/apache/directory/ldap/client/api/LdapNetworkConnection.java::removeFromFutureMaps
ldap/client/api/src/main/java/org/apache/directory/ldap/client/api/LdapNetworkConnection.java::addControls
ldap/model/src/test/java/org/apache/directory/api/ldap/model/message/ExtendedResponseImplTest.java::getLdapResult
::isDebugEnabled
::info
::getClass
ldap/model/src/test/java/org/apache/directory/api/ldap/model/message/ModifyRequestImplTest.java::getType
ldap/model/src/test/java/org/apache/directory/api/ldap/model/message/SearchResultEntryImplTest.java::getEntry
ldap/model/src/test/java/org/apache/directory/api/ldap/model/message/ExtendedResponseImplTest.java::setResponseName

//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 deleteSynchronously(String mediaPackageId) throws SearchException, UnauthorizedException,
          NotFoundException {
    SearchResult result;
    try {
      result = solrRequester.getForWrite(new SearchQuery().withId(mediaPackageId));
      if (result.getItems().length == 0) {
        logger.warn(
                "Can not delete mediapackage {}, which is not available for the current user to delete from the search index.",
                mediaPackageId);
        return false;
      }
      logger.info("Removing mediapackage {} from search index", mediaPackageId);

      Date now = new Date();
      try {
        persistence.deleteMediaPackage(mediaPackageId, now);
        logger.info("Removed mediapackage {} from search persistence", mediaPackageId);
      } catch (NotFoundException e) {
        // even if mp not found in persistence, it might still exist in search index.
        logger.info("Could not find mediapackage with id {} in persistence, but will try remove it from index, anyway.",
                mediaPackageId);
      } catch (SearchServiceDatabaseException e) {
        logger.error("Could not delete media package with id {} from persistence storage", mediaPackageId);
        throw new SearchException(e);
      }

      return indexManager.delete(mediaPackageId, now);
    } catch (SolrServerException e) {
      logger.info("Could not delete media package with id {} from search index", mediaPackageId);
      throw new SearchException(e);
    }
  }
// 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/search-service-impl/src/main/java/org/opencastproject/search/impl/SearchServiceImpl.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
 	 @Deprecated String decrypt(String ciphertext) throws EncryptionException;

// 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/owasp/esapi/Encryptor.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 static synchronized void initDocBuilderFactory() {
        docBuilderFactory = DocumentBuilderFactory.newInstance();
        docBuilderFactory.setIgnoringComments(true);
        docBuilderFactory.setCoalescing(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/main/java/com/dd/plist/XMLPropertyListParser.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:
 main/java/com/dd/plist/XMLPropertyListParser.java::XMLPropertyListParser.getDocBuilder

//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 validateSubType(DeserializationContext ctxt, JavaType type,
            BeanDescription beanDesc) throws JsonMappingException
    {
        // There are certain nasty classes that could cause problems, mostly
        // via default typing -- catch them here.
        final Class<?> raw = type.getRawClass();
        String full = raw.getName();

        main_check:
        do {
            if (_cfgIllegalClassNames.contains(full)) {
                break;
            }

            // 18-Dec-2017, tatu: As per [databind#1855], need bit more sophisticated handling
            //    for some Spring framework types
            // 05-Jan-2017, tatu: ... also, only applies to classes, not interfaces
            if (raw.isInterface()) {
                ;
            } else if (full.startsWith(PREFIX_SPRING)) {
                for (Class<?> cls = raw; (cls != null) && (cls != Object.class); cls = cls.getSuperclass()){
                    String name = cls.getSimpleName();
                    // looking for "AbstractBeanFactoryPointcutAdvisor" but no point to allow any is there?
                    if ("AbstractPointcutAdvisor".equals(name)
                            // ditto  for "FileSystemXmlApplicationContext": block all ApplicationContexts
                            || "AbstractApplicationContext".equals(name)) {
                        break main_check;
                    }
                }
            } else if (full.startsWith(PREFIX_C3P0)) {
                // [databind#1737]; more 3rd party
                // s.add("com.mchange.v2.c3p0.JndiRefForwardingDataSource");
                // s.add("com.mchange.v2.c3p0.WrapperConnectionPoolDataSource");
                // [databind#1931]; more 3rd party
                // com.mchange.v2.c3p0.ComboPooledDataSource
                // com.mchange.v2.c3p0.debug.AfterCloseLoggingComboPooledDataSource
                if (full.endsWith("DataSource")) {
                    break main_check;
                }
            }
            return;
        } while (false);

        ctxt.reportBadTypeDefinition(beanDesc,
                "Illegal type (%s) to deserialize: prevented for security reasons", full);
    }
// 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:
 src/main/java/com/fasterxml/jackson/databind/deser/BeanDeserializerFactory.java::BeanDeserializerFactory._validateSubType
//This function itself calls other functions within the repository:
 src/test/java/com/fasterxml/jackson/databind/BaseTest.java::getName
src/test/java/com/fasterxml/jackson/failing/InnerClassNonStaticCore384Test.java::equals
src/main/java/com/fasterxml/jackson/databind/JavaType.java::getRawClass
src/main/java/com/fasterxml/jackson/databind/SerializerProvider.java::reportBadTypeDefinition
::endsWith
::getSuperclass
::startsWith
src/test/java/com/fasterxml/jackson/databind/type/PolymorphicList036Test.java::contains
src/main/java/com/fasterxml/jackson/databind/PropertyName.java::getSimpleName
src/main/java/com/fasterxml/jackson/databind/JavaType.java::isInterface

//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 testEmptyQueryParams() throws HttpRequestParser.BadRequestException {
        byte[] in = "GET /clusterbench/requestinfo//?;?=44&test=OK;devil=3&&&&&&&&&&&&&&&&&&&&&&&&&&&&777=666 HTTP/1.1\r\n\r\n".getBytes();

        final ParseState context = new ParseState();
        HttpServerExchange result = new HttpServerExchange(null);
        HttpRequestParser.instance(OptionMap.EMPTY).handle(ByteBuffer.wrap(in), context, result);
        Assert.assertSame(Methods.GET, result.getRequestMethod());
        Assert.assertEquals("/clusterbench/requestinfo//", result.getRequestURI());
        Assert.assertEquals("/clusterbench/requestinfo//", result.getRequestPath());
        Assert.assertEquals(3, result.getQueryParameters().size());
        Assert.assertEquals("OK;devil=3", result.getQueryParameters().get("test").getFirst());
        Assert.assertEquals("666", result.getQueryParameters().get("777").getFirst());
        Assert.assertEquals("44", result.getQueryParameters().get(";?").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 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 testWSFrames(boolean binary, WebsocketVersion version) throws Exception {

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

    // version 0 doesn't support continuations so we just send 1 frame per message
    int frames = version == WebsocketVersion.V00 ? 1: 10;

    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"));
      AtomicInteger count = new AtomicInteger();
      ws.frameHandler(frame -> {
        if (frame.isClose()) {
          testComplete();
        } else {
          if (count.get() == 0) {
            if (binary) {
              assertTrue(frame.isBinary());
              assertFalse(frame.isText());
            } else {
              assertFalse(frame.isBinary());
              assertTrue(frame.isText());
            }
            assertFalse(frame.isContinuation());
          } else {
            assertFalse(frame.isBinary());
            assertFalse(frame.isText());
            assertTrue(frame.isContinuation());
          }
          if (count.get() == frames - 1) {
            assertTrue(frame.isFinal());
          } else {
            assertFalse(frame.isFinal());
          }
          ws.writeFrame(frame);
          if (count.incrementAndGet() == frames) {
            count.set(0);
          }
        }
      });
    });

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

      int msgs = 10;

      client.websocket(DEFAULT_HTTP_PORT, HttpTestBase.DEFAULT_HTTP_HOST, path + "?" + query, null,
        version, ws -> {
          final List<Buffer> sent = new ArrayList<>();
          final List<Buffer> received = new ArrayList<>();

          AtomicReference<Buffer> currentReceived = new AtomicReference<>(Buffer.buffer());
          ws.frameHandler(frame -> {
            //received.appendBuffer(frame.binaryData());
            currentReceived.get().appendBuffer(frame.binaryData());
            if (frame.isFinal()) {
              received.add(currentReceived.get());
              currentReceived.set(Buffer.buffer());
            }
            if (received.size() == msgs) {
              int pos = 0;
              for (Buffer rec : received) {
                assertEquals(rec, sent.get(pos++));
              }
              ws.close();
            }
          });

          AtomicReference<Buffer> currentSent = new AtomicReference<>(Buffer.buffer());
          for (int i = 0; i < msgs; i++) {
            for (int j = 0; j < frames; j++) {
              Buffer buff;
              WebSocketFrame frame;
              if (binary) {
                buff = Buffer.buffer(TestUtils.randomByteArray(bsize));
                if (j == 0) {
                  frame = WebSocketFrame.binaryFrame(buff, false);
                } else {
                  frame = WebSocketFrame.continuationFrame(buff, j == frames - 1);
                }
              } else {
                String str = TestUtils.randomAlphaString(bsize);
                buff = Buffer.buffer(str);
                if (j == 0) {
                  frame = WebSocketFrame.textFrame(str, false);
                } else {
                  frame = WebSocketFrame.continuationFrame(buff, j == frames - 1);
                }
              }
              currentSent.get().appendBuffer(buff);
              ws.writeFrame(frame);
              if (j == frames - 1) {
                sent.add(currentSent.get());
                currentSent.set(Buffer.buffer());
              }
            }
          }
        });
    });
    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 void parse(final InputSource is) {
        try {
            final SAXParserFactory factory = SAXParserFactory.newInstance();
            final SAXParser parser = factory.newSAXParser();
            parser.parse(is, this);
        } catch (final Exception e) {
            throw new GsaConfigException("Failed to parse XML file.", e);
        }
    }
// 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/codelibs/fess/util/GsaConfigParser.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:
 ::newInstance
::newSAXParser
src/main/java/org/codelibs/fess/util/KuromojiCSVUtil.java::parse

//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 Reader getReaderFromFile(Environment env, Settings settings, String settingPrefix) {
        String filePath = settings.get(settingPrefix, null);

        if (filePath == null) {
            return null;
        }
        final Path path = env.configDir().resolve(filePath);
        try {
            return Files.newBufferedReader(path, StandardCharsets.UTF_8);
        } catch (CharacterCodingException ex) {
            String message = String.format(
                Locale.ROOT,
                "Unsupported character encoding detected while reading %s_path: %s files must be UTF-8 encoded",
                settingPrefix,
                path.toString()
            );
            throw new IllegalArgumentException(message, ex);
        } catch (IOException ioe) {
            String message = String.format(Locale.ROOT, "IOException while reading %s_path: %s", settingPrefix, path.toString());
            throw new IllegalArgumentException(message, ioe);
        }
    }
// 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/main/java/org/opensearch/index/analysis/Analysis.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 List<String> getAudienceUris() {
        return config.getAudienceUris().getAudienceItem();
    }
// 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: plugins/core/src/main/java/org/apache/cxf/fediz/core/config/FedizContext.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
     public void testByteSerialization() throws Exception {
        final IBaseDataObject d = DataObjectFactory.getInstance("abc".getBytes(), "testfile", Form.UNKNOWN);
        final byte[] bytes = PayloadUtil.serializeToBytes(d);
        final String s1 = new String(bytes);
        assertTrue("Serializedion must include data from payload", s1.indexOf("abc") > -1);
    }
// 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/emissary/util/PayloadUtilTest.java.
//This function is called by other functions within the repository:

//This function itself calls other functions within the repository:
 main/java/emissary/util/search/ByteMatcher.java::indexOf
main/java/emissary/util/io/FastStringBuffer.java::getBytes
main/java/emissary/util/PayloadUtil.java::serializeToBytes
main/java/emissary/core/DataObjectFactory.java::getInstance
::assertTrue

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