return err
	}
	if len(erep.Status) == 0 {
		erep.Status = Disabled
	}
	e.Status = erep.Status
	return nil
}

// Rule - a rule for replication configuration.
type Rule struct {
	XMLName                 xml.Name                `xml:"Rule" json:"Rule"`
	ID                      string                  `xml:"ID,omitempty" json:"ID,omitempty"`

        while (!source.exhausted()) {
          var rule: ByteString = source.readUtf8LineStrict().toRule() ?: continue

          if (rule.startsWith(EXCEPTION_RULE_MARKER)) {
            rule = rule.substring(1)
            // We use '\n' for end of value.
            totalExceptionRuleBytes += rule.size + 1
            sortedExceptionRules.add(rule)
          } else {
            totalRuleBytes += rule.size + 1 // We use '\n' for end of value.

    val rule = findMatchingRule(domainLabels)
    if (domainLabels.size == rule.size && rule[0][0] != EXCEPTION_MARKER) {
      return null // The domain is a public suffix.
    }

    val firstLabelOffset =
      if (rule[0][0] == EXCEPTION_MARKER) {
        // Exception rules hold the effective TLD plus one.
        domainLabels.size - rule.size
      } else {

			// we can skip this rule if it doesn't match the tested
			// prefix.
			if !strings.HasPrefix(prefix, rule.GetPrefix()) && !strings.HasPrefix(rule.GetPrefix(), prefix) {
				continue
			}
		}

		if rule.NoncurrentVersionExpiration.NoncurrentDays > 0 {
			return true
		}
		if rule.NoncurrentVersionExpiration.NewerNoncurrentVersions > 0 {
			return true
		}

	if len(c.Rules) == 0 {
		return false
	}
	for _, rule := range c.Rules {
		if rule.Status == Disabled {
			continue
		}
		if len(prefix) > 0 && len(rule.Filter.Prefix) > 0 {
			// incoming prefix must be in rule prefix
			if !recursive && !strings.HasPrefix(prefix, rule.Filter.Prefix) {
				continue
			}
			// If recursive, we can skip this rule if it doesn't match the tested prefix or level below prefix

			parts = append(parts, fmt.Sprintf("Mode: %s", config.Rule.DefaultRetention.Mode))
		}
		if config.Rule.DefaultRetention.Days != nil {
			parts = append(parts, fmt.Sprintf("Days: %d", *config.Rule.DefaultRetention.Days))
		}
		if config.Rule.DefaultRetention.Years != nil {
			parts = append(parts, fmt.Sprintf("Years: %d", *config.Rule.DefaultRetention.Years))
		}
	}
	return strings.Join(parts, ", ")
}

		{ObjectOpts{Name: "abc/c4test", DeleteMarker: true, OpType: DeleteReplicationType}, cfgs[3], true},                                      // 36. matches rule 2 - DeleteMarker replication allowed by rule

	testCases := []struct {
		inputConfig    string
		opts           ObjectOpts
		expectedResult bool
	}{
		// case 1 - rule with replica modification enabled; not a replica
		{

    CtClass internalInterface
    CtClass incubatingInterface
    CtClass stablePublicInterface

    Map interfaces

    def setup() {
        rule = new IncubatingInternalInterfaceAddedRule(getInitializationParams())
        rule.context = context

        oldBase = instanceScopedPool.get(OldBase.name)
        newBase = instanceScopedPool.get(NewBase.name)
        newSuper = instanceScopedPool.get(NewSuper.name)

```
@Rule public final MockWebServerRule serverRule = new MockWebServerRule();
```

The `serverRule` field has a `server` field. It is an instance of `MockWebServer`. That instance
will be shut down automatically after the test runs.

For Kotlin, the `@JvmField` annotation is also necessary:

```
@JvmField @Rule val serverRule = MockWebServerRule()