Compare method and EqualityComparers for rule

splitice · splitice · commit 18dc96956da7 · 2020-05-10T16:16:54.000+10:00
diff --git a/IPTables.Net.Tests/IpTablesComparisonTests.cs b/IPTables.Net.Tests/IpTablesComparisonTests.cs
@@ -27,7 +27,7 @@ public void TestComparisonMultiport()
             IpTablesRule r1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule r2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.IsTrue(r1.Equals(r2));
+            Assert.IsTrue(r1.Compare(r2));
         }
 
         [Test]
@@ -42,7 +42,7 @@ public void TestLimitComparison()
 
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule2, irule);
+            Assert.IsTrue(irule2.Compare(irule));
         }
 
         [Test]
@@ -57,7 +57,7 @@ public void TestDifficultCharacters()
 
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule2, irule);
+            Assert.IsTrue(irule2.Compare(irule));
         }
     }
 }
diff --git a/IPTables.Net.Tests/IpTablesRestoreSyncTests.cs b/IPTables.Net.Tests/IpTablesRestoreSyncTests.cs
@@ -26,7 +26,7 @@ internal void TestApply(IpTablesRuleSet rulesOrig, IpTablesRuleSet rulesSynced,
             catch (Exception ex)
             {
                 Console.WriteLine("Sync:");
-                DumpRuleset(rulesOrig);
+                DumpRuleset(rulesSynced);
                 Console.WriteLine("New:");
                 DumpRuleset(rulesNew);
                 throw;
@@ -540,6 +540,45 @@ public void TestUpdateMiddle()
             }
         }
 
+        [Test]
+        public void TestUpdateUnlabelled()
+        {
+            var mock = new MockIptablesSystemFactory();
+            var system = new IpTablesSystem(mock, new MockIpTablesRestoreAdapter());
+
+            IpTablesRuleSet rulesOriginal = new IpTablesRuleSet(4, new List<String>()
+                                               {
+                                                   "-A INPUT -p tcp -j DROP -m connlimit --connlimit-above 10",
+                                                   "-A INPUT -p udp -j DROP -m connlimit --connlimit-above 2",
+                                                   "-A INPUT -p udp -j DROP -m connlimit --connlimit-above 2",
+                                                   "-A INPUT -p udp -j DROP -m connlimit --connlimit-above 2"
+                                               }, system);
+            IpTablesRuleSet rulesNew = new IpTablesRuleSet(4, new List<String>()
+                                               {
+                                                   "-A INPUT -p tcp -j DROP -m connlimit --connlimit-above 10",
+                                                   "-A INPUT -p udp -j DROP -m connlimit --connlimit-above 28",
+                                                   "-A INPUT -p udp -j DROP -m connlimit --connlimit-above 11",
+                                                   "-A INPUT -p udp -j DROP -m connlimit --connlimit-above 2"
+                                               }, system);
+
+            List<String> expectedCommands = new List<String>
+                                            {
+                                                "*filter", rulesNew.Chains.First().Rules[1].GetActionCommand("-R"), rulesNew.Chains.First().Rules[2].GetActionCommand("-R"), "COMMIT"
+                                            };
+
+
+            using (var client = system.GetTableAdapter(4))
+            {
+                var sync = new DefaultNetfilterSync<IpTablesRule>();
+                var rulesSynced = rulesOriginal.DeepClone();
+                mock.TestSync(client, rulesSynced, rulesNew, sync);
+                var output = (client as IMockIpTablesRestoreGetOutput).GetOutput();
+                CollectionAssert.AreEqual(expectedCommands, output);
+
+                TestApply(rulesOriginal, rulesSynced, rulesNew, expectedCommands);
+            }
+        }
+
 
         [Test]
         public void TestUpdateMiddleTwo()
diff --git a/IPTables.Net.Tests/SingleCommentRuleParseTests.cs b/IPTables.Net.Tests/SingleCommentRuleParseTests.cs
@@ -28,7 +28,7 @@ public void TestDropFragmentedTcpDnsWithCommentEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
         }
 
         [Test]
