ruleManager.addRule(rule1);
        ruleManager.addRule(rule3);
        ruleManager.addRule(1, rule2); // Insert in middle

        List<Rule> rules = ruleManager.getRules();
        assertEquals(3, rules.size());
        assertEquals("rule1", rules.get(0).getRuleId());
        assertEquals("rule2", rules.get(1).getRuleId());
        assertEquals("rule3", rules.get(2).getRuleId());
    }

    /**

        assertTrue(ruleManager.hasRule(rule2));
        assertTrue(ruleManager.hasRule(rule3));

        ruleManager.removeRule(rule2);

        assertFalse(ruleManager.hasRule(rule2));
        assertTrue(ruleManager.hasRule(rule3));

        ruleManager.removeRule(rule3);

        assertFalse(ruleManager.hasRule(rule2));
        assertFalse(ruleManager.hasRule(rule3));
    }

            if (rule != null) {
                rules.add(rule);
            }
        }

        @Override
        public void addRule(int index, Rule rule) {
            if (rule != null) {
                rules.add(index, rule);
            }
        }

        @Override
        public boolean removeRule(Rule rule) {
            return rules.remove(rule);
        }

        assertSame(sharedProcessor, rule1.getResponseProcessor());
        assertSame(sharedProcessor, rule2.getResponseProcessor());
        assertSame(sharedProcessor, rule3.getResponseProcessor());

        // Different rule IDs
        assertEquals("rule1", rule1.getRuleId());
        assertEquals("rule2", rule2.getRuleId());
        assertEquals("rule3", rule3.getRuleId());

        // Different match results

 * and obtain the associated response processor.
 */
public interface Rule extends Serializable {

    /**
     * Determines if the given response data matches the rule.
     *
     * @param responseData the response data to be evaluated
     * @return true if the response data matches the rule, false otherwise
     */

		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"`

# no rules should be needed

-whyareyoukeeping class okhttp3.internal.idn.IdnaMappingTable {
  *;

					rules[5],
				},
			},
			opts: ObjectOpts{
				IsLatest: true,
				UserTags: "key1=val1",
				Name:     "obj-1",
				Size:     1*humanize.MiByte - 1,
			},
			hasRules: true,
		},
		{ // PUT version with size based filters
			lc: Lifecycle{
				Rules: []Rule{
					rules[1],
					rules[2],
					rules[3],
					rules[4],
					rules[5],
				},
			},

		{ObjectOpts{Name: "xyz/c3test", DeleteMarker: true, OpType: DeleteReplicationType}, cfgs[2], true},                                      // 24. matches rule 2 - DeleteMarker replication allowed by rule

			continue
		}
		if rule.Filter.TestTags(obj.UserTags) {
			rules = append(rules, rule)
		}
	}
	sort.Slice(rules, func(i, j int) bool {
		return rules[i].Priority > rules[j].Priority && rules[i].Destination.String() == rules[j].Destination.String()
	})

	return rules
}

// GetDestination returns destination bucket and storage class.
func (c Config) GetDestination() Destination {