// 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)

                    return "Transformer with $provider"
                }
            }
            transform.provider = new FlatMapProvider(Providers.of("value"), transform)
            return transform.provider
        }
    }

    static class FlatMapProviderCircularChainEvaluationTest extends CircularChainEvaluationSpec<String> implements UsesStringProperty {
        @Override

 */

package org.gradle.api.internal.artifacts.transform;

import org.gradle.api.attributes.HasAttributes;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvedVariant;
import org.gradle.api.internal.attributes.ImmutableAttributes;

/**
 * Represents a variant which is produced as the result of applying an artifact transform chain
 * to a root producer variant.
 */

     *
     * @param problem the problem to transform
     * @param id the operation id associated with the problem
     * @return the transformed problem
     */
    Problem transform(Problem problem, OperationIdentifier id);

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

package org.gradle.api.internal.initialization.transform;

import org.gradle.api.artifacts.transform.InputArtifact;
import org.gradle.api.artifacts.transform.TransformOutputs;
import org.gradle.api.file.FileSystemLocation;
import org.gradle.api.provider.Provider;
import org.gradle.api.tasks.Classpath;

import org.gradle.api.artifacts.transform.TransformParameters

// tag::artifact-transform-countloc[]
abstract class CountLoc implements TransformAction<TransformParameters.None> {

    @Inject                                                             // <1>
    abstract InputChanges getInputChanges()

    @PathSensitive(PathSensitivity.RELATIVE)
    @InputArtifact
    abstract Provider<FileSystemLocation> getInput()

    @Override

                @Override
                String toString() {
                    return "BiFunction with $provider"
                }
            }
            transform.provider = new BiProvider(String, Providers.of("A"), Providers.of("B"), transform)
            return transform.provider
        }

        @Override
        List<Consumer<ProviderInternal<?>>> safeConsumers() {
            return [TO_STRING, GET_PRODUCER]
        }

 *
 * <p>The constraints allows certain optimizations. Currently, this is limited to skipping the transform when the provider presence is queried, but other optimizations may be added in the future.
 * Also, because the transform does not use the value content, this provider also skips checks to verify that the content has been built when the value is queried.</p>
 *
 * @see ProviderInternal for a discussion of the "value" and "value contents".

    }

    def 'transforms last segment of path with non-null input'() {
        when:
        action.execute(details);

        then:
        1 * transformer.transform('b') >> 'c'
        1 * details.setRelativePath(new RelativePath(true, "a", "c"))
    }

    def 'does not transform last segment of path with null input'() {
        when:
        action.execute(details);

        this.typeRegistry = typeRegistry;
        this.transform = transform;
    }

    @Override
    public final void transform(File destination) {
        resultBuilder().accept(destination, builder -> {
            try {
                visitEntries(builder);
            } catch (FileException e) {
                // Badly formed archive, so discard the contents and produce an empty JAR