diff --git a/IPTables.Net.Tests/SingleConnlimitRuleParseTests.cs b/IPTables.Net.Tests/SingleConnlimitRuleParseTests.cs
@@ -27,7 +27,7 @@ public void TestDropConnectionLimitEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
         }
     }
 }
diff --git a/IPTables.Net.Tests/SingleConntrackRuleParseTests.cs b/IPTables.Net.Tests/SingleConntrackRuleParseTests.cs
@@ -18,7 +18,7 @@ public void TestParse()
             IpTablesRule irule2 = IpTablesRule.Parse(rule2, null, chains, 4);
 
             irule2.Equals(irule1);
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
         }
     }
 }
diff --git a/IPTables.Net.Tests/SingleCoreRuleParseTests.cs b/IPTables.Net.Tests/SingleCoreRuleParseTests.cs
@@ -71,7 +71,7 @@ public void TestCoreDropingDestinationEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
         }
 
         [Test]
@@ -83,7 +83,7 @@ public void TestCoreDropingInterfaceEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
         }
 
         [Test]
@@ -95,7 +95,7 @@ public void TestCoreDropingSourceEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
         }
 
         [Test]
@@ -107,7 +107,7 @@ public void TestCoreDropingUdpEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
         }
 
         [Test]
@@ -119,7 +119,7 @@ public void TestCoreFragmentingEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
         }
     }
 }
diff --git a/IPTables.Net.Tests/SingleDnatParseTests.cs b/IPTables.Net.Tests/SingleDnatParseTests.cs
@@ -17,7 +17,7 @@ public void DnatTest1()
             IpTablesRule irule = IpTablesRule.Parse(rule, null, chains, 4);
 
             Assert.AreEqual(rule, irule.GetActionCommand());
-            Assert.AreEqual(irule, IpTablesRule.Parse(rule, null, chains, 4));
+            Assert.IsTrue(irule.Compare(IpTablesRule.Parse(rule, null, chains, 4)));
         }
 
     }
diff --git a/IPTables.Net.Tests/SingleDnatRuleParseTests.cs b/IPTables.Net.Tests/SingleDnatRuleParseTests.cs
@@ -27,7 +27,7 @@ public void TestDnatRangeSourceAndEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
             Assert.AreEqual(rule, irule1.GetActionCommand());
             Assert.AreEqual(rule, irule2.GetActionCommand());
         }
diff --git a/IPTables.Net.Tests/SingleHashlimitRuleParseTests.cs b/IPTables.Net.Tests/SingleHashlimitRuleParseTests.cs
@@ -13,7 +13,7 @@ public void TestCompare1()
             String rule = "-A ABC -m hashlimit --hashlimit-name aaaaaaaaaaaaaaaaaaaaaa --hashlimit-above 125/second --hashlimit-burst 500 --hashlimit-mode dstip,dstport --hashlimit-srcmask 32 --hashlimit-dstmask 32 --hashlimit-htable-size 65000 --hashlimit-htable-max 30000 --hashlimit-htable-expire 6 --hashlimit-htable-gcinterval 600 -j AVS";
             IpTablesChainSet chains = new IpTablesChainSet(4);
 
-            Assert.AreEqual(IpTablesRule.Parse(rule, null, chains, 4), IpTablesRule.Parse(rule, null, chains, 4));
+            Assert.IsTrue(IpTablesRule.Parse(rule, null, chains, 4).Compare(IpTablesRule.Parse(rule, null, chains, 4)));
         }
 
         [Test]
@@ -23,7 +23,7 @@ public void TestCompare2()
             String rule2 = "-A AAAA -t raw -m hashlimit --hashlimit-above 111/sec --hashlimit-burst 500 --hashlimit-mode dstip,dstport --hashlimit-name synflood_spoofe --hashlimit-htable-size 65000 --hashlimit-htable-max 30000 --hashlimit-htable-gcinterval 600 --hashlimit-htable-expire 6 -g AA";
             IpTablesChainSet chains = new IpTablesChainSet(4);
 
