// limitations under the License.

package model

const (
	// RDSHttpProxy is the special name for HTTP PROXY route
	RDSHttpProxy = "http_proxy"

	// VirtualOutboundListenerName is the name for traffic capture listener
	VirtualOutboundListenerName = "virtualOutbound"

	// VirtualOutboundCatchAllTCPFilterChainName is the name of the catch all tcp filter chain
	VirtualOutboundCatchAllTCPFilterChainName = "virtualOutbound-catchall-tcp"

void TF_SetPayload(TF_Status* s, const char* key, const char* value) {
  TSL_SetPayload(s, key, value);
}
void TF_ForEachPayload(const TF_Status* s, TF_PayloadVisitor visitor,
                       void* capture) {
  TSL_ForEachPayload(s, visitor, capture);
}
void TF_SetStatusFromIOError(TF_Status* s, int error_code,
                             const char* context) {
  TSL_SetStatusFromIOError(s, error_code, context);
}

	// StartTime is the start time the log capture time range.
	// If set, Since must be unset.
	StartTime time.Time `json:"startTime,omitempty"`
	// EndTime is the end time the log capture time range.
	// Default is now.
	EndTime time.Time `json:"endTime,omitempty"`
	// Since defines the start time the log capture time range.
	// StartTime is set to EndTime - Since.

  std::vector<ImmediateTensorHandlePtr> owned_captures;
  owned_captures.reserve(captures.size());
  for (ImmediateExecutionTensorHandle* capture : captures) {
    capture->Ref();
    owned_captures.push_back(ImmediateTensorHandlePtr(capture));
  }

  out->reset(new FlatTensorFunction(function_def->signature().name(),
                                    std::move(owned_captures), ctx));
  return Status();
}

        loggingManager.getLevel() == null
    }

    public void "can change standard out capture log level"() {
        when:
        loggingManager.captureStandardOutput(LogLevel.ERROR)

        then:
        loggingManager.getStandardOutputCaptureLevel() == LogLevel.ERROR
    }

    public void "can change standard error capture log level"() {
        when:
        loggingManager.captureStandardError(LogLevel.WARN)

                        }
                        useSpock()
                    }
                }
            }

            ${mavenCentralRepository()}
        """
    }

    def "can capture user input if standard input was provided"() {
        when:
        file("src/test/groovy/Test.groovy") << functionalTest("""
            // defer sending the answer until prompted
            def stdin = new PipedInputStream()

        }

        // then:
        val runnableBuildOperation = ArgumentCaptor.forClass(RunnableBuildOperation::class.java)
        verify(buildOperationRunner).run(runnableBuildOperation.capture())

        // and:
        assertThat(
            runnableBuildOperation.value.description().build().progressDisplayName,
            equalTo("Storing configuration cache state")
        )
    }

    @Test

## Architecture Standards

**Experimental!**

We'd like to capture our architectural decisions about the build tool as [Architectural Decision Records (ADRs)](https://adr.github.io/).
For now we just have this global repository of ADRs.
If we see fit, we can break these out to per-platform ones, or keep a hybrid approach to having global and platform-specific ADSs.

Our aim is to keep the process lightweight and approachable.

			CNIMode:          cfg.CNIMode,
			NetworkNamespace: cfg.NetworkNamespace,
		}
	}

	iptConfigurator := capture.NewIptablesConfigurator(cfg, ext)

	if !cfg.SkipRuleApply {
		if err := iptConfigurator.Run(); err != nil {
			return err
		}
		if err := capture.ConfigureRoutes(cfg); err != nil {
			return fmt.Errorf("failed to configure routes: %v", err)
		}
	}
	return nil

   * {@code ArrayList<?>::set}.
   *
   * <p>Instead, {@code <?>} will be resolved to a capture in the form of a type variable {@code
   * <capture-of-? extends Object>}, effectively preventing {@code set} from accepting any type.
   */
  static TypeResolver invariantly(Type contextType) {
    Type invariantContext = WildcardCapturer.INSTANCE.capture(contextType);