secondMask:            []int{0},
			expectedFirstNarrower: false,
		},
	}
	for _, tc := range tcases {
		firstMask, _ := NewBitMask(tc.firstMask...)
		secondMask, _ := NewBitMask(tc.secondMask...)
		expectedFirstNarrower := firstMask.IsNarrowerThan(secondMask)
		if expectedFirstNarrower != tc.expectedFirstNarrower {
			t.Errorf("Expected value to be %v, got %v", tc.expectedFirstNarrower, expectedFirstNarrower)
		}

                doLast { submitWorkItem("task1") }
            }

            task secondTask(type: MultipleWorkItemTask) {
                doLast { submitWorkItem("task2") }
            }

            task allTasks {
                dependsOn firstTask, secondTask
            }
        """

        blockingHttpServer.expectConcurrent("task1", "task2")

        expect:

        def secondBase = tmpDir.createDir("secondBase")

        expect:
        fileCollection.files == [
            baseDir.file("a/b/c"),
            baseDir.file("d"),
            baseDir.file("e/f")
        ] as Set


        when:
        baseDirectory.set(secondBase)

        then:
        fileCollection.files == [
            secondBase.file("a/b/c"),

                def outTxt = file("build/first.txt")
                outputs.file(outTxt)
                doLast {
                    outTxt.text = "Done"
                }
            }

            task secondTask {
                dependsOn firstTask
                outputs.cacheIf { true }
                def outTxt = file("build/second.txt")
                outputs.file(outTxt)
                doLast {

            }

            task secondTask {
                def inputDir = file("${outputDir}")
                def outputDir = file("${sourceDir}")
                inputs.dir(inputDir)
                outputs.dir(outputDir)
                doLast {
                    new File(outputDir, "source").text = "fixed"
                }
            }

            secondTask.${relation}(firstTask)
        """

            task anotherTask
            task firstTask
            task secondTask
            task lastTask
            task someTask

            someTask.dependsOn anotherTask
            someTask.dependsOn otherTask
            someTask.mustRunAfter firstTask
            someTask.shouldRunAfter secondTask
            someTask.finalizedBy lastTask
        """
        when:

        _ * ts1.name >> 'firstTask'
        _ * ts1.taskNames >> Sets.newTreeSet([':firstTask'])
        def ts2 = Mock(TaskListingLaunchable)
        _ * ts2.name >> 'secondTask'
        _ * ts2.taskNames >> Sets.newTreeSet([':secondTask'])
        def ts3 = Mock(TaskListingLaunchable)
        _ * ts3.name >> 'thirdTask'
        _ * ts3.taskNames >> Sets.newTreeSet([':thirdTask'])

	_, err := l.Put("foo", "bar")
	assert.NoError(t, err)
	firstHash, err := l.Put("second", "value")
	assert.NoError(t, err)
	secondHash, err := l.Put("foo", "baz")
	assert.NoError(t, err)
	assert.Equal(t, firstHash != secondHash, true)
	lastHash, err := l.Put("foo", "bar")
	assert.NoError(t, err)
	assert.Equal(t, firstHash, lastHash)
}

func MyHasher(data ...[]byte) (result []byte) {

        firstTaskNode.task == a
        assertNoWorkReadyToStart()
        lockedProjects.empty

        when:
        finishedExecuting(firstTaskNode)
        def secondTask = selectNextTask()
        then:
        secondTask == b

        where:
        relation << ["dependsOn", "mustRunAfter"]
    }

    def "two tasks with should run after ordering are executed in parallel"() {

	}

	// Test 1: Remove the object backend files from the first disk.
	z := objLayer.(*erasureServerPools)
	er := z.serverPools[0].sets[0]
	erasureDisks := er.getDisks()
	firstDisk := erasureDisks[0]
	secondDisk := erasureDisks[1]

	fileInfos, errs := readAllFileInfo(ctx, erasureDisks, "", bucket, object, "", false, true)
	fi, err := getLatestFileInfo(ctx, fileInfos, er.defaultParityCount, errs)
	if err != nil {