-            Assert.AreEqual(IpTablesRule.Parse(rule, null, chains, 4), IpTablesRule.Parse(rule2, null, chains));
+            Assert.IsTrue(IpTablesRule.Parse(rule, null, chains, 4).Compare(IpTablesRule.Parse(rule2, null, chains)));
         }
     }
 }
diff --git a/IPTables.Net.Tests/SingleMarkRuleParseTests.cs b/IPTables.Net.Tests/SingleMarkRuleParseTests.cs
@@ -17,7 +17,7 @@ public void MatchMarkDec()
             IpTablesRule irule = IpTablesRule.Parse(rule, null, chains, 4);
 
             Assert.AreEqual(ruleExpect, irule.GetActionCommand());
-            Assert.AreEqual(IpTablesRule.Parse(ruleExpect, null, chains, 4), irule);
+            Assert.IsTrue(IpTablesRule.Parse(ruleExpect, null, chains, 4).Compare(irule));
         }
 
         [Test]
@@ -30,7 +30,7 @@ public void MatchMarkHex()
             IpTablesRule irule = IpTablesRule.Parse(rule, null, chains, 4);
 
             Assert.AreEqual(ruleExpect, irule.GetActionCommand());
-            Assert.AreEqual(IpTablesRule.Parse(ruleExpect, null, chains, 4), irule);
+            Assert.IsTrue(IpTablesRule.Parse(ruleExpect, null, chains, 4).Compare(irule));
         }
 
 
diff --git a/IPTables.Net.Tests/SingleNfacctRuleParseTests.cs b/IPTables.Net.Tests/SingleNfacctRuleParseTests.cs
@@ -28,7 +28,7 @@ public void TestQuote()
             IpTablesRule irule = IpTablesRule.Parse(rule, null, chains, 4);
 
             Assert.AreEqual(rule2, irule.GetActionCommand());
-            Assert.AreEqual(IpTablesRule.Parse(rule2, null, chains, 4), irule);
+            Assert.IsTrue(IpTablesRule.Parse(rule2, null, chains, 4).Compare(irule));
         }
 
         [Test]
@@ -41,7 +41,7 @@ public void TestDoubleSpace()
             IpTablesRule irule = IpTablesRule.Parse(rule, null, chains, 4);
 
             Assert.AreEqual(rule2, irule.GetActionCommand());
-            Assert.AreEqual(IpTablesRule.Parse(rule2, null, chains, 4), irule);
+            Assert.IsTrue(IpTablesRule.Parse(rule2, null, chains, 4).Compare(irule));
         }
     }
 }
diff --git a/IPTables.Net.Tests/SinglePolyfillTests.cs b/IPTables.Net.Tests/SinglePolyfillTests.cs
@@ -47,7 +47,7 @@ public void TestPolyfillArgumentsComparison1()
             String rule = "-A INPUT -m unknown --unknown --unknown-2 1111 -p tcp -d 1.1.1.1 -m tcp --dport 80";
             IpTablesChainSet chains = new IpTablesChainSet(4);
 
-            Assert.AreEqual(IpTablesRule.Parse(rule, null, chains, 4), IpTablesRule.Parse(rule, null, chains, 4));
+            Assert.IsTrue(IpTablesRule.Parse(rule, null, chains, 4).Compare(IpTablesRule.Parse(rule, null, chains, 4)));
         }
 
         [Test]
@@ -57,7 +57,7 @@ public void TestPolyfillArgumentsComparison2()
                 "-A INPUT -m unknown --unknown --unknown-2 1111 -m unknown2 --unknown2 -p tcp -d 1.1.1.1 -m tcp --dport 80";
             IpTablesChainSet chains = new IpTablesChainSet(4);
 
-            Assert.AreEqual(IpTablesRule.Parse(rule, null, chains, 4), IpTablesRule.Parse(rule, null, chains, 4));
+            Assert.IsTrue(IpTablesRule.Parse(rule, null, chains, 4).Compare(IpTablesRule.Parse(rule, null, chains, 4)));
         }
 
         [Test]
@@ -69,7 +69,7 @@ public void TestPolyfillArgumentsComparison3()
                 "-A INPUT -m unknown2 --unknown2 -m unknown --unknown --unknown-2 1111 -p tcp -d 1.1.1.1 -m tcp --dport 80";
             IpTablesChainSet chains = new IpTablesChainSet(4);
 
