from fileToReverse
            into parameters.destinationDir
            filter { String line -> line.reverse() }
        }
        if (Boolean.getBoolean("org.gradle.sample.showFileSize")) {
            println "Reversed ${fileToReverse.size()} bytes from ${fileToReverse.name}"
        }
    }
}

abstract class ReverseFiles extends SourceTask {
    private final WorkerExecutor workerExecutor

    @OutputDirectory

    public String toString() {
        if (content.size() == 0) {
            return "<<empty>>";
        }

        StringBuilder out = new StringBuilder();
        List<String> reversed = Lists.reverse(content);
        for (Object item : reversed) {
            out.append(item).append("\n");
        }

        return out.toString();
    }

import spock.lang.Issue

class GroovyJavaJointCompileSourceOrderIntegrationTest extends AbstractIntegrationSpec {

    @Issue("https://issues.apache.org/jira/browse/GROOVY-7966")
    def "compiling Groovy has the same results with reversed file order"() {
        file("src/main/groovy/JavaThing.java") << "public class JavaThing {}"
        file("src/main/groovy/AbstractThing.groovy") << "class AbstractThing {}"

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

package crc32_test

import (
	"fmt"
	"hash/crc32"
)

func ExampleMakeTable() {
	// In this package, the CRC polynomial is represented in reversed notation,
	// or LSB-first representation.
	//
	// LSB-first representation is a hexadecimal number with n bits, in which the
	// most significant bit represents the coefficient of x⁰ and the least significant

		ids = append(ids, string(id.Value))
	}
	return ids, nil
}

func generateReversedMap(m map[IdentityType]int) map[int]IdentityType {
	reversed := make(map[int]IdentityType)
	for key, value := range m {
		reversed[value] = key
	}
	return reversed

        workQueue.await()
        logger.lifecycle("Created ${outputDir.get().asFile.listFiles().length} reversed files in ${projectLayout.projectDirectory.asFile.relativePath(outputDir.get().asFile)}")

        // end::wait-for-completion[]
    }
}

task reverseFiles(type: ReverseFiles) {
    outputDir = layout.buildDirectory.dir("reversed")
    source("sources")

            subject.push(r2)
        }

        assertThat(
            subject.nextGroup(),
            equalTo(requestsInGroup2.reversed())
        )

        assertThat(
            subject.nextGroup(),
            equalTo(requestsInGroup1.reversed())
        )
    }

    @Test
    fun `#nextGroup honours timeout`() {

        val subject = ConcurrentGroupingQueue<Int> { false }

// Reverse returns the value of x with its bits in reversed order.
func Reverse(x uint) uint {
	if UintSize == 32 {
		return uint(Reverse32(uint32(x)))
	}
	return uint(Reverse64(uint64(x)))
}

// Reverse8 returns the value of x with its bits in reversed order.
func Reverse8(x uint8) uint8 {
	return rev8tab[x]
}

// Reverse16 returns the value of x with its bits in reversed order.
func Reverse16(x uint16) uint16 {

        then:
        executedAndNotSkipped(":lib:compileScala")
        notExecuted(":lib:processResources", ":lib:jar")
    }

    def "scala and java source directory compilation order can be reversed (task configuration #configurationStyle)"() {
        given:
        file("src/main/scala/Scala.scala") << "class Scala { }"
        file("src/main/java/Java.java") << "public class Java { Scala scala = new Scala(); }"

import com.google.common.collect.ImmutableMap;
import java.util.Deque;

/** Parser for a map of reversed domain names stored as a serialized radix tree. */
@GwtCompatible
final class TrieParser {

  private static final Joiner DIRECT_JOINER = Joiner.on("");

  /**
   * Parses a serialized trie representation of a map of reversed public suffixes into an immutable