const auto &output_tensor = (*subgraph.tensors())[buffer];
    std::cout << "\tname: '"
              << (output_tensor->name() ? output_tensor->name()->str()
                                        : "<<unnamed>>")
              << "' buffer: " << buffer;
    if (loc) std::cout << llvm::formatv(" {0}", loc(id)).str();
    std::cout << '\n';
  };

        def addOpensArgs = parameters.effectiveJvmArgs.findAll { it.startsWith("--add-opens") }
        !addOpensArgs.isEmpty()
        addOpensArgs.every { it.matches("--add-opens=.*?/.*?=ALL-UNNAMED") }

        and: "The required --add-opens args should not contain duplicates"
        addOpensArgs.toSet().size() == addOpensArgs.size()
    }

    def "can configure debug mode"() {
        when:

            // For java.util.concurrent.CountDownLatch being serialized reflectively by configuration cache
            executer.withArgument('-Dorg.gradle.jvmargs=--add-opens java.base/java.util.concurrent=ALL-UNNAMED --add-opens java.base/java.util.concurrent.locks=ALL-UNNAMED')
        }

        configureGarbageCollectionHeapEventsFor(256, 512, 100, garbageCollector.monitoringStrategy.thrashingThreshold + 0.2)
        waitForImmediateDaemonExpiration()

	f(A, a, b /* ERROR "cannot use b (variable of type chan<- int) as namedA value in argument to f" */)
	f(A, b /* ERROR "cannot use b (variable of type chan<- int) as namedA value in argument to f" */, a)

	// Unnamed directed channels win over bidirectional channels.
	b = f(a, b)
	b = f(b, a)

	// Defined directed channels win over defined bidirectional channels.
	A = f(A, a)
	A = f(a, A)
	B = f(B, b)
	B = f(b, B)

            }
            @Override
            Iterable<String> asArguments() {
                return test.javaVersion.isCompatibleWith(JavaVersion.VERSION_1_9)
                    ? ["--add-opens=java.base/java.lang=ALL-UNNAMED"]
                    : []
            }
        }
        tasks.withType(Test).configureEach {
            jvmArgumentProviders.add(new AddOpensArgProvider(it))
        }
        """
    }

	C_STAT    = 3   // Static symbol
	C_BLOCK   = 100 // Beginning or end of inner block
	C_FCN     = 101 // Beginning or end of function
	C_FILE    = 103 // Source file name and compiler information
	C_HIDEXT  = 107 // Unnamed external symbol
	C_BINCL   = 108 // Beginning of include file
	C_EINCL   = 109 // End of include file
	C_WEAKEXT = 111 // Weak external symbol
	C_DWARF   = 112 // DWARF symbol
	C_GSYM    = 128 // Global variable

----
include::{snippetsPath}/java-library/module/kotlin/src/main/java/module-info.java[]
----

While a real module cannot directly depend on the unnamed module (only by adding command line flags), automatic modules can also see the unnamed module.
Thus, if you cannot avoid to rely on a library without module information, you can wrap that library in an automatic module as part of your project.

            executer.withArgument('-Dorg.gradle.jvmargs=--add-opens java.base/java.util.concurrent=ALL-UNNAMED')
        }
        fails "verify"

        then:
        if (FluidDependenciesResolveInterceptor.isFluid()) {
            failure.assertHasDescription("Could not determine the dependencies of task ':verify'.")

  }

  TF_Status* status = TF_NewStatus();
  auto clean_status = MakeCleanup([status] { TF_DeleteStatus(status); });

  // Builds TF operation and sets all the attributes.
  std::string node_name = "unnamed";
  if (auto attr = inst->getAttrOfType<mlir::StringAttr>("name")) {
    node_name = std::string(attr.getValue());
  }
  auto node_def_or = ConvertTFDialectOpToNodeDef(

		{NewTypeName(nopos, pkg, "t0", nil), false}, // no type yet
		{t1, false}, // type name refers to named type and vice versa
		{NewTypeName(nopos, nil, "t2", NewInterfaceType(nil, nil)), true}, // type name refers to unnamed type
		{NewTypeName(nopos, pkg, "t3", n1), true},                         // type name refers to named type with different type name