* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.model.internal.report.unbound;

import com.google.common.collect.ImmutableList;
import javax.annotation.concurrent.NotThreadSafe;
import javax.annotation.concurrent.ThreadSafe;

import java.io.File;
import java.util.List;

@ThreadSafe

- Method invalidRule(org.gradle.api.Task) is not a valid rule method: A method annotated with @Mutate must have void return type.''')
    }

    def "unbound inputs of scoped rules are reported and their scope is shown"() {
        when:
        buildScript '''
            class UnboundRuleSource extends RuleSource {
                @Mutate

		if volume.Spec.ClaimRef == nil {
			// Claim is bound but volume has come unbound.
			// Or, a claim was bound and the controller has not received updated
			// volume yet. We can't distinguish these cases.
			// Bind the volume again and set all states to Bound.

			var dialer Dialer
			// Try to connect to a real host on a port
			// that it is not listening on.
			_, err := dialer.DialContext(ctx, "tcp", "golang.org:3")
			if err == nil {
				t.Errorf("Dial to unbound port succeeded on attempt %d", i)
			}
			<-sem
		}(i)
	}
	wg.Wait()

		"Gauge measuring number of persistent volume currently bound",
		[]string{storageClassLabel}, nil,
		metrics.ALPHA, "")
	unboundPVCountDesc = metrics.NewDesc(
		metrics.BuildFQName("", pvControllerSubsystem, unboundPVKey),
		"Gauge measuring number of persistent volume currently unbound",
		[]string{storageClassLabel}, nil,
		metrics.ALPHA, "")

	boundPVCCountDesc = metrics.NewDesc(

				}
			}
			return true
		}
	}

	// Unless we have exact unification, neither x nor y are interfaces now.
	// Except for unbound type parameters (see below), x and y must be structurally
	// equivalent to unify.

	// If we get here and x or y is a type parameter, they are unbound
	// (not recorded with the unifier).
	// Ensure that if we have at least one type parameter, it is in x

                $("unknown")
              }
            }
        '''

        then:
        fails "tasks"
        failure.assertHasCause('''The following model rules could not be applied due to unbound inputs and/or subjects:

  tasks { ... } @ build.gradle line 3, column 15
    subject:
      - tasks Object
    inputs:
      - unknown Object (@ line 4) [*]

''')
    }

        where:
        order << [ProvidesStringOne, MutatesS1AsInteger].permutations()
    }

    static class ReadS1AsInteger extends RuleSource {
        @Mutate
        void m(Integer unbound, @Path("s1") Integer s1) {

        }
    }

    def "incompatible readable type binding of mutate rule is detected irrespective of discovery order - #order.simpleName"() {
        when:
        order.each {

}

// checkAliasingOneArg checks if f returns a correct result when v and x alias.
//
// f is a function that takes x as an argument, doesn't modify it, sets v to the
// result, and returns v. It is the function signature of unbound methods like
//
//	func (v *big.Int) m(x *big.Int) *big.Int
//
// v and x are two random Int values. v is randomized even if it will be
// overwritten to test for improper buffer reuse.

		return
	}

	// CheckVolumeBindingPred fails if pod has unbound immediate PVCs. If these
	// PVCs have specified StorageClass name, creating StorageClass objects
	// with late binding will cause predicates to pass, so we need to move pods
	// to active queue.
	// We don't need to invalidate cached results because results will not be
	// cached for pod that has unbound immediate PVCs.