return new SampleElements<>(
                        Tables.immutableCell("bar", 1, 'a'),
                        Tables.immutableCell("bar", 2, 'b'),
                        Tables.immutableCell("bar", 3, (Character) null),
                        Tables.immutableCell("bar", 4, 'b'),
                        Tables.immutableCell("bar", 5, 'b'));
                  }

                  @Override

                + "<img src=\"http://example/bar.jpg\">";
        expected = "http://example/foo.jpg";
        assertGetThumbnailUrl(data, expected);

        data = "<img src=\"http://example/foo.jpg\">" //
                + "<img src=\"http://example/bar.jpg\" width=\"100\" height=\"100\">";
        expected = "http://example/bar.jpg";
        assertGetThumbnailUrl(data, expected);

        List<? super String> list) {
      return notSubtype(list);
    }

    // Can't test getSupertype() or getSubtype() because JDK reflection doesn't consider
    // Foo<?> and Foo<? extends Bar> equal for class Foo<T extends Bar>
    @TestSubtype(suppressGetSupertype = true, suppressGetSubtype = true)
    public UseIterable<?> explicitTypeBoundIsSubtypeOfImplicitTypeBound(
        UseIterable<? extends Iterable<?>> obj) {

        when:
        configurationCacheRun 'ok', '-Dfoo=foo'

        then:
        outputContains "*(foo | bar = foo)*"
        configurationCache.assertStateStored()

        when:
        configurationCacheRun 'ok', '-Dbar=bar'

        then:
        outputContains "*(foo | bar = bar)*"
        configurationCache.assertStateLoaded()

        when:
        configurationCacheRun 'ok', '-Dbaz=baz'

     *
     * Relies on the fact that in such references only the last qualifier refers to the
     * actual extension callable, and the part before that refers to the receiver type (either fully
     * or partially qualified).
     *
     * For example, `foo.Foo.bar` may only refer to the extension callable `bar` with

            """
            fun foo(it: Any) = true

            // The inline modifier is important. This does not fail when this is no inline function.
            inline fun bar(f: (Any) -> Boolean) = print("*" + f(Unit) + "*")

            bar(::foo)
            """
        )

        assertThat(
            build().output,
            containsString("*true*")
        )
    }

    @Test

        file("build.gradle.dcl") << declarativeScriptThatConfiguresOnlyTestSoftwareType + """
            anotherSoftwareType {
                foo = "test2"

                bar {
                    baz = "fizz"
                }
            }
        """

        when:
        run(":printTestSoftwareTypeExtensionConfiguration", ":printAnotherSoftwareTypeExtensionConfiguration")

        val referencedSymbolsByFir = listOfNotNull(symbolBuilder.buildSymbol(referencedSymbol))
        val fullQualifiedAccess = when (val psi = fir.source.psi) {
            // for cases like `Foo.Bar()`, where `Foo.Bar` is an object, and `Foo.Bar()` is a call to `invoke` operator
            is KtSimpleNameExpression -> psi.getQualifiedElement()
            else -> psi
        }

                id = "test"

                foo {
                    bar = "baz"
                }
            }
        """
    }

    static String getDeclarativeScriptThatConfiguresOnlyTestSoftwareTypeFoo() {
        return """
            testSoftwareType {
                foo {
                    bar = "baz"
                }
            }
        """
    }

                + "<field name=\"image\"><list><item>taro.png</item><item>jiro.png</item><item>hanako.png</item></list></field>\n"//
                + "<field name=\"email\"><list><item></item><item>******@****.***.bar</item></list></field>\n"//
                + "<field name=\"url\">http://www.taro.com/</field>\n"//