2008-08-24 Sebastien Pouliot <sebastien@ximian.com>

	* FeatureRequiresRootPrivilegeOnUnixRule.cs: Convert to the new
	test API. Add a few more cases to get better unit tests coverage.


svn path=/trunk/mono-tools/; revision=111503

2 files changed, 56 insertions, 66 deletions

diff --git a/gendarme/rules/Gendarme.Rules.Portability/Test/ChangeLog b/gendarme/rules/Gendarme.Rules.Portability/Test/ChangeLog
index 32d05dbc..20ff546a 100644
--- a/gendarme/rules/Gendarme.Rules.Portability/Test/ChangeLog
+++ b/gendarme/rules/Gendarme.Rules.Portability/Test/ChangeLog
@@ -1,3 +1,8 @@
+2008-08-24  Sebastien Pouliot  <sebastien@ximian.com>
+
+	* FeatureRequiresRootPrivilegeOnUnixRule.cs: Convert to the new
+	test API. Add a few more cases to get better unit tests coverage.
+
 2008-08-07  Sebastien Pouliot  <sebastien@ximian.com>
 
 	* DoNotHardcodePathsTest.cs: Add test case from Richard Birkby 
diff --git a/gendarme/rules/Gendarme.Rules.Portability/Test/FeatureRequiresRootPrivilegeOnUnixTest.cs b/gendarme/rules/Gendarme.Rules.Portability/Test/FeatureRequiresRootPrivilegeOnUnixTest.cs
index e04f8109..3d974d79 100644
--- a/gendarme/rules/Gendarme.Rules.Portability/Test/FeatureRequiresRootPrivilegeOnUnixTest.cs
+++ b/gendarme/rules/Gendarme.Rules.Portability/Test/FeatureRequiresRootPrivilegeOnUnixTest.cs
@@ -34,7 +34,10 @@ using System.Net.NetworkInformation;
 using Gendarme.Framework;
 using Gendarme.Rules.Portability;
 using Mono.Cecil;
+
 using NUnit.Framework;
