- orRules:
                rules:
                - header:
                    name: :method
                    stringMatch:
                      exact: rule[0]-to[0]-method[1]
                - header:
                    name: :method
                    stringMatch:
                      exact: rule[0]-to[0]-method[2]
            - orRules:
                rules:
                - urlPath:
                    path:

class FreshValueGenerator {

  private static final ImmutableMap<Class<?>, Method> GENERATORS;

  static {
    ImmutableMap.Builder<Class<?>, Method> builder = ImmutableMap.builder();
    for (Method method : FreshValueGenerator.class.getDeclaredMethods()) {
      if (method.isAnnotationPresent(Generates.class)) {
        builder.put(method.getReturnType(), method);
      }
    }
    GENERATORS = builder.buildOrThrow();
  }

        failure.assertHasCause('''Type BrokenRuleSource is not a valid rule source:
- Method broken() is not a valid rule method: A rule method cannot be private
- Method broken() is not a valid rule method: A method annotated with @Validate must have at least one parameter''')
    }

    def "reports unbound parameters for rules on applied RuleSource"() {

    return suite;
  }

  protected Collection<Method> suppressForCheckedNavigableSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptySet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptyNavigableSet() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForEmptySortedSet() {
    return Collections.emptySet();

    }

    def "entry method setValue changes map"() {
        when:
        def map = getMapUnderTestToWrite()
        def entry = map.entrySet().find { entry -> entry.getKey() == 'existing' }

        def result = entry.setValue('newValue')

        then:
        result == 'existingValue'
        map['existing'] == 'newValue'
    }

    def "entry method setValue reports change"() {
        when:

        val loadedClass = loadClass()
        val method = loadedClass.getMethod(methodName)
        val instance = loadedClass.getDeclaredConstructor().newInstance()
        return method.invoke(instance)
    }

    fun callStatic(methodName: String): Any {
        val loadedClass = loadClass()
        val method = loadedClass.getMethod(methodName)
        return method.invoke(loadedClass)
    }

        StubRequest stubRequest = httpStub.request
        String path = stubRequest.path
        assert path.startsWith('/')
        assert path == request.pathInfo
        assert stubRequest.method == request.method
        assert stubRequest.params.every {
            request.getParameterMap()[it.key] == it.value
        }
    }

    boolean requestMatches(HttpStub httpStub, HttpServletRequest request) {

 * A property can be _read_ if there is a method named `get<PropertyName>` with zero arguments that returns the same type as the property.
 * A property can be _modified_ if there is a method named `set<PropertyName>` with one argument that has the same type as the property and a return type of `void`.

  private boolean matches(Test test) {
    Method method;
    try {
      method = extractMethod(test);
    } catch (IllegalArgumentException e) {
      logger.finer(Platform.format("%s: including by default: %s", test, e.getMessage()));
      return true;
    }
    if (suppressedTests.contains(method)) {

// so we can detect and manipulated them here.
//
// There are three ways a method of a reachable type can be invoked:
//
//  1. direct call
//  2. through a reachable interface type
//  3. reflect.Value.Method (or MethodByName), or reflect.Type.Method
//     (or MethodByName)
//
// The first case is handled by the flood fill, a directly called method
// is marked as reachable.
//