// Path: src/main/java/org/dmfs/rfc5545/recur/RecurrenceRule.java
// public enum RfcMode
// {
//     /**
//      * Parses recurrence rules according to <a href="http://tools.ietf.org/html/rfc2445#section-4.3.10">RFC 2445</a>. Every error will cause an exception to
//      * be thrown.
//      */
//     RFC2445_STRICT,
// 
//     /**
//      * Parses recurrence rules according to <a href="http://tools.ietf.org/html/rfc2445#section-4.3.10">RFC 2445</a> in a more tolerant way. The parser will
//      * just skip invalid parts in the rule and won't complain as long as the result is a valid rule. <p> This mode also accepts rules that comply with <a
//      * href="http://tools.ietf.org/html/rfc5545#section-3.3.10">RFC 5545</a>. </p> <p> <strong>Note:</strong> Using this mode rules are evaluated
//      * differently than with {@link #RFC5545_LAX}. {@link #RFC5545_LAX} will just drop all invalid parts and evaluate the rule according to RFC 5545. This
//      * mode will evaluate all rules. <p> Also this mode will output rules that comply with RFC 2445. </p>
//      */
//     RFC2445_LAX,
// 
//     /**
//      * Parses recurrence rules according to <a href="http://tools.ietf.org/html/rfc5545#section-3.3.10">RFC 5545</a>. Every error will cause an exception to
//      * be thrown.
//      */
//     RFC5545_STRICT,
// 
//     /**
//      * Parses recurrence rules according to <a href="http://tools.ietf.org/html/rfc5545#section-3.3.10">RFC 5545</a> in a more tolerant way. The parser will
//      * just skip invalid parts in the rule and won't complain as long as the result is a valid rule. <p> This mode also accepts rules that comply with <a
//      * href="http://tools.ietf.org/html/rfc2445#section-4.3.10">RFC 2445</a> but not with RFC 5545. </p> <p> <strong>Note:</strong> Using this mode rules
//      * are evaluated differently than with {@link #RFC2445_LAX}. This mode will just drop all invalid parts and evaluate the rule according to RFC 5545.
//      * {@link #RFC2445_LAX} will evaluate all rules. <p> Also this mode will output rules that comply with RFC 5545. </p>
//      */
//     RFC5545_LAX;
// }


import org.dmfs.rfc5545.DateTime;
import org.dmfs.rfc5545.recur.RecurrenceRule.RfcMode;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import static org.junit.Assert.assertTrue;
					if (count == 10/* RecurrenceIteratorTest.MAX_ITERATIONS */)
					{
						break;
					}
				}
				return instances;
			}
			catch (Exception e)
			{
				e.printStackTrace();
				throw new IllegalArgumentException("Invalid testrule: " + rule.rule);
			}
		}


		public Unit setStart(String start)
		{
			for (TestRule recRule : rules)
			{
				recRule.setStart(start);
			}
			return this;
		}
	}


	@Test
	public void testEquivalence()
	{
		addRules();
// Path: src/main/java/org/dmfs/rfc5545/recur/RecurrenceRule.java
// public enum RfcMode
// {
//     /**
//      * Parses recurrence rules according to <a href="http://tools.ietf.org/html/rfc2445#section-4.3.10">RFC 2445</a>. Every error will cause an exception to
//      * be thrown.
//      */
//     RFC2445_STRICT,
// 
//     /**
//      * Parses recurrence rules according to <a href="http://tools.ietf.org/html/rfc2445#section-4.3.10">RFC 2445</a> in a more tolerant way. The parser will
//      * just skip invalid parts in the rule and won't complain as long as the result is a valid rule. <p> This mode also accepts rules that comply with <a
//      * href="http://tools.ietf.org/html/rfc5545#section-3.3.10">RFC 5545</a>. </p> <p> <strong>Note:</strong> Using this mode rules are evaluated
//      * differently than with {@link #RFC5545_LAX}. {@link #RFC5545_LAX} will just drop all invalid parts and evaluate the rule according to RFC 5545. This
//      * mode will evaluate all rules. <p> Also this mode will output rules that comply with RFC 2445. </p>
//      */
//     RFC2445_LAX,
// 
//     /**
//      * Parses recurrence rules according to <a href="http://tools.ietf.org/html/rfc5545#section-3.3.10">RFC 5545</a>. Every error will cause an exception to
//      * be thrown.
//      */
//     RFC5545_STRICT,
// 
//     /**
//      * Parses recurrence rules according to <a href="http://tools.ietf.org/html/rfc5545#section-3.3.10">RFC 5545</a> in a more tolerant way. The parser will
//      * just skip invalid parts in the rule and won't complain as long as the result is a valid rule. <p> This mode also accepts rules that comply with <a
//      * href="http://tools.ietf.org/html/rfc2445#section-4.3.10">RFC 2445</a> but not with RFC 5545. </p> <p> <strong>Note:</strong> Using this mode rules
//      * are evaluated differently than with {@link #RFC2445_LAX}. This mode will just drop all invalid parts and evaluate the rule according to RFC 5545.
//      * {@link #RFC2445_LAX} will evaluate all rules. <p> Also this mode will output rules that comply with RFC 5545. </p>
//      */
//     RFC5545_LAX;
// }


// Path: src/test/java/org/dmfs/rfc5545/recur/RecurrenceEquivalenceTest.java
import org.dmfs.rfc5545.DateTime;
import org.dmfs.rfc5545.recur.RecurrenceRule.RfcMode;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import static org.junit.Assert.assertTrue;

					if (count == 10/* RecurrenceIteratorTest.MAX_ITERATIONS */)
					{
						break;
					}
				}
				return instances;
			}
			catch (Exception e)
			{
				e.printStackTrace();
				throw new IllegalArgumentException("Invalid testrule: " + rule.rule);
			}
		}


		public Unit setStart(String start)
		{
			for (TestRule recRule : rules)
			{
				recRule.setStart(start);
			}
			return this;
		}
	}


	@Test
	public void testEquivalence()
	{
		addRules();
		for (Unit ruleUnit : mRules)