+using Test.Rules.Definitions;
+using Test.Rules.Fixtures;
 using Test.Rules.Helpers;
 
 namespace Test.Rules.Portability {
@@ -42,13 +45,18 @@ namespace Test.Rules.Portability {
 	class MyPing : Ping { } //MyPing..ctor calls Ping..ctor, this triggers the rule.
 	class MyProcess : Process { } //Using MyProcess.PriorityClass calls Process.PriorityClass. The property is not virtual.
 
+	class ProcessLookAlike {
+		public ProcessPriorityClass PriorityClass { get; set; }
+	}
+
 	[TestFixture]
-	public class FeatureRequiresRootPrivilegeOnUnixTest {
+	public class FeatureRequiresRootPrivilegeOnUnixTest : MethodRuleTestFixture<FeatureRequiresRootPrivilegeOnUnixRule> {
 
-		private FeatureRequiresRootPrivilegeOnUnixRule rule;
-		private TestRunner runner;
-		private AssemblyDefinition assembly;
-		private TypeDefinition type;
+		[Test]
+		public void DoesNotApply ()
+		{
+			AssertRuleDoesNotApply (SimpleMethods.ExternalMethod);
+		}
 
 		public void SetPriority ()
 		{
@@ -62,112 +70,89 @@ namespace Test.Rules.Portability {
 			p.PriorityClass = ProcessPriorityClass.Normal;
 		}
 
-		public void SetPriorityNormalVariable ()
-		{
-			ProcessPriorityClass priority = ProcessPriorityClass.Normal;
-			Process p = new Process ();
-			p.PriorityClass = priority;
-		}
-
 		public void SetMyPriority ()
 		{
 			MyProcess p = new MyProcess ();
 			p.PriorityClass = ProcessPriorityClass.AboveNormal;
 		}
 
-		public void CreatePing ()
-		{
-			new Ping ();
-		}
-
-		public void CreateObject ()
+		public void SetLookAlikePriority ()
 		{
-			new object ();
+			ProcessLookAlike p = new ProcessLookAlike ();
+			p.PriorityClass = ProcessPriorityClass.AboveNormal;
 		}
 
-		public void UsePing (Ping ping)
+		[Test]
+		public void TestSetPriority ()
 		{
-			// e.g. Ping could be supplied from another assembly
-			// but Gendarme should still flag it's usage inside the analyzed assembly
-			ping.Send ("127.0.0.1");
+			AssertRuleFailure<FeatureRequiresRootPrivilegeOnUnixTest> ("SetPriority", 1);
+			AssertRuleFailure<FeatureRequiresRootPrivilegeOnUnixTest> ("SetMyPriority", 1);
+			AssertRuleSuccess<FeatureRequiresRootPrivilegeOnUnixTest> ("SetPriorityNormal");
+			AssertRuleSuccess<FeatureRequiresRootPrivilegeOnUnixTest> ("SetLookAlikePriority");
 		}
 
-		[TestFixtureSetUp]
-		public void FixtureSetUp ()
+		public void SetPriorityUnknown (ProcessPriorityClass priority)
 		{
-			string unit = Assembly.GetExecutingAssembly ().Location;
-			assembly = AssemblyFactory.GetAssembly (unit);
-			type = assembly.MainModule.Types ["Test.Rules.Portability.FeatureRequiresRootPrivilegeOnUnixTest"];
-			rule = new FeatureRequiresRootPrivilegeOnUnixRule ();
-			runner = new TestRunner (rule);
+			Process p = new Process ();
+			p.PriorityClass = priority;
 		}
 
-		private MethodDefinition GetTest (string name)
+		public void SetPriorityNormalVariable ()
 		{
-			foreach (MethodDefinition method in type.Methods) {
-				if (method.Name == name)
-					return method;
-			}
-			return null;
+			ProcessPriorityClass priority = ProcessPriorityClass.Normal;
+			Process p = new Process ();
+			p.PriorityClass = priority;
 		}
 
-		[Test]
-		public void TestSetPriority ()
+		public void SetPriorityAboveNormalVariable ()
 		{
-			MethodDefinition method = GetTest ("SetPriority");
-			Assert.AreEqual (RuleResult.Failure, runner.CheckMethod (method));
+			ProcessPriorityClass priority = ProcessPriorityClass.AboveNormal;
+			Process p = new Process ();
+			p.PriorityClass = priority;
 		}
 
 		[Test]
-		public void TestSetMyPriority ()
+		public void TestSetPriorityVariable ()
 		{
-			MethodDefinition method = GetTest ("SetMyPriority");
-			Assert.AreEqual (RuleResult.Failure, runner.CheckMethod (method));
+			AssertRuleSuccess<FeatureRequiresRootPrivilegeOnUnixTest> ("SetPriorityNormalVariable");
+			AssertRuleSuccess<FeatureRequiresRootPrivilegeOnUnixTest> ("SetPriorityUnknown");
 		}
 
 		[Test]
-		public void TestSetPriorityNormal ()
+		[Ignore ("we don't track variables value")]
+		public void TestSetPriorityAboveVariable ()
 		{
-			MethodDefinition method = GetTest ("SetPriorityNormal"); //allowed value
-			Assert.AreEqual (RuleResult.Success, runner.CheckMethod (method));
+			AssertRuleFailure<FeatureRequiresRootPrivilegeOnUnixTest> ("SetPriorityAboveNormalVariable", 1);
 		}
 
-		[Test]
-		[Ignore ("we warn if the value is set from a variable")]
-		public void TestSetPriorityNormalVariable ()
+		public void CreatePing ()
 		{
-			MethodDefinition method = GetTest ("SetPriorityNormalVariable");
-			Assert.AreEqual (RuleResult.Success, runner.CheckMethod (method));
+			new Ping ();
 		}
 
-		[Test]
-		public void TestMyPing ()
+		public void UsePing (Ping ping)
 		{
-			TypeDefinition type = assembly.MainModule.Types ["Test.Rules.Portability.MyPing"]; //this class extends Ping
-			MethodDefinition method = type.Constructors [0]; //the constructor calls the base constructor
-			Assert.AreEqual (RuleResult.Failure, runner.CheckMethod (method));
+			// e.g. Ping could be supplied from another assembly
+			// but Gendarme should still flag it's usage inside the analyzed assembly
+			ping.Send ("127.0.0.1");
 		}
 
 		[Test]
 		public void TestCreatePing ()
 		{
-			MethodDefinition method = GetTest ("CreatePing"); // calls new Ping ()
-			Assert.AreEqual (RuleResult.Failure, runner.CheckMethod (method));
+			AssertRuleFailure<FeatureRequiresRootPrivilegeOnUnixTest> ("CreatePing", 1);
+			AssertRuleFailure<FeatureRequiresRootPrivilegeOnUnixTest> ("UsePing", 1);
 		}
 
-		[Test]
-		public void TestCreateObject ()
+		public void CreateObject ()
 		{
-			MethodDefinition method = GetTest ("CreateObject"); //calls new object()
-			Assert.AreEqual (RuleResult.Success, runner.CheckMethod (method));
+			new object ();
 		}
 
 		[Test]
-		public void TestUsePing ()
+		public void TestCreate ()
 		{
-			// use an already created Ping instance
-			MethodDefinition method = GetTest ("UsePing");
-			Assert.AreEqual (RuleResult.Failure, runner.CheckMethod (method));
+			AssertRuleSuccess<FeatureRequiresRootPrivilegeOnUnixTest> ("CreateObject");
 		}
 	}
 }