assertTrue(transformer.isValidUrl("http://www.example.com"));
        assertTrue(transformer.isValidUrl("http://www.example.com/aaa"));
        assertTrue(transformer.isValidUrl("https://www.example.com"));
        assertTrue(transformer.isValidUrl("://www.example.com"));
        assertTrue(transformer.isValidUrl("//www.example.com"));

        assertFalse(transformer.isValidUrl(null));

    private final Class<T> clazz;
    private final PropertyListTransformer<T> transformer;
    private T rootObject;

    protected PropertyListPersistableConfigurationObject(Class<T> clazz, PropertyListTransformer<T> transformer) {
        this.clazz = clazz;
        this.transformer = transformer;
    }

    protected abstract T newRootObject();

    @Override

package org.gradle.internal.scripts;

import org.gradle.api.internal.file.FileCollectionFactory;
import org.gradle.internal.classpath.transforms.ClasspathElementTransform;
import org.gradle.internal.classpath.transforms.ClasspathElementTransformFactoryForLegacy;
import org.gradle.internal.classpath.transforms.InstrumentingClassTransform;
import org.gradle.internal.classpath.types.InstrumentationTypeRegistry;

                // queuing the transforms for execution
                // The problem can potentially also be triggered by including many direct dependencies so that the queued transforms start to execute before the main thread sees the second transform
                componentFilter { it instanceof ModuleComponentIdentifier && it.module != 'test' }

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

package org.gradle.model.dsl.internal.transform;

import groovy.lang.Closure;
import org.gradle.api.Transformer;
import org.gradle.internal.BiAction;
import org.gradle.internal.file.RelativeFilePathResolver;
import org.gradle.model.dsl.internal.inputs.PotentialInput;

        then:
        result == transformed

        1 * attributeMatcher.matches(_, _, _) >> Collections.emptyList()
        1 * consumerProvidedVariantFinder.findTransformedVariants(variants, requestedAttributes) >> transformedVariants
        1 * factory.asTransformed(variant, transformedVariants[0].getTransformedVariantDefinition(), dependenciesResolverFactory, transformedVariantFactory) >> transformed
        0 * attributeMatcher._
    }

// license that can be found in the LICENSE file.

package cases

import "golang.org/x/text/transform"

type caseFolder struct{ transform.NopResetter }

// caseFolder implements the Transformer interface for doing case folding.
func (t *caseFolder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
	c := context{dst: dst, src: src, atEOF: atEOF}
	for c.next() {
		foldFull(&c)

    /**
     * Creates a new filtered reader.
     *
     * @param transformer a transformer to filter each line
     * @throws NullPointerException if <code>in</code> is <code>null</code>
     */
    public LineFilter(Reader in, Transformer<String, String> transformer) {
        this.in = in;
        this.bufferedIn = new BufferedReader(in);
        this.transformer = transformer;
    }

                //
                // This may also happen when a transform takes upstream dependencies and the dependencies are transformed using a different transform
                // In this case, the main thread that schedules the work should isolate the transform parameters prior to scheduling the work. However, the dependencies may

    List<String> transform = Lists.transform(listIteratorOnlyList, SOME_FUNCTION);
    assertTrue(
        Iterables.elementsEqual(transform, Lists.transform(randomAccessList, SOME_FUNCTION)));
  }

  private static class ListIterationOnlyList<E> extends ForwardingList<E> {
    private final List<E> realDelegate;

    private ListIterationOnlyList(List<E> realDelegate) {
      this.realDelegate = realDelegate;
    }