return i + 1;
      }
    }

    return NO_SUFFIX_FOUND;
  }

  /**
   * Returns an instance of {@link InternetDomainName} after lenient validation. Specifically,
   * validation against <a href="http://www.ietf.org/rfc/rfc3490.txt">RFC 3490</a>
   * ("Internationalizing Domain Names in Applications") is skipped, while validation against <a

            task resolve(type: Copy) {
                def artifacts = configurations.compile.incoming.artifactView {
                    attributes { it.attribute(artifactType, 'size') }
                    lenient(providers.gradleProperty("lenient").present)
                }.artifacts
                from artifacts.artifactFiles
                into "\${buildDir}/libs"
            }
        """

        when:

	// http://tools.ietf.org/html/rfc7230#section-5.4
	//     Host = uri-host [ ":" port ]
	//
	// Where uri-host is:
	//     http://tools.ietf.org/html/rfc3986#section-3.2.2
	//
	// But we're going to be much more lenient for now and just
	// search for any byte that's not a valid byte in any of those
	// expressions.
	for i := 0; i < len(h); i++ {
		if !validHostByte[h[i]] {
			return false
		}
	}
	return true
}

                @Override
                public void execute(ArtifactView.ViewConfiguration viewConfiguration) {
                    viewConfiguration.lenient(true);
                    viewConfiguration.componentFilter(getComponentFilter(visitor));
                }
            }).getArtifacts();
        }

                String errorMessage = buildConsoleErrorMessage(report);
                if (verificationMode == DependencyVerificationMode.LENIENT) {
                    LOGGER.error(errorMessage);
                    // Clear failures to avoid printing this error multiple times.
                    failures.clear();
                    hasFatalFailure = false;

            int readByte = in.read();
            if (readByte < 0) {
                return TRANSFORMED;
            }
            // Be lenient - any non-empty file means the JAR isn't transformed.
            return NOT_TRANSFORMED;
        }

        public byte[] asBytes() {
            return markerBody;
        }
    }

        "gradle"     | gradleComponentMetadata('dep') | 'Variant'
    }

    def "does not add a variant for non-existing base in #metadataType metadata if lenient"() {
        given:
        def rule = Mock(Action)

        when:
        metadata.getVariantMetadataRules().addVariant("new-variant", "not-exist", true)

     * Indicates if the model to be built is a local project or a dependency.
     * In case the project is loaded externally from a remote repository (as a dependency or
     * even as an external parent), the POM will be parsed in a lenient way.  Local POMs
     * are parsed more strictly.
     */
    boolean isProjectBuild();

    /**
     * Specifies whether plugin processing should take place for the built model.

        return doRegisterIfAbsent(name, implementationType, () -> {
            // TODO - extract some shared infrastructure to take care of parameter instantiation (eg strict vs lenient, which services are visible)
            P parameters = instantiateParametersOf(implementationType);

            // TODO - should defer execution of the action, to match behaviour for other container `register()` methods.

- `lenient`, which will run the build even if there are verification failures.
The verification errors will be displayed during the build without causing a build failure.
- `off` when verification is totally ignored.

All those modes can be activated on the CLI using the `--dependency-verification` flag, for example:

----
./gradlew --dependency-verification lenient build
----