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:

        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 {

				hashedServices[firstHash] = svc
			} else {
				// This means we have a collision. Resolve collision by "DoubleHashing".
				i := uint32(1)
				secondHash := uint32(prime) - (s % uint32(prime))
				for {
					nh := (s + i*secondHash) % uint32(maxIPs-1)
					if hashedServices[nh] == nil {
						hashedServices[nh] = svc
						break
					}
					i++
				}
			}
			hash.Reset()
			j++