<td>StackSys</td>
        <td id="StackSys">{{.StackSys}} bytes</td>
        <td>Stack memory obtained from the OS.</td>
    </tr>

    <tr>
        <td>NextGC</td>
        <td id="NextGC">{{.NextGC}} bytes</td>
        <td>Target heap size of the next GC cycle.</td>
    </tr>

    <tr>
        <td>LastGC</td>
        <td id="LastGC"></td>
        <td>The time the last garbage collection finished.</td>

        return (cmpXToRoundArbitrarily <= 0) ? roundArbitrarily : Math.nextUp(roundArbitrarily);
      case DOWN:
        if (sign(x) >= 0) {
          return (cmpXToRoundArbitrarily >= 0)
              ? roundArbitrarily
              : DoubleUtils.nextDown(roundArbitrarily);
        } else {
          return (cmpXToRoundArbitrarily <= 0) ? roundArbitrarily : Math.nextUp(roundArbitrarily);
        }
      case UP:
        if (sign(x) >= 0) {

	resultTag = monitoring.CreateLabel("result")

	wasmCacheEntries = monitoring.NewGauge(
		"wasm_cache_entries",
		"number of Wasm remote fetch cache entries.",
	)

	wasmCacheLookupCount = monitoring.NewSum(
		"wasm_cache_lookup_count",
		"number of Wasm remote fetch cache lookups.",
	)

	wasmRemoteFetchCount = monitoring.NewSum(
		"wasm_remote_fetch_count",

    private ProblemsProgressEventConsumer createProblemsProgressConsumer(ProgressEventConsumer progressEventConsumer) {
        Supplier<OperationIdentifier> operationIdentifierSupplier = () -> new OperationIdentifier(idFactory.nextId());
        AggregatingProblemConsumer aggregator = new AggregatingProblemConsumer(progressEventConsumer, operationIdentifierSupplier);
        this.problemAggregator = Optional.of(aggregator);

            .details(details)
            .build(newOperationIdentifier(), parentId);
    }

    private OperationIdentifier newOperationIdentifier() {
        return new OperationIdentifier(buildOperationIdFactory.nextId());
    }

    private static class Details implements ExecuteTestBuildOperationType.Details {
        private final TestDescriptor testDescriptor;
        private final long startTime;

	"istio.io/istio/pkg/test/echo/common"
	"istio.io/istio/pkg/test/util/retry"
)

var _ Instance = &tcpInstance{}

type tcpInstance struct {
	Config
	l net.Listener
}

func newTCP(config Config) Instance {
	return &tcpInstance{
		Config: config,
	}
}

func (s *tcpInstance) GetConfig() Config {
	return s.Config
}

func (s *tcpInstance) Start(onReady OnReadyFunc) error {

# GOPATH: Set up
env GO111MODULE=off

# GOPATH: Fetch with insecure, should error
! go get -insecure test
stderr 'go: -insecure flag is no longer supported; use GOINSECURE instead'

# Modules: Set up
env GO111MODULE=on

# Modules: Fetch with insecure, should error
! go get -insecure test

// CHECK-NEXT:         value {
// CHECK-NEXT:           tensor {
// CHECK-NEXT:             dtype: DT_INT32
// CHECK-NEXT:             tensor_shape {
// CHECK-NEXT:             }
// CHECK-NEXT:             int_val: 1
// CHECK-NEXT:           }
// CHECK-NEXT:         }
// CHECK-NEXT:       }
// CHECK:          }
// CHECK:          node_def {
// CHECK-NEXT:       name: "tf.Empty"
// CHECK-NEXT:       op: "Empty"

        tf_executor.yield %1 : tensor<i32>
      }
      // CHECK: control_output: "control_const"
      // CHECK:       control_ret {
      // CHECK-NEXT:    key: "control_const"
      // CHECK-NEXT:    value: "control_const"
      // CHECK-NEXT:  }
      tf_executor.fetch %0#1 : !tf_executor.control
    }
    func.return
  }

        %3 = "tf.A"() : () -> tensor<?xi32>
        tf_device.return %3 : tensor<?xi32>
      }) {device = "/device:test_device:0"} : () -> tensor<?xi32>
    // CHECK: tf_executor.fetch %[[LAUNCH_OUTPUT]]
    tf_executor.fetch %1#0 : tensor<?xi32>
  }
  func.return %0 : tensor<?xi32>
}

// CHECK: func private @[[LAUNCH]]
// CHECK-SAME: () -> tensor<?xi32>
// CHECK: %[[A_OUTPUT:[0-9]*]] = "tf.A"()