-            Assert.AreEqual(IpTablesRule.Parse(rule, null, chains, 4), IpTablesRule.Parse(rule2, null, chains));
+            Assert.IsTrue(IpTablesRule.Parse(rule, null, chains, 4).Compare(IpTablesRule.Parse(rule2, null, chains)));
         }
 
         [Test]
@@ -81,7 +81,7 @@ public void TestPolyfillArgumentsComparison4()
                 "-A INPUT -m unknown2 --unknown2 -m unknown --unknown --unknown-2 \'this has spaces & a symbol\' -p tcp -d 1.1.1.1 -m tcp --dport 80";
             IpTablesChainSet chains = new IpTablesChainSet(4);
 
-            Assert.AreEqual(IpTablesRule.Parse(rule, null, chains, 4), IpTablesRule.Parse(rule2, null, chains));
+            Assert.IsTrue(IpTablesRule.Parse(rule, null, chains, 4).Compare(IpTablesRule.Parse(rule2, null, chains)));
         }
 
         public void TestPolyfillArgumentsComparison5()
diff --git a/IPTables.Net.Tests/SingleRecentRuleParseTests.cs b/IPTables.Net.Tests/SingleRecentRuleParseTests.cs
@@ -35,7 +35,7 @@ public void TestCompare1()
             String rule = "-A ATTK_CHECK -m recent --rcheck --name BANNED --seconds 180 --reap --rttl -j ATTACKED";
             IpTablesChainSet chains = new IpTablesChainSet(4);
 
-            Assert.AreEqual(IpTablesRule.Parse(rule, null, chains, 4), IpTablesRule.Parse(rule, null, chains, 4));
+            Assert.IsTrue(IpTablesRule.Parse(rule, null, chains, 4).Compare(IpTablesRule.Parse(rule, null, chains, 4)));
         }
     }
 }
diff --git a/IPTables.Net.Tests/SingleSnatRuleParseTests.cs b/IPTables.Net.Tests/SingleSnatRuleParseTests.cs
@@ -27,7 +27,7 @@ public void TestSnatRangeSourceAndEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
             Assert.AreEqual(rule, irule1.GetActionCommand());
             Assert.AreEqual(rule, irule2.GetActionCommand());
         }
diff --git a/IPTables.Net.Tests/SingleTcpRuleParseTests.cs b/IPTables.Net.Tests/SingleTcpRuleParseTests.cs
@@ -27,7 +27,7 @@ public void TestDropFragmentedTcpDnsEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
         }
 
         [Test]
@@ -39,7 +39,7 @@ public void TestCoreSportEquality()
             IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);
             IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);
 
-            Assert.AreEqual(irule1, irule2);
+            Assert.IsTrue(irule2.Compare(irule1));
         }
 
         [Test]
diff --git a/IPTables.Net/Iptables/IpTablesChain.cs b/IPTables.Net/Iptables/IpTablesChain.cs
@@ -166,9 +166,10 @@ public override int GetHashCode()
             }
         }
 
-        public bool CompareRules(IpTablesChain ipTablesChain)
+        public bool CompareRules(IpTablesChain ipTablesChain, IEqualityComparer<IpTablesRule> eqc = null)
         {
-            return Enumerable.SequenceEqual(_rules, ipTablesChain._rules);
+            eqc = eqc ?? new IpTablesRule.ValueComparison();
+            return Enumerable.SequenceEqual(_rules, ipTablesChain._rules, eqc);
         }
     }
 }
