// guarded by db.mu
	inUse      bool
	dbmuClosed bool      // same as closed, but guarded by db.mu, for removeClosedStmtLocked
	returnedAt time.Time // Time the connection was created or returned.
	onPut      []func()  // code (with db.mu held) run when conn is next returned
}

func (dc *driverConn) releaseConn(err error) {
	dc.db.putConn(dc, err, true)
}

func (dc *driverConn) removeOpenStmt(ds *driverStmt) {

			}

			// Validate freeConn order.
			var last time.Time
			for _, c := range db.freeConn {
				if last.After(c.returnedAt) {
					t.Error("freeConn is not ordered by returnedAt")
					break
				}
				last = c.returnedAt
			}

			db.mu.Unlock()
			for _, c := range closing {
				c.Close()
			}
			if g, w := int64(len(closing)), item.wantIdleClosed; g != w {

// errInvalidRange - returned when given range value is not valid.
var errInvalidRange = errors.New("Invalid range")

// errInvalidRangeSource - returned when given range value exceeds
// the source object size.
var errInvalidRangeSource = errors.New("Range specified exceeds source object size")

// error returned by disks which are to be initialized are waiting for the

            import ${Project.name};

            public class SomePlugin implements Plugin<Project> {
                public void apply(Project project) {
                    Object returned = $method;
                    System.out.println("returned = " + returned);
                }
            }
        """

        buildScript("""
            apply plugin: SomePlugin
        """)

        when:

            @CompileStatic
            class SomePlugin implements Plugin<Project> {
                void apply(Project project) {
                    def returned = $method
                    println("returned = \$returned")
                }
            }
        """

        buildScript("""
            apply plugin: SomePlugin
        """)

        when:

            import static ${System.name}.setProperty

            class SomePlugin implements Plugin<Project> {
                void apply(Project project) {
                    def returned = $method
                    println("returned = \$returned")
                }
            }
        """
        file("buildSrc/build.gradle") << """
            compileGroovy {
                groovyOptions.optimizationOptions.indy = $enableIndy

            public class $pluginName implements Plugin<Project> {
                @Override
                public void apply(Project project) {
                    String returned = System.getProperty("$propertyName");
                    System.out.println("returned = " + returned);
                }
            }
        """
        file("$folder/build.gradle") << """
            plugins {
                id("java-gradle-plugin")

   * returned ordering is based on the state of the {@code comparators} iterable at the time it was
   * provided to this method.
   *
   * <p>The returned ordering is equivalent to that produced using {@code
   * Ordering.from(comp1).compound(comp2).compound(comp3) . . .}.
   *
   * <p>The returned object is serializable if each of the {@code comparators} is serializable.
   *

   * returned ordering is based on the state of the {@code comparators} iterable at the time it was
   * provided to this method.
   *
   * <p>The returned ordering is equivalent to that produced using {@code
   * Ordering.from(comp1).compound(comp2).compound(comp3) . . .}.
   *
   * <p>The returned object is serializable if each of the {@code comparators} is serializable.
   *

            import ${Project.name}

            class SomePlugin : Plugin<Project> {
                override fun apply(project: Project) {
                    val returned = $method
                    println("returned = \$returned")
                }
            }
        """

        file("buildSrc/build.gradle.kts") << """
            plugins {
                `kotlin-dsl`
            }