</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.codelibs.fesen.client</groupId>
			<artifactId>fesen-httpclient</artifactId>
			<version>${fesen.httpclient.version}</version>
		</dependency>
		<dependency>
			<groupId>org.ow2.asm</groupId>
			<artifactId>asm</artifactId>
			<version>${asm.version}</version>
		</dependency>
		<dependency>
			<groupId>org.ow2.asm</groupId>

        // packaging type.
        for (Dependency dependency : dependencies) {
            String key = dependency.getGroupId() + ":" + dependency.getArtifactId() + ":" + dependency.getVersion()
                    + (dependency.getClassifier() != null ? ":" + dependency.getClassifier() : EMPTY);
            String mKey = m.getGroupId() + ":" + m.getArtifactId() + ":" + m.getVersion();

                    if (pointer instanceof Lifecycle.DependenciesPointer) {
                        // For dependencies: ensure current project's phase starts after dependency's phase completes
                        // Example: project's compile starts after dependency's package completes
                        // TODO: String scope = ((Lifecycle.DependenciesPointer) pointer).scope();
                        projects.get(project)

        for (Iterator<Dependency> it = depMgmt.getDependencies().iterator(); it.hasNext(); ) {
            Dependency dependency = it.next();

            if (!"pom".equals(dependency.getType()) || !"import".equals(dependency.getScope())) {
                continue;
            }

            it.remove();

            String groupId = dependency.getGroupId();

    ] = None,
    *,
    use_cache: Annotated[
        bool,
        Doc(
            """
            By default, after a dependency is called the first time in a request, if
            the dependency is declared again for the rest of the request (for example
            if the dependency is needed by several dependencies), the value will be
            re-used for the rest of the request.

    constant is included for completeness.
 *  New: Upgrade to Okio 1.14.0.

     ```xml
     <dependency>
       <groupId>com.squareup.okio</groupId>
       <artifactId>okio</artifactId>
       <version>1.14.0</version>
     </dependency>

     com.squareup.okio:okio:1.14.0
     ```

 *  Fix: Handle `HTTP/1.1 100 Continue` status lines, even on requests that did

                  {}, false);
}

TEST_F(CApiFunctionTest, ControlDependency) {
  /*
   *                  |  |    scalar
   *                  |  |    .
   *                  v  v   . <---- control dependency
   *                  add < -
   *                   |
   *                   v
   */
  // Define
  TF_Operation* feed1 = Placeholder(func_graph_, s_, "feed1");

# build is static and TensorFlow symbols (in Python only) are loaded into the
# global symbol table in order to support op registration. This means that
# projects building with Bazel and importing TensorFlow as a dependency will not
# depend on libtensorflow_framework.so unless they opt in.
tf_cc_shared_library(
    name = "tensorflow_framework",
    additional_linker_inputs = [
        "//tensorflow:tf_framework_version_script.lds",

        QueryContext context = queryHelper.build(SearchRequestType.ADMIN_SEARCH, "test", ctx -> {
            // Admin search should not add virtual host filter
            ctx.skipRoleQuery(); // Skip role query to avoid complex dependency issues
        });

        assertNotNull(context);
    }

    @Test
    public void test_buildRoleQuery_emptyRoleSet() {
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();

    throw new InvalidObjectException("Use SerializationProxy");
  }

  /**
   * The actual object that gets serialized. Unfortunately, readResolve() doesn't get called when a
   * circular dependency is present, so the proxy must be able to behave as the map itself.
   */
  abstract static class AbstractSerializationProxy<K, V> extends ForwardingConcurrentMap<K, V>
      implements Serializable {