diff --git a/IPTables.Net/Iptables/IpTablesRule.cs b/IPTables.Net/Iptables/IpTablesRule.cs
diff --git a/IPTables.Net/Iptables/IpTablesRuleSet.cs b/IPTables.Net/Iptables/IpTablesRuleSet.cs
diff --git a/IPTables.Net/Netfilter/INetfilterRule.cs b/IPTables.Net/Netfilter/INetfilterRule.cs
diff --git a/IPTables.Net/Netfilter/TableSync/DefaultNetfilterSync.cs b/IPTables.Net/Netfilter/TableSync/DefaultNetfilterSync.cs

Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public void TestComparisonMultiport()`
`27`	`27`	`IpTablesRule r1 = IpTablesRule.Parse(rule, null, chains, 4);`
`28`	`28`	`IpTablesRule r2 = IpTablesRule.Parse(rule, null, chains, 4);`
`29`	`29`
`30`		`- Assert.IsTrue(r1.Equals(r2));`
	`30`	`+ Assert.IsTrue(r1.Compare(r2));`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`[Test]`
`@@ -42,7 +42,7 @@ public void TestLimitComparison()`
`42`	`42`
`43`	`43`	`IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);`
`44`	`44`
`45`		`- Assert.AreEqual(irule2, irule);`
	`45`	`+ Assert.IsTrue(irule2.Compare(irule));`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`[Test]`
`@@ -57,7 +57,7 @@ public void TestDifficultCharacters()`
`57`	`57`
`58`	`58`	`IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);`
`59`	`59`
`60`		`- Assert.AreEqual(irule2, irule);`
	`60`	`+ Assert.IsTrue(irule2.Compare(irule));`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public void TestDropFragmentedTcpDnsWithCommentEquality()`
`28`	`28`	`IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);`
`29`	`29`	`IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);`
`30`	`30`
`31`		`- Assert.AreEqual(irule1, irule2);`
	`31`	`+ Assert.IsTrue(irule2.Compare(irule1));`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public void TestDropConnectionLimitEquality()`
`27`	`27`	`IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);`
`28`	`28`	`IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);`
`29`	`29`
`30`		`- Assert.AreEqual(irule1, irule2);`
	`30`	`+ Assert.IsTrue(irule2.Compare(irule1));`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public void TestParse()`
`18`	`18`	`IpTablesRule irule2 = IpTablesRule.Parse(rule2, null, chains, 4);`
`19`	`19`
`20`	`20`	`irule2.Equals(irule1);`
`21`		`- Assert.AreEqual(irule1, irule2);`
	`21`	`+ Assert.IsTrue(irule2.Compare(irule1));`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ public void TestCoreDropingDestinationEquality()`
`71`	`71`	`IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);`
`72`	`72`	`IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);`
`73`	`73`
`74`		`- Assert.AreEqual(irule1, irule2);`
	`74`	`+ Assert.IsTrue(irule2.Compare(irule1));`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`[Test]`
`@@ -83,7 +83,7 @@ public void TestCoreDropingInterfaceEquality()`
`83`	`83`	`IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);`
`84`	`84`	`IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);`
`85`	`85`
`86`		`- Assert.AreEqual(irule1, irule2);`
	`86`	`+ Assert.IsTrue(irule2.Compare(irule1));`
`87`	`87`	`}`
`88`	`88`
`89`	`89`	`[Test]`
`@@ -95,7 +95,7 @@ public void TestCoreDropingSourceEquality()`
`95`	`95`	`IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);`
`96`	`96`	`IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);`
`97`	`97`
`98`		`- Assert.AreEqual(irule1, irule2);`
	`98`	`+ Assert.IsTrue(irule2.Compare(irule1));`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`[Test]`
`@@ -107,7 +107,7 @@ public void TestCoreDropingUdpEquality()`
`107`	`107`	`IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);`
`108`	`108`	`IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);`
`109`	`109`
`110`		`- Assert.AreEqual(irule1, irule2);`
	`110`	`+ Assert.IsTrue(irule2.Compare(irule1));`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`[Test]`
`@@ -119,7 +119,7 @@ public void TestCoreFragmentingEquality()`
`119`	`119`	`IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);`
`120`	`120`	`IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);`
`121`	`121`
`122`		`- Assert.AreEqual(irule1, irule2);`
	`122`	`+ Assert.IsTrue(irule2.Compare(irule1));`
`123`	`123`	`}`
`124`	`124`	`}`
`125`	`125`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public void DnatTest1()`
`17`	`17`	`IpTablesRule irule = IpTablesRule.Parse(rule, null, chains, 4);`
`18`	`18`
`19`	`19`	`Assert.AreEqual(rule, irule.GetActionCommand());`
`20`		`- Assert.AreEqual(irule, IpTablesRule.Parse(rule, null, chains, 4));`
	`20`	`+ Assert.IsTrue(irule.Compare(IpTablesRule.Parse(rule, null, chains, 4)));`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public void TestDnatRangeSourceAndEquality()`
`27`	`27`	`IpTablesRule irule1 = IpTablesRule.Parse(rule, null, chains, 4);`
`28`	`28`	`IpTablesRule irule2 = IpTablesRule.Parse(rule, null, chains, 4);`
`29`	`29`
`30`		`- Assert.AreEqual(irule1, irule2);`
	`30`	`+ Assert.IsTrue(irule2.Compare(irule1));`
`31`	`31`	`Assert.AreEqual(rule, irule1.GetActionCommand());`
`32`	`32`	`Assert.AreEqual(rule, irule2.GetActionCommand());`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public void TestCompare1()`
`13`	`13`	`String rule = "-A ABC -m hashlimit --hashlimit-name aaaaaaaaaaaaaaaaaaaaaa --hashlimit-above 125/second --hashlimit-burst 500 --hashlimit-mode dstip,dstport --hashlimit-srcmask 32 --hashlimit-dstmask 32 --hashlimit-htable-size 65000 --hashlimit-htable-max 30000 --hashlimit-htable-expire 6 --hashlimit-htable-gcinterval 600 -j AVS";`
`14`	`14`	`IpTablesChainSet chains = new IpTablesChainSet(4);`
`15`	`15`
`16`		`- Assert.AreEqual(IpTablesRule.Parse(rule, null, chains, 4), IpTablesRule.Parse(rule, null, chains, 4));`
	`16`	`+ Assert.IsTrue(IpTablesRule.Parse(rule, null, chains, 4).Compare(IpTablesRule.Parse(rule, null, chains, 4)));`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`[Test]`
