def outputProgress = compileJavaOperation.progress(StyledTextOutputEvent)
        // Output may come in different orders, so we just check that all the expected messages are there.
        def text = outputProgress*.details.spans*.text.flatten().join()
        text.count("Unrecognized option: --not-a-real-argument") == 1
        text.count("Error: Could not create the Java Virtual Machine.") == 1

# A note on distributed tracing:
#
# Although Istio proxies are able to automatically send spans, they need some
# hints to tie together the entire trace. Applications need to propagate the
# appropriate HTTP headers so that when the proxies send span information, the
# spans can be correlated correctly into a single trace.
#
# To do this, an application needs to collect and propagate headers from the

            List<XCTestCaseElement> getTestCases() {
                return [testCase("testMultiLineStringContainsSpecificString",
                    '''let longMessage = """
                            When you write a string that spans multiple
                            lines make sure you start its content on a
                            line all of its own, and end it with three
                            quotes also on a line of their own.

                })
                return result
            }

            public func getLongMessage() -> String {
                return "When you write a string that spans multiple\\nlines make sure you start its content on a\\nline all of its own, and end it with three\\nquotes also on a line of their own.\\nMulti-line strings also let you write \\"quote marks\\"\\nfreely inside your strings, which is great!"

)

// TestClientTracing exercises the trace generation features of Istio, based on the Envoy Trace driver for zipkin using
// client initiated tracing using envoy traceheader.
// The test verifies that all expected spans (a client span and a server span for each service call in the sample bookinfo app)
// are generated and that they are all a part of the same distributed trace with correct hierarchy and name.
func TestClientTracing(t *testing.T) {

            @Override
            public String toString() {
                return pattern.toString();
            }
        };
    }

    /**
     * Get the number of lines that the expected message spans.
     *
     * @return the number of lines in this message
     */
    public int getNumLines() {
        return numLines;
    }

    /**

		return false
	}
	systemstack(func() {
		gp := getg().m.curg
		for i := 0; i < batchSize && !(preemptible && gp.preempt); i++ {
			span := work.wbufSpans.free.first
			if span == nil {
				break
			}
			work.wbufSpans.free.remove(span)
			mheap_.freeManual(span, spanAllocWorkBuf)
		}
	})
	more := !work.wbufSpans.free.isEmpty()
	unlock(&work.wbufSpans.lock)
	return more

					i = start
					continue Spans
				}
			}

			// Span is either paragraph or heading.
			if end-start == 1 && isHeading(lines[start]) {
				kind = spanHeading
			} else if end-start == 1 && isOldHeading(lines[start], lines, start) {
				kind = spanOldHeading
			} else {
				kind = spanPara
			}
		}

		spans = append(spans, span{start, end, kind})
		i = end
	}

			if start < 0 {
				start = end
			}
		}
	}

	// Last field might end at EOF.
	if start >= 0 {
		spans = append(spans, span{start, len(s)})
	}

	// Create strings from recorded field indices.
	a := make([]string, len(spans))
	for i, span := range spans {
		a[i] = s[span.start:span.end]
	}

	return a
}

   * error to execute a call more than once.
   */
  fun isExecuted(): Boolean

  fun isCanceled(): Boolean

  /**
   * Returns a timeout that spans the entire call: resolving DNS, connecting, writing the request
   * body, server processing, and reading the response body. If the call requires redirects or
   * retries all must complete within one timeout period.
   *