# See the License for the specific language governing permissions and
# limitations under the License.
#
################################################################################
#
# Script to configure and start the Istio sidecar.

set -ea

# Load optional config variables
ISTIO_SIDECAR_CONFIG=${ISTIO_SIDECAR_CONFIG:-./var/lib/istio/envoy/sidecar.env}
if [[ -r ${ISTIO_SIDECAR_CONFIG} ]]; then
  # shellcheck disable=SC1090

	}()

	const iters = 5
	for i := 0; i < iters; i++ {
		var w io.Writer
		if i == iters-1 {
			w = os.Stdout
		} else {
			w = new(bytes.Buffer)
		}
		if err := trace.Start(w); err != nil {
			log.Fatalf("failed to start tracing: %v", err)
		}
		time.Sleep(time.Millisecond)
		trace.Stop()
	}
	<-outerDone

	// Trace a few times.
	for i := 0; i < 10; i++ {
		var buf bytes.Buffer
		if err := trace.Start(&buf); err != nil {
			log.Fatalf("failed to start tracing: %v", err)
		}
		runtime.GC()
		trace.Stop()
	}

	// Start tracing again, this time writing out the result.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}
	runtime.GC()
	trace.Stop()

}

configurations {
    create("gradleScriptsElements") {
        isVisible = false
        isCanBeResolved = false
        isCanBeConsumed = true
        attributes.attribute(Usage.USAGE_ATTRIBUTE, objects.named("start-scripts"))
        outgoing.artifact(startScripts)
    }

    assertThat(ComparisonChain.start().compareFalseFirst(false, true).result()).isLessThan(0);
    assertThat(ComparisonChain.start().compareFalseFirst(false, false).result()).isEqualTo(0);
  }

  public void testCompareTrueFirst() {
    assertThat(ComparisonChain.start().compareTrueFirst(true, true).result()).isEqualTo(0);

        broadcaster.finished(op1, finishEvent)
        broadcaster.finished(op2, finishEvent)

        then:
        events == [
            start("1", id1),
            start("2", id1),
            start("3", id1),
            start("1", id2),
            start("2", id2),
            start("3", id2),
            finished("3", id1),
            finished("2", id1),
            finished("1", id1),
            finished("3", id2),

    def "starts operation"() {
        when:
        def op = ops.start("compile", null, new OperationIdentifier(1), null)

        then:
        op.parent == null
        op.operationId.id == 1L
    }

    def "maintains operation hierarchy"() {
        when:
        def op1 = ops.start("compile", null, new OperationIdentifier(1), null)
        def op2 = ops.start("resolve", null, new OperationIdentifier(2), new OperationIdentifier(1))

}

// TODO(brainman): decide if start parameter should be int instead of uint32

// String extracts string from COFF string table st at offset start.
func (st StringTable) String(start uint32) (string, error) {
	// start includes 4 bytes of string table length
	if start < 4 {
		return "", fmt.Errorf("offset %d is before the start of string table", start)
	}
	start -= 4
	if int(start) > len(st) {

    def "allows configuring the start parameter with build arguments"() {
        params.getArguments() >> ['-PextraProperty=foo', '-m']

        when:
        def start = new ProviderStartParameterConverter().toStartParameter(params, layout, properties)

        then:
        start.projectProperties['extraProperty'] == 'foo'
        start.dryRun
    }

    def "the start parameter is configured from properties"() {

		&model.Service{Hostname: "foo.com"}, nil)
	work := func(start time.Time, n int32) {
		v := mkv(n)
		time.Sleep(time.Millisecond * time.Duration(rand.Intn(100)))
		req := &model.PushRequest{Start: start}
		c.Add(k, req, v)
	}
	// 5 round of xds push
	for vals := 0; vals < 5; vals++ {
		c.ClearAll()
		n.Inc()
		start := time.Now()
		for i := 0; i < 5; i++ {
			go work(start, n.Load())
		}
		retry.UntilOrFail(t, func() bool {