`@@ -23,7 +23,7 @@ public void TestCompare2()`
`23`	`23`	`String rule2 = "-A AAAA -t raw -m hashlimit --hashlimit-above 111/sec --hashlimit-burst 500 --hashlimit-mode dstip,dstport --hashlimit-name synflood_spoofe --hashlimit-htable-size 65000 --hashlimit-htable-max 30000 --hashlimit-htable-gcinterval 600 --hashlimit-htable-expire 6 -g AA";`
`24`	`24`	`IpTablesChainSet chains = new IpTablesChainSet(4);`
`25`	`25`
`26`		`- Assert.AreEqual(IpTablesRule.Parse(rule, null, chains, 4), IpTablesRule.Parse(rule2, null, chains));`
	`26`	`+ Assert.IsTrue(IpTablesRule.Parse(rule, null, chains, 4).Compare(IpTablesRule.Parse(rule2, null, chains)));`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public void MatchMarkDec()`
`17`	`17`	`IpTablesRule irule = IpTablesRule.Parse(rule, null, chains, 4);`
`18`	`18`
`19`	`19`	`Assert.AreEqual(ruleExpect, irule.GetActionCommand());`
`20`		`- Assert.AreEqual(IpTablesRule.Parse(ruleExpect, null, chains, 4), irule);`
	`20`	`+ Assert.IsTrue(IpTablesRule.Parse(ruleExpect, null, chains, 4).Compare(irule));`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`[Test]`
`@@ -30,7 +30,7 @@ public void MatchMarkHex()`
`30`	`30`	`IpTablesRule irule = IpTablesRule.Parse(rule, null, chains, 4);`
`31`	`31`
`32`	`32`	`Assert.AreEqual(ruleExpect, irule.GetActionCommand());`
`33`		`- Assert.AreEqual(IpTablesRule.Parse(ruleExpect, null, chains, 4), irule);`
	`33`	`+ Assert.IsTrue(IpTablesRule.Parse(ruleExpect, null, chains, 4).Compare(irule));`
`34`	`34`	`}`
`35`	`35`
`36`	`36`