t.Logf("got span %+v, want span %+v", got, want)
		return false
	}
	if len(got.ChildSpans) < len(want.ChildSpans) {
		t.Logf("got %d child spans from, want %d child spans, maybe trace has not be fully reported",
			len(got.ChildSpans), len(want.ChildSpans))
		return false
	} else if len(got.ChildSpans) > len(want.ChildSpans) {

            new ListSerializer<StyledTextOutputEvent.Span>(
                new SpanSerializer(serializerFactory.getSerializerFor(StyledTextOutput.Style.class))))
    }

    def "can serialize StyledTextOutputEvent messages"() {
        given:
        List spans = [new StyledTextOutputEvent.Span(StyledTextOutput.Style.Description, "description"),
                      new StyledTextOutputEvent.Span(StyledTextOutput.Style.Error, "error")]

        List spans = [new StyledTextOutputEvent.Span(StyledTextOutput.Style.UserInput, 'UserInput'),
                new StyledTextOutputEvent.Span(StyledTextOutput.Style.Normal, 'Normal'),
                new StyledTextOutputEvent.Span(StyledTextOutput.Style.Header, 'Header')
        ]
        def event = new StyledTextOutputEvent(100, 'category', LogLevel.LIFECYCLE, null, spans)

        when:
        event.render(output)

	if span.list != list {
		print("runtime: failed mSpanList.remove span.npages=", span.npages,
			" span=", span, " prev=", span.prev, " span.list=", span.list, " list=", list, "\n")
		throw("mSpanList.remove")
	}
	if list.first == span {
		list.first = span.next
	} else {
		span.prev.next = span.next
	}
	if list.last == span {
		list.last = span.prev
	} else {
		span.next.prev = span.prev

//   can free a whole span if none of the objects are marked, but that
//   isn't its goal. This can be driven either synchronously by
//   mcentral.cacheSpan for mcentral spans, or asynchronously by
//   sweepone, which looks at all the mcentral lists.
//
// * The span reclaimer looks for spans that contain no marked objects
//   and frees whole spans. This is a separate algorithm because

			scopes.Framework.Debugf("cannot parse or cannot find spans in trace object %+v", t)
			continue
		}
		var spans []Span
		for _, obj := range spanObjs {
			newSpan := buildSpan(obj)
			spans = append(spans, newSpan)
		}
		for p := range spans {
			for c := range spans {
				if spans[c].ParentSpanID == spans[p].SpanID {
					spans[p].ChildSpans = append(spans[p].ChildSpans, &spans[c])
				}
			}

// TODO(bianpengyuan) consider using zipkin proto api https://github.com/istio/istio/issues/13926
type Span struct {
	SpanID       string
	ParentSpanID string
	ServiceName  string
	Name         string
	ChildSpans   []*Span
}

// Trace represents a trace by a collection of spans which all belong to that trace
type Trace struct {
	Spans []Span
}

// New returns a new instance of zipkin.

issue:
  - 28801

releaseNotes:
- |
  **Added** canonical service tags to Envoy-generated trace spans.
upgradeNotes:
  - title: Service Tags added to trace spans
    content: |
      Istio now configures Envoy to include tags identifying the canonical service for a workload in generated trace spans.

      This will lead to a small increase in storage per span for tracing backends.

        OperationIdentifier buildOperationId = decoder.readBoolean() ? new OperationIdentifier(decoder.readSmallLong()) : null;
        List<StyledTextOutputEvent.Span> spans = spanSerializer.read(decoder);
        return new StyledTextOutputEvent(timestamp, category, logLevel, buildOperationId, spans);
    }

	// this block. This number is used to help determine when a block
	// may be safely recycled.
	popped atomic.Uint32

	// spans is the set of spans in this block.
	spans [spanSetBlockEntries]atomicMSpanPointer
}

// push adds span s to buffer b. push is safe to call concurrently
// with other push and pop operations.
func (b *spanSet) push(s *mspan) {
	// Obtain our slot.