public ContinuousOperation setStart(long start) {
        this.start = start;
        return this;
    }

    public ContinuousOperation setFinish(long finish) {
        this.finish = finish;
        return this;
    }

    public long getStartTime() {
        return start;
    }

    @Override
    public long getElapsedTime() {
        return finish - start;
    }

    @Override

}

func (p *printer) lineAt(start int) []byte {
	pos := start
	for pos < len(p.output) && !isNL(p.output[pos]) {
		pos++
	}
	if pos < len(p.output) {
		pos++
	}
	return p.output[start:pos]
}

func (p *printer) commentTextAt(start int) string {
	if start < len(p.output) && p.output[start] == tabwriter.Escape {
		start++
	}
	pos := start

	type fields struct {
		activeBuckets map[BucketOptions]*bucketMeasurement
		endTime       time.Time
		update2       uint64
		endTime2      time.Time
	}
	start := time.Now()
	m0 := newBucketMeasurement(start)
	m0.incrementBytes(0)
	m1MiBPS := newBucketMeasurement(start)
	m1MiBPS.incrementBytes(oneMiB)

	test1Want := make(map[BucketOptions]Details)

            [fromStringList(), "new ProcessBuilder(command).start()", "", ""],
            [fromStringArray(), "new ProcessBuilder(command)?.start()", "", ""],
        ]
    }

        when:
        renderer.onOutput(start(1))
        console.flush()

        then:
        progressArea.display == []
    }

    def "parent progress operation without message is ignored when renderable child completes"() {
        when:
        renderer.onOutput(start(1))
        renderer.onOutput(start(id: 2, parentId: 1, status: ":foo"))
        renderer.onOutput(start(id: 3, parentId: null, status: ":bar"))

        def output = output()

        when:
        output.text(eol)
        output.text(eol)
        output.text("$eol$eol")

        then:
        result.toString() == "{eol}{start}{eol}{start}{eol}{start}{eol}"

        where:
        [type, eol] << EOLS
    }

    def "appends eol to current line [#type]"() {
        def output = output()

        when:
        output.text("some text")

        }
        def action2 = {
            thread.blockUntil.action1Started
            instant.action2Done
        }

        when:
        async {
            start {
                lifecycle.use(action1)
            }
            start {
                lifecycle.use(action2)
            }
        }

        then:
        instant.action1Done > instant.action2Done
    }

	start := i
	for start > 0 && (s[start-1] == ' ' || s[start-1] == '\t') {
		start--
	}
	end := i + 1
	for end < len(s) && (s[end] == ' ' || s[end] == '\t') {
		end++
	}
	// TODO: Do tabs count? That would be a mess.
	if i >= 2 && s[i-1] == ' ' && s[i-2] == ' ' {
		return &HardBreak{}, start, end, true
	}
	return &SoftBreak{}, start, end, true

    def "can execute generated Unix start script in Bash"() {
        given:
        succeeds('installDist')

        when:
        runViaUnixStartScript("bash")

        then:
        outputContains('Hello World!')
    }

    @Requires([UnitTestPreconditions.UnixDerivative, PluginTestPreconditions.DashAvailable])
    def "can execute generated Unix start script in Dash"() {
        given:

	if IsEnabled() {
		t.Skip("skipping because -test.trace is set")
	}
	Stop()
	buf := new(bytes.Buffer)
	if err := Start(buf); err != nil {
		t.Fatalf("failed to start tracing: %v", err)
	}
	if err := Start(buf); err == nil {
		t.Fatalf("succeed to start tracing second time")
	}
	Stop()
	Stop()
}

func saveTrace(t *testing.T, buf *bytes.Buffer, name string) {
	if !*saveTraces {
		return