// 1. If host is precise, the request matches this rule if the http host header is equal to Host.
  // 2. If host is a wildcard, then the request matches this rule if the http host header
  // is to equal to the suffix (removing the first label) of the wildcard rule.
  // +optional
  optional string host = 1;

  // IngressRuleValue represents a rule to route requests for this IngressRule.

all
rule 'MD002', :level => 1
rule 'MD007', :indent => 4
rule 'MD013', :line_length => 160, :code_blocks => false, :tables => false
rule 'MD026', :punctuation => ".,;:!"
exclude_rule 'MD013'
exclude_rule 'MD014'
exclude_rule 'MD030'
exclude_rule 'MD032'
exclude_rule 'MD033'
exclude_rule 'MD041'

		} else {
			rMap[id] = rl
		}
	}

	var rules []lifecycle.Rule
	for _, rule := range rMap {
		rules = append(rules, rule)
	}

	// no rules, return
	if len(rules) == 0 {
		return []byte{}, nil
	}

	// get final list for write
	finalLcCfg := lifecycle.Lifecycle{
		XMLName:         xmlName,
		Rules:           rules,
		ExpiryUpdatedAt: &updatedAt,
	}

    static class NewBase extends NewSuperInternal {}

    static class NewSub extends NewBase {}

    Map classes = [:]

    def setup() {
        rule = new MethodsRemovedInInternalSuperClassRule(getInitializationParams())
        rule.context = context
        [OldSuperInternal, NewSuperInternal].each {
            CtClass c = instanceScopedPool.get(it.name)
            c.name = replaceAsInternal(c.name)

                                        <td>${f:h(urlExpr)}<la:hidden property="urlExpr"/></td>
                                    </tr>
                                    <tr>
                                        <th><la:message
                                                key="labels.boost_document_rule_boost_expr"/></th>

    def setup() {
        instanceScopedPool.appendSystemPath()
    }

    void noViolation(def rule) {
        assert rule.maybeViolation(apiClass) == null
    }

    Map getInitializationParams() {
        return [acceptedApiChanges: [:],
            publicApiPatterns: ['gradlebuild[.]binarycompatibility[.]rules.[^.]+'],
            apiChangesJsonFile: new File(testDir, 'test-api-changes.json').path,

class MockWebServerRuleTest {
  @Test fun statementStartsAndStops() {
    val rule = MockWebServerRule()
    val called = AtomicBoolean()
    val statement: Statement =
      rule.apply(
        object : Statement() {
          override fun evaluate() {
            called.set(true)
            rule.server.url("/").toUrl().openConnection().connect()
          }
        },
        Description.EMPTY,
      )

			    <Rule>
		               <Expiration>
		                  <Days>30</Days>
	                          <ExpiredObjectAllVersions>true</ExpiredObjectAllVersions>
	                       </Expiration>
	                       <Filter></Filter>
	                       <Status>Enabled</Status>
			       <ID>DeleteAllVersions</ID>
	                    </Rule>
	                 </LifecycleConfiguration>`

        <rule-config name='ClassName'>
            <property name='regex' value='^[A-Z][\$a-zA-Z0-9]*$'/>
        </rule-config>
        <rule-config name='FieldName'>
            <property name='finalRegex' value='^[a-z][a-zA-Z0-9]*$'/>
            <property name='staticFinalRegex' value='^logger$|^[A-Z][A-Z_0-9]*$|^serialVersionUID$'/>
        </rule-config>
        <rule-config name='MethodName'>

		writeErrorResponse(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	// Create a map of updated set of rules in request
	updatedRules := make(map[string]lifecycle.Rule, len(bucketLifecycle.Rules))
	for _, rule := range bucketLifecycle.Rules {
		updatedRules[rule.ID] = rule
	}

	// Get list of rules for the bucket from disk
	meta, err := globalBucketMetadataSys.GetConfigFromDisk(ctx, bucket)
	if err != nil {