}
        return targetGradleVersion == candidate
    }

    private static Closure getAnnotationClosure(Class target, Class annotation, Closure defaultValue) {
        def a = target.getAnnotation(annotation)
        a ? a.value().newInstance(target, target) : defaultValue
    }

    private static class PreviousVersionExecution extends org.gradle.integtests.fixtures.extensions.AbstractMultiTestInterceptor.Execution {

	"istio.io/istio/tools/istio-iptables/pkg/constants"
)

func DefaultConfig() *Config {
	return &Config{
		OwnerGroupsInclude: constants.OwnerGroupsInclude.DefaultValue,
		OwnerGroupsExclude: constants.OwnerGroupsExclude.DefaultValue,
	}
}

// Command line options
// nolint: maligned
type Config struct {
	DryRun                  bool     `json:"DRY_RUN"`
	ProxyUID                string   `json:"PROXY_UID"`

    @Override
    @SuppressWarnings("SuspiciousMethodCalls")
    @Nullable
    public String getOrDefault(@Nullable Object key, @Nullable String defaultValue) {
        String value = getAndReport(key);
        if (value == null && !delegate.containsKey(key)) {
            return defaultValue;
        }
        return value;
    }

    @Override
    public boolean containsKey(@Nullable Object key) {

        "$schema": "$schemaValue",
        "$ref": "$refValue",
        "description": "descriptionValue",
        "type": "typeValue",
        "format": "formatValue",
        "title": "titleValue",
        "default": "defaultValue",
        "maximum": 9.5,
        "exclusiveMaximum": true,
        "minimum": 11.5,
        "exclusiveMinimum": true,
        "maxLength": 13,
        "minLength": 14,
        "pattern": "patternValue",

        when:
        def result = getMapUnderTestToRead().getOrDefault(key, 'defaultValue')

        then:
        result == expectedResult
        1 * onAccess.accept(key, reportedValue)
        0 * onAccess._

        where:
        key        | expectedResult  | reportedValue
        'existing' | 'existingValue' | 'existingValue'
        'missing'  | 'defaultValue'  | null
    }


    def "containsKey(#key) is tracked"() {

	}

	// The port was not already excluded - exclude it now.
	outPorts = append(outPorts, portStr)
	return strings.Join(outPorts, ",")
}

func valueOrDefault(value any, defaultValue any) any {
	if value == "" || value == nil {
		return defaultValue
	}
	return value
}

func toJSON(m map[string]string) string {
	if m == nil {
		return "{}"
	}

	ba, err := json.Marshal(m)
	if err != nil {

  string VariableName() const;
  string VariableType() const;
  string AttrNameString() const;
  string VariableStrLen() const;
  string VariableSpanData() const;
  string VariableSpanLen() const;
  string DefaultValue() const;
  string InputArg(bool with_default_value) const;
  string SetterMethod() const;
  std::vector<string> SetterArgs() const;

 private:
  AttrSpec attr_;
};

}  // namespace cpp

  @TestDataPath("$PROJECT_ROOT")
  public class DefaultValues {
    @Test
    public void testAllFilesPresentInDefaultValues() {
      KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/dataFlowInfoProvider/exitPointSnapshot/defaultValues"), Pattern.compile("^(.+)\\.kts$"), null, true);
    }
  }

  @TestDataPath("$PROJECT_ROOT")
  public class DefaultValues {
    @Test
    public void testAllFilesPresentInDefaultValues() {
      KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/components/dataFlowInfoProvider/exitPointSnapshot/defaultValues"), Pattern.compile("^(.+)\\.kts$"), null, true);
    }
  }

          <description>The type of layout this repository uses for locating and storing artifacts - can be "legacy" or
            "default".</description>
          <type>String</type>
          <defaultValue>default</defaultValue>
        </field>
      </fields>
      <codeSegments>
        <codeSegment>
          <version>1.0.0</version>
          <code><![CDATA[
            public boolean equals( Object obj )