}
    }

    /**
     * Call this when an error occurs during class loading.
     * This method only records the error but doesn't throw any exceptions.
     * The exception will be rethrown (wrapped in a ClassNotFoundException) when this thread enters or exits the class loading scope.
     * <p>

        'validation:property-validation:value-not-set' : 'Value not set',
        'validation:type-validation:ignored-annotations-on-method' : 'Ignored annotations on method',
        'validation:type-validation:invalid-use-of-type-annotation' : 'Incorrect use of type annotation',
        'validation:type-validation:not-cacheable-without-reason' : 'Not cacheable without reason',

 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({
    ElementType.PACKAGE,
    ElementType.TYPE,
    ElementType.ANNOTATION_TYPE,
    ElementType.CONSTRUCTOR,
    ElementType.FIELD,
    ElementType.METHOD
})
public @interface Incubating {

 *
 * @since 4.2
 */
@Target({ElementType.TYPE, ElementType.PACKAGE})
@org.jetbrains.annotations.NotNull
@Nonnull
@TypeQualifierDefault({ElementType.METHOD, ElementType.PARAMETER})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface NonNullApi {

 */
@AndroidIncompatible // depends on details of gc

public class GcFinalizationTest extends TestCase {

  // ----------------------------------------------------------------
  // Ordinary tests of successful method execution
  // ----------------------------------------------------------------

  public void testAwait_CountDownLatch() {
    final CountDownLatch latch = new CountDownLatch(1);
    Object x =
        new Object() {

 * limitations under the License.
 */

package org.gradle.internal.cc.impl.serialization.codecs

import org.junit.Test


/**
 * [Lazy] values support Java serialization via a custom `writeReplace` method that forces their evaluation.
 */
class LazyCodecTest : AbstractFunctionalTypeTest() {

    @Test
    fun `forces evaluation of Lazy objects`() {
        assertEagerEvaluationOf(lazy()) {
            value

    def "lists with elements #elements are the same"() {
        expect:
        listOf(elements) == listOf(elements)

        where:
        elements << [["a"], ["a", "b"]]
    }

    def "has a nice toString method"() {
        expect:
        PersistentList.of().toString() == "Nil"
        PersistentList.of("a").toString() == "a"
        PersistentList.of("a", "b").toString() == "a : b"

        title = processCreator.replace("command", varInitializer.description)
        indyStatus = enableIndy ? "with indy" : "without indy"
    }


    // Lift the visibility of the method to make it available for the mixin
    @Override
    TestFile buildScript(@GroovyBuildScriptLanguage String script) {
        super.buildScript(script)
    }

    override val annotations by cached {
        KaFirAnnotationListForDeclaration.create(firSymbol, builder)
    }

    /**
     * Returns [CallableId] of the delegated Java method if the corresponding property of this setter is a synthetic Java property.
     * Otherwise, returns `null`
     */
    override val callableId: CallableId? by cached {
        val fir = firSymbol.fir

			// whereas scheme/method/authority does not:
			// https://github.com/envoyproxy/envoy/blob/v1.29.2/api/envoy/type/matcher/string.proto#L38
			errs = appendErrors(errs, validateStringMatchRegexp(match.GetUri(), "uri"))
			errs = appendErrors(errs, validateStringMatch(match.GetScheme(), "scheme"))
			errs = appendErrors(errs, validateStringMatch(match.GetMethod(), "method"))