if (ShouldPrint(pass, op)) Log(print_callback, pass, op, "after");
}

std::vector<std::string> BridgeLoggerConfig::GetFilter(
    const std::string& env_var) {
  std::vector<std::string> filter;
  const char* filter_str = getenv(env_var.c_str());
  if (filter_str) {
    filter = absl::StrSplit(filter_str, ';', absl::SkipWhitespace());
  }
  return filter;
}

	for _, env := range container.EnvFrom {
		if env.SecretRef != nil {
			if !visitor(env.SecretRef.Name) {
				return false
			}
		}
	}
	for _, envVar := range container.Env {
		if envVar.ValueFrom != nil && envVar.ValueFrom.SecretKeyRef != nil {
			if !visitor(envVar.ValueFrom.SecretKeyRef.Name) {
				return false
			}
		}
	}
	return true
}

func Convert_v1beta3_ControlPlaneComponent_To_kubeadm_ControlPlaneComponent(in *ControlPlaneComponent, out *kubeadm.ControlPlaneComponent, s conversion.Scope) error {
	out.ExtraEnvs = []kubeadm.EnvVar{}
	out.ExtraArgs = convertToArgs(in.ExtraArgs)
	return autoConvert_v1beta3_ControlPlaneComponent_To_kubeadm_ControlPlaneComponent(in, out, s)
}

  bool ShouldPrint(mlir::Pass* pass, mlir::Operation* op);

 private:
  // Get `filter` encoded by environment variable `env_var`.
  static std::vector<std::string> GetFilter(const std::string& env_var);
  // Returns `true` iff any of the strings in `filter` matches `str`, either
  // exactly or as a substring, depending on `exact_match`.
  static bool MatchesFilter(const std::string& str,

O benefício de lançar uma exceção em vez de retornar um valor ficará mais evidente na seção sobre Dependências e Segurança.

	execProbe := &v1.Probe{
		ProbeHandler: v1.ProbeHandler{
			Exec: &v1.ExecAction{},
		},
	}
	tests := []struct {
		probe          *v1.Probe
		env            []v1.EnvVar
		execError      bool
		expectError    bool
		execResult     probe.Result
		expectedResult results.Result
		expectCommand  []string
	}{
		{ // No probe
			probe:          nil,

				EnvFrom: []v1.EnvFromSource{{
					SecretRef: &v1.SecretEnvSource{
						LocalObjectReference: v1.LocalObjectReference{
							Name: "Spec.Containers[*].EnvFrom[*].SecretRef"}}}},
				Env: []v1.EnvVar{{
					ValueFrom: &v1.EnvVarSource{
						SecretKeyRef: &v1.SecretKeySelector{
							LocalObjectReference: v1.LocalObjectReference{
								Name: "Spec.Containers[*].Env[*].ValueFrom.SecretKeyRef"}}}}}}},

    NONE(false),
    ENV_VAR(true),
    KEYSTORE(true);

    companion object {
        fun select(requested: Boolean): EncryptionKind {
            val keyInEnvVar = System.getenv(EnvironmentVarKeySource.GRADLE_ENCRYPTION_KEY_ENV_KEY)
            return when {
                !requested -> NONE
                !keyInEnvVar.isNullOrBlank() -> ENV_VAR
                else -> KEYSTORE
            }

	}
	if obj.Timeouts == nil {
		obj.Timeouts = &Timeouts{}
	}
	SetDefaults_Timeouts(obj.Timeouts)
}

// SetDefaults_EnvVar assigns default values for EnvVar.
// +k8s:defaulter-gen=covers
func SetDefaults_EnvVar(obj *EnvVar) {
	if obj.ValueFrom != nil {
		if obj.ValueFrom.FieldRef != nil {
			if obj.ValueFrom.FieldRef.APIVersion == "" {
				obj.ValueFrom.FieldRef.APIVersion = "v1"
			}
		}
	}

	cases := []struct {
		name               string
		perviouslyInjected bool
		in                 []corev1.EnvVar
		probers            string
		want               []corev1.EnvVar
	}{
		{
			name:               "Append Prober",
			perviouslyInjected: false,
			in:                 []corev1.EnvVar{},
			probers: `{"/app-health/bar/livez":{"httpGet":{"path":"/","port":9000,"scheme":"HTTP"}},` +