argStrings = p[1:]
	}
	return ExecuteArgs(nil, combinedOutput, parts[0], argStrings...)
}

func ExecuteArgs(env []string, combinedOutput bool, name string, args ...string) (string, error) {
	if scope.DebugEnabled() {
		cmd := strings.Join(args, " ")
		cmd = name + " " + cmd
		scope.Debugf("Executing command: %s", cmd)
	}

	c := exec.Command(name, args...)
	c.Env = env

	var b []byte
	var err error

	} else {
		// Otherwise get everything
		list = c.List()
	}
	list = slices.FilterInPlace(list, func(i T) bool {
		o := c.augment(i)
		return d.filter.Matches(o, true)
	})
	if log.DebugEnabled() {
		log.WithLabels(
			"parent", h.name(),
			"fetch", c.name(),
			"filter", d.filter,
			"size", len(list),
		).Debugf("Fetch")
	}
	return list

        return interpolate(model, null, new DefaultProjectBuilderConfiguration().setExecutionProperties(props), true);
    }

    public Model interpolate(Model model, File projectDir, ProjectBuilderConfiguration config, boolean debugEnabled)
            throws ModelInterpolationException {
        StringWriter sWriter = new StringWriter(1024);

        MavenStaxWriter writer = new MavenStaxWriter();
        try {

        logger.errorEnabled
        logger.quietEnabled
        logger.warnEnabled
        !logger.lifecycleEnabled
        !logger.infoEnabled
        !logger.debugEnabled
        !logger.traceEnabled

        logger.isEnabled(LogLevel.ERROR)
        !logger.isEnabled(LogLevel.INFO)
    }

type zapLogger struct {
	l *Scope
}

const debugLevelThreshold = 3

func (zl *zapLogger) Enabled(level int) bool {
	if level > debugLevelThreshold {
		return zl.l.DebugEnabled()
	}
	return zl.l.InfoEnabled()
}

// Logs will come in with newlines, but our logger auto appends newline
func trimNewline(msg string) string {
	if len(msg) == 0 {
		return msg
	}
	lc := len(msg) - 1

        when:
        System.properties[DefaultGradleRunner.DEBUG_SYS_PROP] = systemPropertyValue

        then:
        createRunner().debug == debugEnabled

        where:
        systemPropertyValue | debugEnabled | description
        "true"              | true         | 'enabled'
        "false"             | false        | 'disabled'
        "test"              | false        | 'disabled'

	for _, s := range suites {
		if IsValidCipherSuite(s) {
			if !validCiphers.InsertContains(s) {
				ret = append(ret, s)
			} else if log.DebugEnabled() {
				log.Debugf("ignoring duplicated cipherSuite: %q", s)
			}
		} else if log.DebugEnabled() {
			log.Debugf("ignoring unsupported cipherSuite: %q", s)
		}
	}
	return ret

	if s.GetOutputLevel() >= DebugLevel {
		msg := maybeSprintf(format, args)
		s.emit(zapcore.DebugLevel, msg)
	}
}

// DebugEnabled returns whether output of messages using this scope is currently enabled for debug-level output.
func (s *Scope) DebugEnabled() bool {
	return s.GetOutputLevel() >= DebugLevel
}

// Name returns this scope's name.
func (s *Scope) Name() string {
	return s.name
}

				RestConfig:               gatewayConformanceInputs.Client.RESTConfig(),
				GatewayClassName:         "istio",
				Debug:                    scopes.Framework.DebugEnabled(),
				CleanupBaseResources:     gatewayConformanceInputs.Cleanup,
				ManifestFS:               []fs.FS{&conformance.Manifests},
				SupportedFeatures:        supportedFeatures,

			// ignore for now
		default:
			adscLog.Infof(protomarshal.ToJSONWithIndent(l, "  "))
		}
	}

	adscLog.Infof("LDS: http=%d tcp=%d size=%d", len(lh), len(lt), ldsSize)
	if adscLog.DebugEnabled() {
		b, _ := json.MarshalIndent(ll, " ", " ")
		adscLog.Debugf(string(b))
	}
	a.mutex.Lock()
	defer a.mutex.Unlock()
	if len(routes) > 0 {
		a.sendRsc(v3.RouteType, routes)
	}