details == "File \'${file('missing.toml').absolutePath}\' doesn\'t exist"
            solutions == [ 'Make sure that the catalog file \'missing.toml\' exists before importing it' ]
        }
    }

    def "can use nested versions, libraries and bundles"() {
        tomlFile << """
[versions]
commons-lib = "1.0"

[libraries]

    /**
     * Returns a [KaScopeContext] formed by all imports in the [KtFile].
     *
     * By default, this will also include default importing scopes, which can be filtered by [KaScopeKind]
     */
    public fun KtFile.getImportingScopeContext(): KaScopeContext =
        withValidityAssertion { analysisSession.scopeProvider.getImportingScopeContext(this) }

    if (import_saved_model_object_graph) {
      saved_model_version = 2;
    } else {
      saved_model_version = 1;
    }
    if (input_mlir)
      module = tensorflow::errors::InvalidArgument(
          "Importing saved model should not have input_mlir set");

    tags = absl::StrSplit(saved_model_tags, ',');
    std::vector<std::string> exported_names_vector =

		switch tc := tc.(type) {
		// Most of the concrete image types in the testCases implement the
		// draw.RGBA64Image interface: they have a SetRGBA64 method. We use an
		// interface literal here, instead of importing "image/draw", to avoid
		// an import cycle.
		//
		// The YCbCr and NYCbCrA types are special-cased. Chroma subsampling
		// means that setting one pixel can modify neighboring pixels. They

   *
   * <p>To find the first non-null element in an iterable, use {@code Iterables.find(iterable,
   * Predicates.notNull())}. For varargs, use {@code Iterables.find(Arrays.asList(a, b, c, ...),
   * Predicates.notNull())}, static importing as necessary.
   *
   * <p><b>Note:</b> if {@code first} is represented as an {@link Optional}, this can be
   * accomplished with {@link Optional#or(Object) first.or(second)}. That approach also allows for

                    }
                }
            }
        """
    }

    private TestFile setupSerializableConsumerInterface() {
        // declaring in top-level package, so that importing at usage site is not required.
        file("buildSrc/src/main/java/CustomSerializableConsumer.java") << """
            import java.util.function.Consumer;
            import java.io.Serializable;

   *
   * <p>To find the first non-null element in an iterable, use {@code Iterables.find(iterable,
   * Predicates.notNull())}. For varargs, use {@code Iterables.find(Arrays.asList(a, b, c, ...),
   * Predicates.notNull())}, static importing as necessary.
   *
   * <p><b>Note:</b> if {@code first} is represented as an {@link Optional}, this can be
   * accomplished with {@link Optional#or(Object) first.or(second)}. That approach also allows for

	if _, err := ctxt.Import("example.com/p", gopath, FindOnly); err == nil {
		t.Fatal("importing package when no go.mod is present succeeded unexpectedly")
	} else if errStr := err.Error(); !strings.Contains(errStr, want) {
		t.Fatalf("error when importing package when no go.mod is present: got %q; want %q", errStr, want)
	} else {
		t.Logf(`ctxt.Import("example.com/p", _, FindOnly): %v`, err)
	}

// - If we implement tests for all common functionality using the config of another component and it gets
//   deprecated and/or we stop supporting it in production, we'll have to focus on a massive test refactoring
//   or just continue importing this config just for test use.
//
// Thus, to reduce maintenance costs without sacrificing test coverage, we introduce this mini-framework

	m := make(map[key]analysis.Fact) // one big bucket
	for _, imp := range d.pkg.Imports() {
		logf := func(format string, args ...interface{}) {
			if debug {
				prefix := fmt.Sprintf("in %s, importing %s: ",
					d.pkg.Path(), imp.Path())
				log.Print(prefix, fmt.Sprintf(format, args...))
			}
		}

		// Read the gob-encoded facts.
		data, err := read(imp.Path())
		if err != nil {