* @param group the group of the module to be added as a dependency.
     * @param name the name of the module to be added as a dependency.
     * @param version the optional version of the module to be added as a dependency.
     * @param configuration the optional configuration of the module to be added as a dependency.
     * @param classifier the optional classifier of the module artifact to be added as a dependency.

        ) == expectedChanges

        where:
        current                          | expectedChanges
        regularFile("two", 0x1234)       | [added("two")]
        missing("two")                   | [added("two")]
        directoryWithTwoChildren("root") | [added("root"), added("root/one"), added("root/two")]
    }

    def "trivial removal of #previous.type"() {
        expect:
        changes(
            previous,

        ) == [removed('jar2'), added('jar1'), removed('jar1'), added('jar2'), added('jar4'), modified('jar5'), added('jar6')]
    }

    def changes(Map<String, FileSystemLocationFingerprint> current, Map<String, FileSystemLocationFingerprint> previous) {
        def visitor = new CollectingChangeVisitor()
        def strategyConfigurationHash = TestHashCodes.hashCodeFrom(1234)

        DefaultFileChange.removed("somePath", "test", FileType.Directory, "")   | "has been removed"
        DefaultFileChange.added("somePath", "test", FileType.RegularFile, "")   | "has been added"
        DefaultFileChange.added("somePath", "test", FileType.Directory, "")     | "has been added"
    }

     * @param group the group of the module to be added as a dependency.
     * @param name the name of the module to be added as a dependency.
     * @param version the optional version of the module to be added as a dependency.
     * @param configuration the optional configuration of the module to be added as a dependency.
     * @param classifier the optional classifier of the module artifact to be added as a dependency.

 *
 * @param group the group of the module to be added as a dependency.
 * @param name the name of the module to be added as a dependency.
 * @param version the optional version of the module to be added as a dependency.
 * @param configuration the optional configuration of the module to be added as a dependency.
 * @param classifier the optional classifier of the module artifact to be added as a dependency.

	"reflect"
	"testing"

	. "k8s.io/apimachinery/pkg/watch"
)

func TestFilter(t *testing.T) {
	table := []Event{
		{Type: Added, Object: testType("foo")},
		{Type: Added, Object: testType("bar")},
		{Type: Added, Object: testType("baz")},
		{Type: Added, Object: testType("qux")},
		{Type: Added, Object: testType("zoo")},
	}

	source := NewFake()
	filtered := Filter(source, func(e Event) (Event, bool) {

	MOVSD   $L7, X6
	MULSD   X5, X6
	ADDSD   $L5, X6
	MULSD   X5, X6
	ADDSD   $L3, X6
	MULSD   X5, X6
	ADDSD   $L1, X6
	MULSD   X6, X4 // x1= k, x2= f, x3= s, x4= t1, x5= s4
	// t2 := s4 * (L2 + s4*(L4+s4*L6))
	MOVSD   $L6, X6
	MULSD   X5, X6
	ADDSD   $L4, X6
	MULSD   X5, X6
	ADDSD   $L2, X6
	MULSD   X6, X5 // x1= k, x2= f, x3= s, x4= t1, x5= t2
	// R := t1 + t2
	ADDSD   X5, X4 // x1= k, x2= f, x3= s, x4= R

    }

    def added(String path) {
        added((path): path)
    }

    def added(Map<String, String> entry) {
        def singleEntry = Iterables.getOnlyElement(entry.entrySet())
        DefaultFileChange.added(singleEntry.key, "test", FileType.RegularFile, singleEntry.value)
    }

    def removed(String path) {

    def "diff #previous and #current"() {
        expect:
        diff(previous, current) == [removed: removed, updated: updated, added: added]

        where:
        previous             | current              | removed              | updated    | added
        ['a', 'b', 'c']      | ['b', 'c', 'd']      | ['a']                | ['b', 'c'] | ['d']