namespace MonoTests.System.Security {
[TestFixture]
- public class NamedPermissionSetTest : Assertion {
+ public class NamedPermissionSetTest {
private static string name = "mono";
private static string sentinel = "go mono!";
public void ConstructorNameEmpty ()
{
NamedPermissionSet nps = new NamedPermissionSet ("");
- }\r
-\r
- [Test]\r
- public void ConstructorName ()\r
- {\r
- NamedPermissionSet nps = new NamedPermissionSet ("name");\r
- AssertEquals ("Name", "name", nps.Name);\r
- AssertNull ("Description", nps.Description);\r
- Assert ("IsUnrestricted", nps.IsUnrestricted ());\r
- Assert ("IsEmpty", !nps.IsEmpty ());\r
- Assert ("IsReadOnly", !nps.IsReadOnly);\r
- Assert ("IsSynchronized", !nps.IsSynchronized);\r
- AssertEquals ("Count", 0, nps.Count);\r
- }\r
-\r
- [Test]\r
- public void ConstructorNameReserved ()\r
- {\r
- NamedPermissionSet nps = new NamedPermissionSet ("FullTrust");\r
- AssertEquals ("Name", "FullTrust", nps.Name);\r
- AssertNull ("Description", nps.Description);\r
- Assert ("IsUnrestricted", nps.IsUnrestricted ());\r
- Assert ("IsEmpty", !nps.IsEmpty ());\r
- Assert ("IsReadOnly", !nps.IsReadOnly);\r
- Assert ("IsSynchronized", !nps.IsSynchronized);\r
- AssertEquals ("Count", 0, nps.Count);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (NullReferenceException))]\r
- public void ConstructorNamedPermissionSetNull ()\r
- {\r
- NamedPermissionSet nullps = null;\r
- NamedPermissionSet nps = new NamedPermissionSet (nullps);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void ConstructorNameNullPermissionState ()\r
- {\r
- new NamedPermissionSet (null, PermissionState.None);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void ConstructorNameEmptyPermissionState ()\r
- {\r
- new NamedPermissionSet (String.Empty, PermissionState.None);\r
- }
-\r
- [Test]\r
- public void ConstructorNamePermissionStateNone ()\r
- {\r
- NamedPermissionSet nps = new NamedPermissionSet ("name", PermissionState.None);\r
- AssertEquals ("Name", "name", nps.Name);\r
- AssertNull ("Description", nps.Description);\r
- Assert ("IsUnrestricted", !nps.IsUnrestricted ());\r
- Assert ("IsEmpty", nps.IsEmpty ());\r
- Assert ("IsReadOnly", !nps.IsReadOnly);\r
- Assert ("IsSynchronized", !nps.IsSynchronized);\r
- AssertEquals ("Count", 0, nps.Count);\r
- }\r
-\r
- [Test]\r
- public void ConstructorNamePermissionStateUnrestricted ()\r
- {\r
- NamedPermissionSet nps = new NamedPermissionSet ("name", PermissionState.Unrestricted);\r
- AssertEquals ("Name", "name", nps.Name);\r
- AssertNull ("Description", nps.Description);\r
- Assert ("IsUnrestricted", nps.IsUnrestricted ());\r
- Assert ("IsEmpty", !nps.IsEmpty ());\r
- Assert ("IsReadOnly", !nps.IsReadOnly);\r
- Assert ("IsSynchronized", !nps.IsSynchronized);\r
- AssertEquals ("Count", 0, nps.Count);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void ConstructorNameNullPermissionSet ()\r
- {\r
- new NamedPermissionSet (null, new PermissionSet (PermissionState.None));\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void ConstructorNameEmptyPermissionSet ()\r
- {\r
- new NamedPermissionSet (String.Empty, new PermissionSet (PermissionState.None));\r
- }
-\r
- [Test]\r
- public void ConstructorNamePermissionSetNull ()\r
- {\r
- NamedPermissionSet nps = new NamedPermissionSet ("name", null);\r
- AssertEquals ("Name", "name", nps.Name);\r
- AssertNull ("Description", nps.Description);\r
-#if NET_2_0\r
- Assert ("IsUnrestricted", !nps.IsUnrestricted ());\r
- Assert ("IsEmpty", nps.IsEmpty ());\r
-#else\r
- Assert ("IsUnrestricted", nps.IsUnrestricted ());\r
- Assert ("IsEmpty", !nps.IsEmpty ());\r
-#endif\r
- Assert ("IsReadOnly", !nps.IsReadOnly);\r
- Assert ("IsSynchronized", !nps.IsSynchronized);\r
- AssertEquals ("Count", 0, nps.Count);\r
- }\r
-\r
+ }
+
+ [Test]
+ public void ConstructorName ()
+ {
+ NamedPermissionSet nps = new NamedPermissionSet ("name");
+ Assert.AreEqual ("name", nps.Name, "Name");
+ Assert.IsNull (nps.Description, "Description");
+ Assert.IsTrue (nps.IsUnrestricted (), "IsUnrestricted");
+ Assert.IsTrue (!nps.IsEmpty (), "IsEmpty");
+ Assert.IsTrue (!nps.IsReadOnly, "IsReadOnly");
+ Assert.IsTrue (!nps.IsSynchronized, "IsSynchronized");
+ Assert.AreEqual (0, nps.Count, "Count");
+ }
+
+ [Test]
+ public void ConstructorNameReserved ()
+ {
+ NamedPermissionSet nps = new NamedPermissionSet ("FullTrust");
+ Assert.AreEqual ("FullTrust", nps.Name, "Name");
+ Assert.IsNull (nps.Description, "Description");
+ Assert.IsTrue (nps.IsUnrestricted (), "IsUnrestricted");
+ Assert.IsTrue (!nps.IsEmpty (), "IsEmpty");
+ Assert.IsTrue (!nps.IsReadOnly, "IsReadOnly");
+ Assert.IsTrue (!nps.IsSynchronized, "IsSynchronized");
+ Assert.AreEqual (0, nps.Count, "Count");
+ }
+
+ [Test]
+ [ExpectedException (typeof (NullReferenceException))]
+ public void ConstructorNamedPermissionSetNull ()
+ {
+ NamedPermissionSet nullps = null;
+ NamedPermissionSet nps = new NamedPermissionSet (nullps);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void ConstructorNameNullPermissionState ()
+ {
+ new NamedPermissionSet (null, PermissionState.None);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void ConstructorNameEmptyPermissionState ()
+ {
+ new NamedPermissionSet (String.Empty, PermissionState.None);
+ }
+
+ [Test]
+ public void ConstructorNamePermissionStateNone ()
+ {
+ NamedPermissionSet nps = new NamedPermissionSet ("name", PermissionState.None);
+ Assert.AreEqual ("name", nps.Name, "Name");
+ Assert.IsNull (nps.Description, "Description");
+ Assert.IsTrue (!nps.IsUnrestricted (), "IsUnrestricted");
+ Assert.IsTrue (nps.IsEmpty (), "IsEmpty");
+ Assert.IsTrue (!nps.IsReadOnly, "IsReadOnly");
+ Assert.IsTrue (!nps.IsSynchronized, "IsSynchronized");
+ Assert.AreEqual (0, nps.Count, "Count");
+ }
+
+ [Test]
+ public void ConstructorNamePermissionStateUnrestricted ()
+ {
+ NamedPermissionSet nps = new NamedPermissionSet ("name", PermissionState.Unrestricted);
+ Assert.AreEqual ("name", nps.Name, "Name");
+ Assert.IsNull (nps.Description, "Description");
+ Assert.IsTrue (nps.IsUnrestricted (), "IsUnrestricted");
+ Assert.IsTrue (!nps.IsEmpty (), "IsEmpty");
+ Assert.IsTrue (!nps.IsReadOnly, "IsReadOnly");
+ Assert.IsTrue (!nps.IsSynchronized, "IsSynchronized");
+ Assert.AreEqual (0, nps.Count, "Count");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void ConstructorNameNullPermissionSet ()
+ {
+ new NamedPermissionSet (null, new PermissionSet (PermissionState.None));
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void ConstructorNameEmptyPermissionSet ()
+ {
+ new NamedPermissionSet (String.Empty, new PermissionSet (PermissionState.None));
+ }
+
+ [Test]
+ public void ConstructorNamePermissionSetNull ()
+ {
+ NamedPermissionSet nps = new NamedPermissionSet ("name", null);
+ Assert.AreEqual ("name", nps.Name, "Name");
+ Assert.IsNull (nps.Description, "Description");
+#if NET_2_0
+ Assert.IsTrue (!nps.IsUnrestricted (), "IsUnrestricted");
+ Assert.IsTrue (nps.IsEmpty (), "IsEmpty");
+#else
+ Assert.IsTrue (nps.IsUnrestricted (), "IsUnrestricted");
+ Assert.IsTrue (!nps.IsEmpty (), "IsEmpty");
+#endif
+ Assert.IsTrue (!nps.IsReadOnly, "IsReadOnly");
+ Assert.IsTrue (!nps.IsSynchronized, "IsSynchronized");
+ Assert.AreEqual (0, nps.Count, "Count");
+ }
+
[Test]
public void Description ()
{
NamedPermissionSet nps = new NamedPermissionSet (name);
// null by default (not empty)
- AssertNull ("Description", nps.Description);
+ Assert.IsNull (nps.Description, "Description");
// is null-able (without exception)
nps.Description = null;
- AssertNull ("Description(null)", nps.Description);
+ Assert.IsNull (nps.Description, "Description(null)");
nps.Description = sentinel;
- AssertEquals ("Description", sentinel, nps.Description);
+ Assert.AreEqual (sentinel, nps.Description, "Description");
}
[Test]
{
NamedPermissionSet nps = new NamedPermissionSet (name);
nps.Name = sentinel;
- AssertEquals ("Name", sentinel, nps.Name);
+ Assert.AreEqual (sentinel, nps.Name, "Name");
}
[Test]
nps.Description = sentinel;
nps.AddPermission (new SecurityPermission (SecurityPermissionFlag.Assertion));
NamedPermissionSet copy = (NamedPermissionSet)nps.Copy ();
- AssertEquals ("Name", nps.Name, copy.Name);
- AssertEquals ("Description", nps.Description, copy.Description);
- AssertEquals ("Count", nps.Count, copy.Count);
+ Assert.AreEqual (nps.Name, copy.Name, "Name");
+ Assert.AreEqual (nps.Description, copy.Description, "Description");
+ Assert.AreEqual (nps.Count, copy.Count, "Count");
}
[Test]
nps.Description = sentinel;
nps.AddPermission (new SecurityPermission (SecurityPermissionFlag.Assertion));
NamedPermissionSet copy = (NamedPermissionSet)nps.Copy ("Copy");
- AssertEquals ("Name", "Copy", copy.Name);
- AssertEquals ("Description", nps.Description, copy.Description);
- AssertEquals ("Count", nps.Count, copy.Count);
+ Assert.AreEqual ("Copy", copy.Name, "Name");
+ Assert.AreEqual (nps.Description, copy.Description, "Description");
+ Assert.AreEqual (nps.Count, copy.Count, "Count");
}
[Test]
nps.FromXml (w);
// having a null name can badly influence the rest of the class code
- AssertNull ("Name", nps.Name);
+ Assert.IsNull (nps.Name, "Name");
NamedPermissionSet copy = (NamedPermissionSet) nps.Copy ();
- AssertNull ("Copy.Name", copy.Name);
+ Assert.IsNull (copy.Name, "Copy.Name");
copy = nps.Copy ("name");
- AssertEquals ("Copy(Name).Name", "name", copy.Name);
+ Assert.AreEqual ("name", copy.Name, "Copy(Name).Name");
se = nps.ToXml ();
- AssertNull ("Name attribute", se.Attribute ("Name"));
+ Assert.IsNull (se.Attribute ("Name"), "Name attribute");
#if NET_2_0
- AssertEquals ("GetHashCode", 0, nps.GetHashCode ());
- Assert ("Equals-self", nps.Equals (nps));
+ Assert.AreEqual (0, nps.GetHashCode (), "GetHashCode");
+ Assert.IsTrue (nps.Equals (nps), "Equals-self");
#endif
}
{
NamedPermissionSet nps = new NamedPermissionSet (name, PermissionState.None);
SecurityElement se = nps.ToXml ();
- AssertNotNull ("ToXml()", se);
+ Assert.IsNotNull (se, "ToXml()");
NamedPermissionSet nps2 = (NamedPermissionSet) nps.Copy ();
nps2.FromXml (se);
- AssertEquals ("FromXml-Copy.Name", name, nps2.Name);
+ Assert.AreEqual (name, nps2.Name, "FromXml-Copy.Name");
// strangely it's empty when converted from XML (but null when created)
- AssertEquals ("FromXml-Copy.Description", "", nps2.Description);
- Assert ("FromXml-Copy.IsUnrestricted", !nps2.IsUnrestricted ());
+ Assert.AreEqual ("", nps2.Description, "FromXml-Copy.Description");
+ Assert.IsTrue (!nps2.IsUnrestricted () , "FromXml-Copy.IsUnrestricted");
se.AddAttribute ("Description", sentinel);
nps2.FromXml (se);
- AssertEquals ("FromXml-Add1.Name", name, nps2.Name);
- AssertEquals ("FromXml-Add1.Description", sentinel, nps2.Description);
- Assert ("FromXml-Add1.IsUnrestricted", !nps2.IsUnrestricted ());
+ Assert.AreEqual (name, nps2.Name, "FromXml-Add1.Name");
+ Assert.AreEqual (sentinel, nps2.Description, "FromXml-Add1.Description");
+ Assert.IsTrue (!nps2.IsUnrestricted () , "FromXml-Add1.IsUnrestricted");
se.AddAttribute ("Unrestricted", "true");
nps2.FromXml (se);
- AssertEquals ("FromXml-Add2.Name", name, nps2.Name);
- AssertEquals ("FromXml-Add2.Description", sentinel, nps2.Description);
- Assert ("FromXml-Add2.IsUnrestricted", nps2.IsUnrestricted ());
+ Assert.AreEqual (name, nps2.Name, "FromXml-Add2.Name");
+ Assert.AreEqual (sentinel, nps2.Description, "FromXml-Add2.Description");
+ Assert.IsTrue (nps2.IsUnrestricted () , "FromXml-Add2.IsUnrestricted");
}
[Test]
NamedPermissionSet ps = new NamedPermissionSet (name, PermissionState.None);
ps.Description = sentinel;
SecurityElement se = ps.ToXml ();
- Assert ("None.ToString().StartsWith", ps.ToString().StartsWith ("<PermissionSet"));
- AssertEquals ("None.class", "System.Security.NamedPermissionSet", (se.Attributes ["class"] as string));
- AssertEquals ("None.version", "1", (se.Attributes ["version"] as string));
- AssertEquals ("None.Name", name, (se.Attributes ["Name"] as string));
- AssertEquals ("None.Description", sentinel, (se.Attributes ["Description"] as string));
- AssertNull ("None.Unrestricted", (se.Attributes ["Unrestricted"] as string));
+ Assert.IsTrue (ps.ToString().StartsWith ("<PermissionSet"), "None.ToString().StartsWith");
+ Assert.AreEqual ("System.Security.NamedPermissionSet", (se.Attributes ["class"] as string), "None.class");
+ Assert.AreEqual ("1", (se.Attributes ["version"] as string), "None.version");
+ Assert.AreEqual (name, (se.Attributes ["Name"] as string), "None.Name");
+ Assert.AreEqual (sentinel, (se.Attributes ["Description"] as string), "None.Description");
+ Assert.IsNull ((se.Attributes ["Unrestricted"] as string), "None.Unrestricted");
}
[Test]
{
NamedPermissionSet ps = new NamedPermissionSet (name, PermissionState.Unrestricted);
SecurityElement se = ps.ToXml ();
- Assert ("Unrestricted.ToString().StartsWith", ps.ToString().StartsWith ("<PermissionSet"));
- AssertEquals ("Unrestricted.class", "System.Security.NamedPermissionSet", (se.Attributes ["class"] as string));
- AssertEquals ("Unrestricted.version", "1", (se.Attributes ["version"] as string));
- AssertEquals ("Unrestricted.Name", name, (se.Attributes ["Name"] as string));
- AssertNull ("Unrestricted.Description", (se.Attributes ["Description"] as string));
- AssertEquals ("Unrestricted.Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
+ Assert.IsTrue (ps.ToString().StartsWith ("<PermissionSet"), "Unrestricted.ToString().StartsWith");
+ Assert.AreEqual ("System.Security.NamedPermissionSet", (se.Attributes ["class"] as string), "Unrestricted.class");
+ Assert.AreEqual ("1", (se.Attributes ["version"] as string), "Unrestricted.version");
+ Assert.AreEqual (name, (se.Attributes ["Name"] as string), "Unrestricted.Name");
+ Assert.IsNull ((se.Attributes ["Description"] as string), "Unrestricted.Description");
+ Assert.AreEqual ("true", (se.Attributes ["Unrestricted"] as string), "Unrestricted.Unrestricted");
}
#if NET_2_0
[Test]
{
NamedPermissionSet psn = new NamedPermissionSet (name, PermissionState.None);
NamedPermissionSet psu = new NamedPermissionSet (name, PermissionState.Unrestricted);
- Assert ("psn!=psu", !psn.Equals (psu));
- Assert ("psu!=psn", !psu.Equals (psn));
+ Assert.IsTrue (!psn.Equals (psu), "psn!=psu");
+ Assert.IsTrue (!psu.Equals (psn), "psu!=psn");
NamedPermissionSet cpsn = (NamedPermissionSet) psn.Copy ();
- Assert ("cpsn==psn", cpsn.Equals (psn));
- Assert ("psn==cpsn", psn.Equals (cpsn));
+ Assert.IsTrue (cpsn.Equals (psn), "cpsn==psn");
+ Assert.IsTrue (psn.Equals (cpsn), "psn==cpsn");
NamedPermissionSet cpsu = (NamedPermissionSet) psu.Copy ();
- Assert ("cpsu==psu", cpsu.Equals (psu));
- Assert ("psu==cpsu", psu.Equals (cpsu));
+ Assert.IsTrue (cpsu.Equals (psu), "cpsu==psu");
+ Assert.IsTrue (psu.Equals (cpsu), "psu==cpsu");
cpsn.Description = sentinel;
- Assert ("cpsn+desc==psn", cpsn.Equals (psn));
- Assert ("psn==cpsn+desc", psn.Equals (cpsn));
+ Assert.IsTrue (cpsn.Equals (psn), "cpsn+desc==psn");
+ Assert.IsTrue (psn.Equals (cpsn), "psn==cpsn+desc");
cpsn.Description = sentinel;
- Assert ("cpsu+desc==psu", cpsu.Equals (psu));
- Assert ("psu==cpsu+desc", psu.Equals (cpsu));
+ Assert.IsTrue (cpsu.Equals (psu), "cpsu+desc==psu");
+ Assert.IsTrue (psu.Equals (cpsu), "psu==cpsu+desc");
}
[Test]
int nhc = psn.GetHashCode ();
NamedPermissionSet psu = new NamedPermissionSet (name, PermissionState.Unrestricted);
int uhc = psu.GetHashCode ();
- Assert ("GetHashCode-1", nhc != uhc);
+ Assert.IsTrue (nhc != uhc, "GetHashCode-1");
psn.Description = sentinel;
- Assert ("GetHashCode-2", psn.GetHashCode () == nhc);
+ Assert.IsTrue (psn.GetHashCode () == nhc, "GetHashCode-2");
psu.Description = sentinel;
- Assert ("GetHashCode-3", psu.GetHashCode () == uhc);
+ Assert.IsTrue (psu.GetHashCode () == uhc, "GetHashCode-3");
}
#endif
}
namespace MonoTests.System.Security {
[TestFixture]
- public class PermissionSetTest : Assertion {
+ public class PermissionSetTest {
[Test]
public void PermissionStateNone ()
{
PermissionSet ps = new PermissionSet (PermissionState.None);
- Assert ("PermissionStateNone.IsUnrestricted", !ps.IsUnrestricted ());
- Assert ("PermissionStateNone.IsEmpty", ps.IsEmpty ());
- Assert ("PermissionStateNone.IsReadOnly", !ps.IsReadOnly);
- AssertEquals ("PermissionStateNone.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());\r
- Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());
+ Assert.IsTrue (!ps.IsUnrestricted (), "PermissionStateNone.IsUnrestricted");
+ Assert.IsTrue (ps.IsEmpty (), "PermissionStateNone.IsEmpty");
+ Assert.IsTrue (!ps.IsReadOnly, "PermissionStateNone.IsReadOnly");
+ Assert.AreEqual (ps.ToXml ().ToString (), ps.ToString (), "PermissionStateNone.ToXml().ToString()==ToString()");
+ Assert.IsTrue (!ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
}
[Test]
public void PermissionStateUnrestricted ()
{
PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
- Assert ("PermissionStateUnrestricted.IsUnrestricted", ps.IsUnrestricted ());
- Assert ("PermissionStateUnrestricted.IsEmpty", !ps.IsEmpty ());
- Assert ("PermissionStateUnrestricted.IsReadOnly", !ps.IsReadOnly);
- AssertEquals ("PermissionStateUnrestricted.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());\r
- Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
+ Assert.IsTrue (ps.IsUnrestricted (), "PermissionStateUnrestricted.IsUnrestricted");
+ Assert.IsTrue (!ps.IsEmpty (), "PermissionStateUnrestricted.IsEmpty");
+ Assert.IsTrue (!ps.IsReadOnly, "PermissionStateUnrestricted.IsReadOnly");
+ Assert.AreEqual (ps.ToXml ().ToString (), ps.ToString (), "PermissionStateUnrestricted.ToXml().ToString()==ToString()");
+ Assert.IsTrue (!ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
}
[Test]
// no exception is thrown
PermissionSet ps = new PermissionSet (null);
#if NET_2_0
- Assert ("PermissionStateNull.IsUnrestricted", !ps.IsUnrestricted ());
- Assert ("PermissionStateNull.IsEmpty", ps.IsEmpty ());
+ Assert.IsTrue (!ps.IsUnrestricted (), "PermissionStateNull.IsUnrestricted");
+ Assert.IsTrue (ps.IsEmpty (), "PermissionStateNull.IsEmpty");
#else
- Assert ("PermissionStateNull.IsUnrestricted", ps.IsUnrestricted ());
- Assert ("PermissionStateNull.IsEmpty", !ps.IsEmpty ());
+ Assert.IsTrue (ps.IsUnrestricted (), "PermissionStateNull.IsUnrestricted");
+ Assert.IsTrue (!ps.IsEmpty (), "PermissionStateNull.IsEmpty");
#endif
- Assert ("PermissionStateNull.IsReadOnly", !ps.IsReadOnly);
- AssertEquals ("PermissionStateNull.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());\r
- Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
+ Assert.IsTrue (!ps.IsReadOnly, "PermissionStateNull.IsReadOnly");
+ Assert.AreEqual (ps.ToXml ().ToString (), ps.ToString (), "PermissionStateNull.ToXml().ToString()==ToString()");
+ Assert.IsTrue (!ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
}
[Test]
FileDialogPermission fdp = new FileDialogPermission (FileDialogPermissionAccess.Open);
PermissionSet ps1 = new PermissionSet (PermissionState.None);
ps1.AddPermission (fdp);
- Assert ("ps1.IsEmpty", !ps1.IsEmpty ());
+ Assert.IsTrue (!ps1.IsEmpty (), "ps1.IsEmpty");
PermissionSet ps = new PermissionSet (ps1);
- Assert ("PermissionSetPermissionSet.IsUnrestricted", !ps.IsUnrestricted ());
- Assert ("PermissionSetPermissionSet.IsEmpty", !ps.IsEmpty ());
- Assert ("PermissionSetPermissionSet.IsReadOnly", !ps.IsReadOnly);
- AssertEquals ("PermissionSetPermissionSet.ToXml().ToString()==ToString()", ps.ToXml ().ToString (), ps.ToString ());\r
- Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
+ Assert.IsTrue (!ps.IsUnrestricted (), "PermissionSetPermissionSet.IsUnrestricted");
+ Assert.IsTrue (!ps.IsEmpty (), "PermissionSetPermissionSet.IsEmpty");
+ Assert.IsTrue (!ps.IsReadOnly, "PermissionSetPermissionSet.IsReadOnly");
+ Assert.AreEqual (ps.ToXml ().ToString (), ps.ToString (), "PermissionSetPermissionSet.ToXml().ToString()==ToString()");
+ Assert.IsTrue (!ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
}
[Test]
{
NamedPermissionSet nps = new NamedPermissionSet ("Test", PermissionState.Unrestricted);
PermissionSet ps = new PermissionSet (nps);
- Assert ("IsUnrestricted", ps.IsUnrestricted ());\r
- Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
+ Assert.IsTrue (ps.IsUnrestricted (), "IsUnrestricted");
+ Assert.IsTrue (!ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
}
[Test]
SecurityPermission sp2 = new SecurityPermission (SecurityPermissionFlag.ControlPolicy);
PermissionSet ps = new PermissionSet (PermissionState.None);
SecurityPermission result = (SecurityPermission)ps.AddPermission (sp1);
- AssertEquals ("1-ControlEvidence", 1, ps.Count);
- AssertEquals ("Flags-1", SecurityPermissionFlag.ControlEvidence, result.Flags);
+ Assert.AreEqual (1, ps.Count, "1-ControlEvidence");
+ Assert.AreEqual (SecurityPermissionFlag.ControlEvidence, result.Flags, "Flags-1");
result = (SecurityPermission)ps.AddPermission (sp2);
- AssertEquals ("1-ControlEvidence+ControlPolicy", 1, ps.Count);
- AssertEquals ("Flags-2", SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags);
+ Assert.AreEqual (1, ps.Count, "1-ControlEvidence+ControlPolicy");
+ Assert.AreEqual (SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags, "Flags-2");
result = (SecurityPermission)ps.AddPermission (sp2);
- AssertEquals ("no change-1", 1, ps.Count);
- AssertEquals ("Flags-3", SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags);
+ Assert.AreEqual (1, ps.Count, "no change-1");
+ Assert.AreEqual (SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags, "Flags-3");
result = (SecurityPermission)ps.AddPermission (sp1);
- AssertEquals ("no change-2", 1, ps.Count);
- AssertEquals ("Flags-4", SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags);
+ Assert.AreEqual (1, ps.Count, "no change-2");
+ Assert.AreEqual (SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence, result.Flags, "Flags-4");
}
[Test]
{
PermissionSet ps = new PermissionSet (PermissionState.None);
IPermission result = ps.AddPermission (null);
- AssertNull ("Add(null)", result);
- AssertEquals ("0", 0, ps.Count);
+ Assert.IsNull (result, "Add(null)");
+ Assert.AreEqual (0, ps.Count, "0");
}
[Test]
PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
IPermission result = ps.AddPermission (sp);
- AssertNotNull ("Add(SecurityPermission)", result);
- AssertEquals ("SecurityPermission", SecurityPermissionFlag.AllFlags, (result as SecurityPermission).Flags);
- AssertEquals ("0", 0, ps.Count);
+ Assert.IsNotNull (result, "Add(SecurityPermission)");
+ Assert.AreEqual (SecurityPermissionFlag.AllFlags, (result as SecurityPermission).Flags, "SecurityPermission");
+ Assert.AreEqual (0, ps.Count, "0");
ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
result = ps.AddPermission (zip);
- AssertNotNull ("Add(ZoneIdentityPermission)", result);
+ Assert.IsNotNull (result, "Add(ZoneIdentityPermission)");
#if NET_2_0
// Identity permissions aren't added to unrestricted permission sets in 2.0
- AssertEquals ("ZoneIdentityPermission", SecurityZone.NoZone, (result as ZoneIdentityPermission).SecurityZone);
- AssertEquals ("1", 0, ps.Count);
+ Assert.AreEqual (SecurityZone.NoZone, (result as ZoneIdentityPermission).SecurityZone, "ZoneIdentityPermission");
+ Assert.AreEqual (0, ps.Count, "1");
#else
- AssertEquals ("ZoneIdentityPermission", zip.SecurityZone, (result as ZoneIdentityPermission).SecurityZone);
- AssertEquals ("1", 1, ps.Count);
+ Assert.AreEqual (zip.SecurityZone, (result as ZoneIdentityPermission).SecurityZone, "ZoneIdentityPermission");
+ Assert.AreEqual (1, ps.Count, "1");
#endif
}
PermissionSet ps = new PermissionSet (PermissionState.None);
SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
IPermission result = ps.AddPermission (sp);
- AssertNotNull ("Add(SecurityPermission)", result);
- AssertEquals ("SecurityPermission", SecurityPermissionFlag.AllFlags, (result as SecurityPermission).Flags);
- AssertEquals ("1", 1, ps.Count);
- Assert ("State", !ps.IsUnrestricted ());
- }\r
-\r
- [Test]\r
- public void AddPermission_NonCasPermission ()\r
- {\r
- PermissionSet ps = new PermissionSet (PermissionState.None);\r
- ps.AddPermission (new PrincipalPermission ("name", "role"));\r
- AssertEquals ("Count", 1, ps.Count);\r
- Assert ("IsEmpty", !ps.IsEmpty ());\r
- }\r
-\r
- [Test]\r
- public void AddPermission_NonCasPermissionNone ()\r
- {\r
- PermissionSet ps = new PermissionSet (PermissionState.None);\r
- ps.AddPermission (new PrincipalPermission (PermissionState.None));\r
- AssertEquals ("Count", 1, ps.Count);\r
- Assert ("IsEmpty", ps.IsEmpty ());\r
- }\r
-\r
- [Test]\r
- public void AddPermission_NonCasPermissionUnrestricted ()\r
- {\r
- PermissionSet ps = new PermissionSet (PermissionState.None);\r
- ps.AddPermission (new PrincipalPermission (PermissionState.Unrestricted));\r
- AssertEquals ("Count", 1, ps.Count);\r
- Assert ("IsEmpty", !ps.IsEmpty ());\r
- }\r
-\r
- [Test]\r
- public void AddPermission_NonCasPermission_Unrestricted ()\r
- {\r
- PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);\r
- ps.AddPermission (new PrincipalPermission ("name", "role"));\r
- AssertEquals ("Count", 0, ps.Count);\r
- Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
- }\r
-\r
- [Test]\r
- public void AddPermission_NonCasPermissionNone_Unrestricted ()\r
- {\r
- PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);\r
- ps.AddPermission (new PrincipalPermission (PermissionState.None));\r
- AssertEquals ("Count", 0, ps.Count);\r
- Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
- }\r
-\r
- [Test]\r
- public void AddPermission_NonCasPermissionUnrestricted_Unrestricted ()\r
- {\r
- PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);\r
- ps.AddPermission (new PrincipalPermission (PermissionState.Unrestricted));\r
- AssertEquals ("Count", 0, ps.Count);\r
- Assert ("ContainsNonCodeAccessPermissions", !ps.ContainsNonCodeAccessPermissions ());\r
- }\r
+ Assert.IsNotNull (result, "Add(SecurityPermission)");
+ Assert.AreEqual (SecurityPermissionFlag.AllFlags, (result as SecurityPermission).Flags, "SecurityPermission");
+ Assert.AreEqual (1, ps.Count, "1");
+ Assert.IsTrue (!ps.IsUnrestricted (), "State");
+ }
+
+ [Test]
+ public void AddPermission_NonCasPermission ()
+ {
+ PermissionSet ps = new PermissionSet (PermissionState.None);
+ ps.AddPermission (new PrincipalPermission ("name", "role"));
+ Assert.AreEqual (1, ps.Count, "Count");
+ Assert.IsTrue (!ps.IsEmpty (), "IsEmpty");
+ }
+
+ [Test]
+ public void AddPermission_NonCasPermissionNone ()
+ {
+ PermissionSet ps = new PermissionSet (PermissionState.None);
+ ps.AddPermission (new PrincipalPermission (PermissionState.None));
+ Assert.AreEqual (1, ps.Count, "Count");
+ Assert.IsTrue (ps.IsEmpty (), "IsEmpty");
+ }
+
+ [Test]
+ public void AddPermission_NonCasPermissionUnrestricted ()
+ {
+ PermissionSet ps = new PermissionSet (PermissionState.None);
+ ps.AddPermission (new PrincipalPermission (PermissionState.Unrestricted));
+ Assert.AreEqual (1, ps.Count, "Count");
+ Assert.IsTrue (!ps.IsEmpty (), "IsEmpty");
+ }
+
+ [Test]
+ public void AddPermission_NonCasPermission_Unrestricted ()
+ {
+ PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
+ ps.AddPermission (new PrincipalPermission ("name", "role"));
+ Assert.AreEqual (0, ps.Count, "Count");
+ Assert.IsTrue (!ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
+ }
+
+ [Test]
+ public void AddPermission_NonCasPermissionNone_Unrestricted ()
+ {
+ PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
+ ps.AddPermission (new PrincipalPermission (PermissionState.None));
+ Assert.AreEqual (0, ps.Count, "Count");
+ Assert.IsTrue (!ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
+ }
+
+ [Test]
+ public void AddPermission_NonCasPermissionUnrestricted_Unrestricted ()
+ {
+ PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
+ ps.AddPermission (new PrincipalPermission (PermissionState.Unrestricted));
+ Assert.AreEqual (0, ps.Count, "Count");
+ Assert.IsTrue (!ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
+ }
[Test]
public void AddPermission_NoCopy ()
public void ContainsNonCodeAccessPermissions ()
{
PermissionSet ps = new PermissionSet (PermissionState.None);
- Assert ("Empty", !ps.ContainsNonCodeAccessPermissions ());
+ Assert.IsTrue (!ps.ContainsNonCodeAccessPermissions (), "Empty");
SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
ps.AddPermission (sp);
- Assert ("SecurityPermission", !ps.ContainsNonCodeAccessPermissions ());
+ Assert.IsTrue (!ps.ContainsNonCodeAccessPermissions (), "SecurityPermission");
PrincipalPermission pp = new PrincipalPermission ("mono", "hacker");
ps.AddPermission (pp);
- Assert ("PrincipalPermission", ps.ContainsNonCodeAccessPermissions ());
+ Assert.IsTrue (ps.ContainsNonCodeAccessPermissions (), "PrincipalPermission");
}
[Test]
public void ConvertPermissionSet_UnknownIn ()
{
byte[] result = PermissionSet.ConvertPermissionSet (String.Empty, new byte [0], "XML");
- AssertNull (result);
+ Assert.IsNull (result);
}
[Test]
public void ConvertPermissionSet_NullData ()
{
byte[] result = PermissionSet.ConvertPermissionSet ("BINARY", null, "XML");
- AssertNull (result);
+ Assert.IsNull (result);
}
[Test]
byte[] result2 = PermissionSet.ConvertPermissionSet ("BINARY", result, "BINARY");
// there's only a little difference - but it doesn't throw an exception
- //Assert ("BINARY!=BINARY", BitConverter.ToString (result) != BitConverter.ToString (result2));
+ //Assert.IsTrue (BitConverter.ToString (result) != BitConverter.ToString (result2), "BINARY!=BINARY");
}
[Test]
byte[] data = Encoding.ASCII.GetBytes (ps.ToString ());
byte[] result = PermissionSet.ConvertPermissionSet ("XML", data, "BINARY");
byte[] result2 = PermissionSet.ConvertPermissionSet ("XMLASCII", data, "BINARY");
- AssertEquals ("XML==XMLASCII", BitConverter.ToString (result), BitConverter.ToString (result2));
+ Assert.AreEqual (BitConverter.ToString (result), BitConverter.ToString (result2), "XML==XMLASCII");
byte[] back = PermissionSet.ConvertPermissionSet ("BINARY", result, "XML");
- AssertEquals ("PS-XML", Encoding.ASCII.GetString (back), ps.ToString ());
+ Assert.AreEqual (Encoding.ASCII.GetString (back), ps.ToString (), "PS-XML");
back = PermissionSet.ConvertPermissionSet ("BINARY", result2, "XMLASCII");
- AssertEquals ("PS-XMLASCII", Encoding.ASCII.GetString (back), ps.ToString ());
+ Assert.AreEqual (Encoding.ASCII.GetString (back), ps.ToString (), "PS-XMLASCII");
}
[Test]
PermissionSet ps = new PermissionSet (PermissionState.None);
byte[] data = Encoding.ASCII.GetBytes (ps.ToString ());
byte[] result = PermissionSet.ConvertPermissionSet ("XML", data, "XML");
- AssertEquals ("PS-XML", Encoding.ASCII.GetString (result), ps.ToString ());
+ Assert.AreEqual (Encoding.ASCII.GetString (result), ps.ToString (), "PS-XML");
result = PermissionSet.ConvertPermissionSet ("XMLASCII", data, "XMLASCII");
- AssertEquals ("PS-XMLASCII", Encoding.ASCII.GetString (result), ps.ToString ());
+ Assert.AreEqual (Encoding.ASCII.GetString (result), ps.ToString (), "PS-XMLASCII");
}
[Test]
{
PermissionSet ps = new PermissionSet (PermissionState.None);
PermissionSet copy = ps.Copy ();
- Assert ("1.State", !copy.IsUnrestricted ());
- AssertEquals ("1.Count", 0, copy.Count);
+ Assert.IsTrue (!copy.IsUnrestricted (), "1.State");
+ Assert.AreEqual (0, copy.Count, "1.Count");
SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
IPermission result = ps.AddPermission (sp);
- AssertNotNull ("1.Add", result);
+ Assert.IsNotNull (result, "1.Add");
copy = ps.Copy ();
- Assert ("2.State", !copy.IsUnrestricted ());
- AssertEquals ("2.Count", 1, copy.Count);
+ Assert.IsTrue (!copy.IsUnrestricted (), "2.State");
+ Assert.AreEqual (1, copy.Count, "2.Count");
ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
result = ps.AddPermission (zip);
- AssertNotNull ("2.Add", result);
+ Assert.IsNotNull (result, "2.Add");
copy = ps.Copy ();
- Assert ("3.State", !copy.IsUnrestricted ());
- AssertEquals ("3.Count", 2, copy.Count);
+ Assert.IsTrue (!copy.IsUnrestricted (), "3.State");
+ Assert.AreEqual (2, copy.Count, "3.Count");
}
[Test]
{
PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
PermissionSet copy = ps.Copy ();
- Assert ("1.State", copy.IsUnrestricted ());
- AssertEquals ("1.Count", 0, copy.Count);
+ Assert.IsTrue (copy.IsUnrestricted (), "1.State");
+ Assert.AreEqual (0, copy.Count, "1.Count");
SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.ControlEvidence);
IPermission result = ps.AddPermission (sp);
- AssertNotNull ("1.Add", result);
+ Assert.IsNotNull (result, "1.Add");
copy = ps.Copy ();
- Assert ("2.State", copy.IsUnrestricted ());
- AssertEquals ("2.Count", 0, copy.Count);
+ Assert.IsTrue (copy.IsUnrestricted (), "2.State");
+ Assert.AreEqual (0, copy.Count, "2.Count");
ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
result = ps.AddPermission (zip);
- AssertNotNull ("2.Add", result);
+ Assert.IsNotNull (result, "2.Add");
copy = ps.Copy ();
- Assert ("3.State", copy.IsUnrestricted ());
+ Assert.IsTrue (copy.IsUnrestricted (), "3.State");
#if NET_2_0
// Identity permissions aren't added to unrestricted permission sets in 2.0
- AssertEquals ("3.Count", 0, copy.Count);
+ Assert.AreEqual (0, copy.Count, "3.Count");
#else
- AssertEquals ("3.Count", 1, copy.Count);
+ Assert.AreEqual (1, copy.Count, "3.Count");
#endif
}
PermissionSet ps = new PermissionSet (PermissionState.None);
ps.AddPermission (sp);
ps.CopyTo (pa, 0);
- AssertEquals ("CopyTo", pa [0].ToString (), sp.ToString ());
- Assert ("Reference", Object.ReferenceEquals (pa [0], sp));
+ Assert.AreEqual (pa [0].ToString (), sp.ToString (), "CopyTo");
+ Assert.IsTrue (Object.ReferenceEquals (pa [0], sp), "Reference");
}
[Test]
{
PermissionSet ps = new PermissionSet (PermissionState.None);
SecurityElement se = ps.ToXml ();
- AssertNotNull ("Empty.ToXml()", se);
- AssertEquals ("Empty.Count", 0, ps.Count);
+ Assert.IsNotNull (se, "Empty.ToXml()");
+ Assert.AreEqual (0, ps.Count, "Empty.Count");
PermissionSet ps2 = (PermissionSet) ps.Copy ();
ps2.FromXml (se);
- Assert ("FromXml-Copy.IsUnrestricted", !ps2.IsUnrestricted ());
+ Assert.IsTrue (!ps2.IsUnrestricted () , "FromXml-Copy.IsUnrestricted");
se.AddAttribute ("Unrestricted", "true");
ps2.FromXml (se);
- Assert ("FromXml-Unrestricted.IsUnrestricted", ps2.IsUnrestricted ());
+ Assert.IsTrue (ps2.IsUnrestricted (), "FromXml-Unrestricted.IsUnrestricted");
}
[Test]
FileDialogPermission fdp = new FileDialogPermission (FileDialogPermissionAccess.Open);
PermissionSet ps1 = new PermissionSet (PermissionState.None);
ps1.AddPermission (fdp);
- Assert ("ps1.IsEmpty", !ps1.IsEmpty ());
+ Assert.IsTrue (!ps1.IsEmpty (), "ps1.IsEmpty");
PermissionSet ps = new PermissionSet (ps1);
SecurityElement se = ps.ToXml ();
- AssertNotNull ("One.ToXml()", se);
- AssertEquals ("One.Count", 1, ps.Count);
+ Assert.IsNotNull (se, "One.ToXml()");
+ Assert.AreEqual (1, ps.Count, "One.Count");
PermissionSet ps2 = (PermissionSet) ps.Copy ();
ps2.FromXml (se);
- Assert ("FromXml-Copy.IsUnrestricted", !ps2.IsUnrestricted ());
- AssertEquals ("Copy.Count", 1, ps2.Count);
+ Assert.IsTrue (!ps2.IsUnrestricted () , "FromXml-Copy.IsUnrestricted");
+ Assert.AreEqual (1, ps2.Count, "Copy.Count");
se.AddAttribute ("Unrestricted", "true");
ps2.FromXml (se);
- Assert ("FromXml-Unrestricted.IsUnrestricted", ps2.IsUnrestricted ());
+ Assert.IsTrue (ps2.IsUnrestricted (), "FromXml-Unrestricted.IsUnrestricted");
#if NET_2_0
- AssertEquals ("Unrestricted.Count", 0, ps2.Count);
+ Assert.AreEqual (0, ps2.Count, "Unrestricted.Count");
#else
// IPermission not shown in XML but still present in Count
- AssertEquals ("Unrestricted.Count", 1, ps2.Count);
+ Assert.AreEqual (1, ps2.Count, "Unrestricted.Count");
#endif
}
SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
ps.AddPermission (sp);
IEnumerator e = ps.GetEnumerator ();
- AssertNotNull ("GetEnumerator", e);
+ Assert.IsNotNull (e, "GetEnumerator");
int i=0;
while (e.MoveNext ()) {
- Assert ("SecurityPermission", e.Current is SecurityPermission);
+ Assert.IsTrue (e.Current is SecurityPermission, "SecurityPermission");
i++;
}
- AssertEquals ("Count", 1, i);
+ Assert.AreEqual (1, i, "Count");
}
#if NET_2_0
[Test]
public void GetHashCode_ ()
{
PermissionSet ps = new PermissionSet (PermissionState.None);
- AssertEquals ("Empty", 0, ps.GetHashCode ());
+ Assert.AreEqual (0, ps.GetHashCode (), "Empty");
SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
ps.AddPermission (sp);
- Assert ("SecurityPermission", ps.GetHashCode () != 0);
+ Assert.IsTrue (ps.GetHashCode () != 0, "SecurityPermission");
PermissionSet copy = ps.Copy ();
- Assert ("Copy", ps.GetHashCode () != copy.GetHashCode ());
+ Assert.IsTrue (ps.GetHashCode () != copy.GetHashCode (), "Copy");
}
#endif
[Test]
public void GetPermission_Null ()
{
PermissionSet ps = new PermissionSet (PermissionState.None);
- AssertNull ("Empty", ps.GetPermission (null));
+ Assert.IsNull (ps.GetPermission (null), "Empty");
}
[Test]
public void GetPermission_None ()
{
PermissionSet ps = new PermissionSet (PermissionState.None);
- AssertNull ("Empty", ps.GetPermission (typeof (SecurityPermission)));
+ Assert.IsNull (ps.GetPermission (typeof (SecurityPermission)), "Empty");
}
[Test]
public void GetPermission_Unrestricted ()
{
PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
- AssertNull ("Empty", ps.GetPermission (typeof (SecurityPermission)));
+ Assert.IsNull (ps.GetPermission (typeof (SecurityPermission)), "Empty");
}
[Test]
IsolatedStorageFilePermission isfp = new IsolatedStorageFilePermission (PermissionState.Unrestricted);
PermissionSet ps = new PermissionSet (PermissionState.None);
ps.AddPermission (isfp);
- AssertNull ("Subclass", ps.GetPermission (typeof (IsolatedStoragePermission)));
+ Assert.IsNull (ps.GetPermission (typeof (IsolatedStoragePermission)), "Subclass");
}
private void Compare (string msg, PermissionSet ps, bool unrestricted, int count)
{
- AssertNotNull (msg + "-NullCheck", ps);
- Assert (msg + "-State", (ps.IsUnrestricted () == unrestricted));
- AssertEquals (msg + "-Count", count, ps.Count);
+ Assert.IsNotNull (ps, msg + "-NullCheck");
+ Assert.IsTrue ((ps.IsUnrestricted () == unrestricted), msg + "-State");
+ Assert.AreEqual (count, ps.Count, msg + "-Count");
}
[Test]
{
PermissionSet ps1 = new PermissionSet (PermissionState.None);
PermissionSet ps2 = new PermissionSet (PermissionState.None);
- AssertNull ("None N null", ps1.Intersect (null));
- AssertNull ("None1 N None2", ps1.Intersect (ps2));
- AssertNull ("None2 N None1", ps2.Intersect (ps1));
+ Assert.IsNull (ps1.Intersect (null), "None N null");
+ Assert.IsNull (ps1.Intersect (ps2), "None1 N None2");
+ Assert.IsNull (ps2.Intersect (ps1), "None2 N None1");
PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
- AssertNull ("None1 N Unrestricted", ps1.Intersect (ups1));
- AssertNull ("Unrestricted N None1", ups1.Intersect (ps1));
- AssertNull ("Unrestricted N Null", ups1.Intersect (null));
+ Assert.IsNull (ps1.Intersect (ups1), "None1 N Unrestricted");
+ Assert.IsNull (ups1.Intersect (ps1), "Unrestricted N None1");
+ Assert.IsNull (ups1.Intersect (null), "Unrestricted N Null");
PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
Compare ("ups1 N ups2", ups1.Intersect (ups2), true, 0);
PermissionSet ps1 = new PermissionSet (PermissionState.None);
ps1.AddPermission (sp);
PermissionSet ps2 = new PermissionSet (PermissionState.None);
- AssertNull ("PS1 N null", ps1.Intersect (null));
- AssertNull ("PS1 N None", ps1.Intersect (ps2));
- AssertNull ("None N PS1", ps2.Intersect (ps1));
+ Assert.IsNull (ps1.Intersect (null), "PS1 N null");
+ Assert.IsNull (ps1.Intersect (ps2), "PS1 N None");
+ Assert.IsNull (ps2.Intersect (ps1), "None N PS1");
PermissionSet ps3 = ps1.Copy ();
Compare ("PS1 N PS3", ps1.Intersect (ps3), false, 1);
PermissionSet ps1 = new PermissionSet (PermissionState.None);
ps1.AddPermission (zip);
PermissionSet ps2 = new PermissionSet (PermissionState.None);
- AssertNull ("PS1 N null", ps1.Intersect (null));
- AssertNull ("PS1 N None", ps1.Intersect (ps2));
- AssertNull ("None N PS1", ps2.Intersect (ps1));
+ Assert.IsNull (ps1.Intersect (null), "PS1 N null");
+ Assert.IsNull (ps1.Intersect (ps2), "PS1 N None");
+ Assert.IsNull (ps2.Intersect (ps1), "None N PS1");
PermissionSet ps3 = ps1.Copy ();
Compare ("PS1 N PS3", ps1.Intersect (ps3), false, 1);
public void IsEmpty_None ()
{
PermissionSet ps = new PermissionSet (PermissionState.None);
- Assert ("Empty.IsEmpty", ps.IsEmpty ());
+ Assert.IsTrue (ps.IsEmpty (), "Empty.IsEmpty");
ps.AddPermission (new ZoneIdentityPermission (SecurityZone.NoZone));
- AssertEquals ("Count==1", 1, ps.Count);
- Assert ("Zip.IsEmpty", ps.IsEmpty ()); // yes empty!
+ Assert.AreEqual (1, ps.Count, "Count==1");
+ Assert.IsTrue (ps.IsEmpty ()); // yes empty!, "Zip.IsEmpty");
}
[Test]
public void IsEmpty_Unrestricted ()
{
PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
- Assert ("Unrestricted.IsEmpty", !ps.IsEmpty ());
+ Assert.IsTrue (!ps.IsEmpty (), "Unrestricted.IsEmpty");
ps.AddPermission (new ZoneIdentityPermission (SecurityZone.NoZone));
#if NET_2_0
// Identity permissions aren't added to unrestricted permission sets in 2.0
- AssertEquals ("Count==0", 0, ps.Count);
+ Assert.AreEqual (0, ps.Count, "Count==0");
#else
- AssertEquals ("Count==1", 1, ps.Count);
+ Assert.AreEqual (1, ps.Count, "Count==1");
#endif
- Assert ("Zip.IsEmpty", !ps.IsEmpty ()); // yes empty!
+ Assert.IsTrue (!ps.IsEmpty ()); // yes empty!, "Zip.IsEmpty");
}
[Test]
{
PermissionSet ps1 = new PermissionSet (PermissionState.None);
PermissionSet ps2 = new PermissionSet (PermissionState.None);
- Assert ("None.IsSubsetOf(null)", ps1.IsSubsetOf (null));
- Assert ("None1.IsSubsetOf(None2)", ps1.IsSubsetOf (ps2));
- Assert ("None2.IsSubsetOf(None1)", ps2.IsSubsetOf (ps1));
+ Assert.IsTrue (ps1.IsSubsetOf (null), "None.IsSubsetOf(null)");
+ Assert.IsTrue (ps1.IsSubsetOf (ps2), "None1.IsSubsetOf(None2)");
+ Assert.IsTrue (ps2.IsSubsetOf (ps1), "None2.IsSubsetOf(None1)");
PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
- Assert ("None1.IsSubsetOf(Unrestricted)", ps1.IsSubsetOf (ups1));
- Assert ("Unrestricted.IsSubsetOf(None1)", !ups1.IsSubsetOf (ps1));
- Assert ("Unrestricted.IsSubsetOf(Null)", !ups1.IsSubsetOf (null));
+ Assert.IsTrue (ps1.IsSubsetOf (ups1), "None1.IsSubsetOf(Unrestricted)");
+ Assert.IsTrue (!ups1.IsSubsetOf (ps1), "Unrestricted.IsSubsetOf(None1)");
+ Assert.IsTrue (!ups1.IsSubsetOf (null), "Unrestricted.IsSubsetOf(Null)");
PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
- Assert ("ups1IsSubsetOf(ups2)", ups1.IsSubsetOf (ups2));
- Assert ("ups2.IsSubsetOf(ups1)", ups2.IsSubsetOf (ups1));
+ Assert.IsTrue (ups1.IsSubsetOf (ups2), "ups1IsSubsetOf(ups2)");
+ Assert.IsTrue (ups2.IsSubsetOf (ups1), "ups2.IsSubsetOf(ups1)");
}
[Test]
PermissionSet ps1 = new PermissionSet (PermissionState.None);
ps1.AddPermission (sp);
PermissionSet ps2 = new PermissionSet (PermissionState.None);
- Assert ("PS1.IsSubset(null)", !ps1.IsSubsetOf (null));
- Assert ("PS1.IsSubset(None)", !ps1.IsSubsetOf (ps2));
- Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));
+ Assert.IsTrue (!ps1.IsSubsetOf (null), "PS1.IsSubset(null)");
+ Assert.IsTrue (!ps1.IsSubsetOf (ps2), "PS1.IsSubset(None)");
+ Assert.IsTrue (ps2.IsSubsetOf (ps1), "None.IsSubset(PS1)");
PermissionSet ps3 = ps1.Copy ();
- Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));
- Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));
+ Assert.IsTrue (ps1.IsSubsetOf (ps3), "PS1.IsSubset(PS3)");
+ Assert.IsTrue (ps3.IsSubsetOf (ps1), "PS3.IsSubset(PS1)");
PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
- Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));
- Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));
+ Assert.IsTrue (ps1.IsSubsetOf (ups1), "PS1.IsSubset(Unrestricted)");
+ Assert.IsTrue (!ups1.IsSubsetOf (ps1), "Unrestricted.IsSubset(PS1)");
}
[Test]
PermissionSet ps1 = new PermissionSet (PermissionState.None);
ps1.AddPermission (zip);
PermissionSet ps2 = new PermissionSet (PermissionState.None);
- Assert ("PS1.IsSubset(null)", !ps1.IsSubsetOf (null));
- Assert ("PS1.IsSubset(None)", !ps1.IsSubsetOf (ps2));
- Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));
+ Assert.IsTrue (!ps1.IsSubsetOf (null), "PS1.IsSubset(null)");
+ Assert.IsTrue (!ps1.IsSubsetOf (ps2), "PS1.IsSubset(None)");
+ Assert.IsTrue (ps2.IsSubsetOf (ps1), "None.IsSubset(PS1)");
PermissionSet ps3 = ps1.Copy ();
- Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));
- Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));
+ Assert.IsTrue (ps1.IsSubsetOf (ps3), "PS1.IsSubset(PS3)");
+ Assert.IsTrue (ps3.IsSubsetOf (ps1), "PS3.IsSubset(PS1)");
PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
ups1.AddPermission (zip);
- Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));
- Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));
+ Assert.IsTrue (ps1.IsSubsetOf (ups1), "PS1.IsSubset(Unrestricted)");
+ Assert.IsTrue (!ups1.IsSubsetOf (ps1), "Unrestricted.IsSubset(PS1)");
PermissionSet ups2 = new PermissionSet (PermissionState.Unrestricted);
#if NET_2_0
// as ZoneIdentityPermission isn't added UPS1Z == UPS2
- Assert ("UPS1Z.IsSubset(UPS2)", ups1.IsSubsetOf (ups2));
+ Assert.IsTrue (ups1.IsSubsetOf (ups2), "UPS1Z.IsSubset(UPS2)");
#else
- Assert ("UPS1Z.IsSubset(UPS2)", !ups1.IsSubsetOf (ups2));
+ Assert.IsTrue (!ups1.IsSubsetOf (ups2), "UPS1Z.IsSubset(UPS2)");
#endif
- Assert ("UPS2.IsSubset(UPS1Z)", ups2.IsSubsetOf (ups1));
+ Assert.IsTrue (ups2.IsSubsetOf (ups1), "UPS2.IsSubset(UPS1Z)");
ups2.AddPermission (zip);
- Assert ("UPS1Z.IsSubset(UPS2Z)", ups1.IsSubsetOf (ups2));
- Assert ("UPS2Z.IsSubset(UPS1Z)", ups2.IsSubsetOf (ups1));
- }\r
-\r
- [Test]\r
- public void IsSubset_NonCasPermission ()\r
- {\r
- PermissionSet ps1 = new PermissionSet (PermissionState.None);\r
- ps1.AddPermission (new PrincipalPermission ("name", "role"));\r
- PermissionSet ps2 = new PermissionSet (PermissionState.None);\r
- Assert ("PS1.IsSubset(null)", !ps1.IsSubsetOf (null));\r
- Assert ("PS1.IsSubset(None)", !ps1.IsSubsetOf (ps2));\r
- Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));\r
-\r
- PermissionSet ps3 = ps1.Copy ();\r
- Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));\r
- Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));\r
-\r
- PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);\r
-#if NET_2_0\r
- Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));\r
+ Assert.IsTrue (ups1.IsSubsetOf (ups2), "UPS1Z.IsSubset(UPS2Z)");
+ Assert.IsTrue (ups2.IsSubsetOf (ups1), "UPS2Z.IsSubset(UPS1Z)");
+ }
+
+ [Test]
+ public void IsSubset_NonCasPermission ()
+ {
+ PermissionSet ps1 = new PermissionSet (PermissionState.None);
+ ps1.AddPermission (new PrincipalPermission ("name", "role"));
+ PermissionSet ps2 = new PermissionSet (PermissionState.None);
+ Assert.IsTrue (!ps1.IsSubsetOf (null), "PS1.IsSubset(null)");
+ Assert.IsTrue (!ps1.IsSubsetOf (ps2), "PS1.IsSubset(None)");
+ Assert.IsTrue (ps2.IsSubsetOf (ps1), "None.IsSubset(PS1)");
+
+ PermissionSet ps3 = ps1.Copy ();
+ Assert.IsTrue (ps1.IsSubsetOf (ps3), "PS1.IsSubset(PS3)");
+ Assert.IsTrue (ps3.IsSubsetOf (ps1), "PS3.IsSubset(PS1)");
+
+ PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
+#if NET_2_0
+ Assert.IsTrue (ps1.IsSubsetOf (ups1), "PS1.IsSubset(Unrestricted)");
#else
- Assert ("PS1.IsSubset(Unrestricted)", !ps1.IsSubsetOf (ups1));\r
-#endif\r
- Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));\r
- }\r
-\r
- [Test]\r
- public void IsSubset_NonCasPermission_None ()\r
- {\r
- PermissionSet ps1 = new PermissionSet (PermissionState.None);\r
- ps1.AddPermission (new PrincipalPermission (PermissionState.None));\r
- PermissionSet ps2 = new PermissionSet (PermissionState.None);\r
- Assert ("PS1.IsSubset(null)", ps1.IsSubsetOf (null));\r
- Assert ("PS1.IsSubset(None)", ps1.IsSubsetOf (ps2));\r
- Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));\r
-\r
- PermissionSet ps3 = ps1.Copy ();\r
- Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));\r
- Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));\r
-\r
- PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);\r
- Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));\r
- Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));\r
- }
-\r
- [Test]\r
- public void IsSubset_NonCasPermission_Unrestricted ()\r
- {\r
- PermissionSet ps1 = new PermissionSet (PermissionState.None);\r
- ps1.AddPermission (new PrincipalPermission (PermissionState.Unrestricted));\r
- PermissionSet ps2 = new PermissionSet (PermissionState.None);\r
- Assert ("PS1.IsSubset(null)", !ps1.IsSubsetOf (null));\r
- Assert ("PS1.IsSubset(None)", !ps1.IsSubsetOf (ps2));\r
- Assert ("None.IsSubset(PS1)", ps2.IsSubsetOf (ps1));\r
-\r
- PermissionSet ps3 = ps1.Copy ();\r
- Assert ("PS1.IsSubset(PS3)", ps1.IsSubsetOf (ps3));\r
- Assert ("PS3.IsSubset(PS1)", ps3.IsSubsetOf (ps1));\r
-\r
- PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);\r
-#if NET_2_0\r
- Assert ("PS1.IsSubset(Unrestricted)", ps1.IsSubsetOf (ups1));\r
+ Assert.IsTrue (!ps1.IsSubsetOf (ups1), "PS1.IsSubset(Unrestricted)");
+#endif
+ Assert.IsTrue (!ups1.IsSubsetOf (ps1), "Unrestricted.IsSubset(PS1)");
+ }
+
+ [Test]
+ public void IsSubset_NonCasPermission_None ()
+ {
+ PermissionSet ps1 = new PermissionSet (PermissionState.None);
+ ps1.AddPermission (new PrincipalPermission (PermissionState.None));
+ PermissionSet ps2 = new PermissionSet (PermissionState.None);
+ Assert.IsTrue (ps1.IsSubsetOf (null), "PS1.IsSubset(null)");
+ Assert.IsTrue (ps1.IsSubsetOf (ps2), "PS1.IsSubset(None)");
+ Assert.IsTrue (ps2.IsSubsetOf (ps1), "None.IsSubset(PS1)");
+
+ PermissionSet ps3 = ps1.Copy ();
+ Assert.IsTrue (ps1.IsSubsetOf (ps3), "PS1.IsSubset(PS3)");
+ Assert.IsTrue (ps3.IsSubsetOf (ps1), "PS3.IsSubset(PS1)");
+
+ PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
+ Assert.IsTrue (ps1.IsSubsetOf (ups1), "PS1.IsSubset(Unrestricted)");
+ Assert.IsTrue (!ups1.IsSubsetOf (ps1), "Unrestricted.IsSubset(PS1)");
+ }
+
+ [Test]
+ public void IsSubset_NonCasPermission_Unrestricted ()
+ {
+ PermissionSet ps1 = new PermissionSet (PermissionState.None);
+ ps1.AddPermission (new PrincipalPermission (PermissionState.Unrestricted));
+ PermissionSet ps2 = new PermissionSet (PermissionState.None);
+ Assert.IsTrue (!ps1.IsSubsetOf (null), "PS1.IsSubset(null)");
+ Assert.IsTrue (!ps1.IsSubsetOf (ps2), "PS1.IsSubset(None)");
+ Assert.IsTrue (ps2.IsSubsetOf (ps1), "None.IsSubset(PS1)");
+
+ PermissionSet ps3 = ps1.Copy ();
+ Assert.IsTrue (ps1.IsSubsetOf (ps3), "PS1.IsSubset(PS3)");
+ Assert.IsTrue (ps3.IsSubsetOf (ps1), "PS3.IsSubset(PS1)");
+
+ PermissionSet ups1 = new PermissionSet (PermissionState.Unrestricted);
+#if NET_2_0
+ Assert.IsTrue (ps1.IsSubsetOf (ups1), "PS1.IsSubset(Unrestricted)");
#else
- Assert ("PS1.IsSubset(Unrestricted)", !ps1.IsSubsetOf (ups1));\r
-#endif\r
- Assert ("Unrestricted.IsSubset(PS1)", !ups1.IsSubsetOf (ps1));\r
+ Assert.IsTrue (!ps1.IsSubsetOf (ups1), "PS1.IsSubset(Unrestricted)");
+#endif
+ Assert.IsTrue (!ups1.IsSubsetOf (ps1), "Unrestricted.IsSubset(PS1)");
}
[Test]
public void RemovePermission_Null ()
{
PermissionSet ps = new PermissionSet (PermissionState.None);
- AssertNull (ps.RemovePermission (null));
+ Assert.IsNull (ps.RemovePermission (null));
}
[Test]
public void RemovePermission_None ()
{
PermissionSet ps = new PermissionSet (PermissionState.None);
- AssertNull ("Empty", ps.RemovePermission (typeof (SecurityPermission)));
+ Assert.IsNull (ps.RemovePermission (typeof (SecurityPermission)), "Empty");
SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
ps.AddPermission (sp);
SecurityPermission removed = (SecurityPermission) ps.RemovePermission (typeof (SecurityPermission));
- AssertNotNull ("SecurityPermission", removed);
- AssertEquals ("Flags", sp.Flags, removed.Flags);
- AssertNull ("Empty-Again", ps.RemovePermission (typeof (SecurityPermission)));
+ Assert.IsNotNull (removed, "SecurityPermission");
+ Assert.AreEqual (sp.Flags, removed.Flags, "Flags");
+ Assert.IsNull (ps.RemovePermission (typeof (SecurityPermission)), "Empty-Again");
}
[Test]
public void RemovePermission_Unrestricted ()
{
PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
- AssertNull ("Empty", ps.RemovePermission (typeof (SecurityPermission)));
+ Assert.IsNull (ps.RemovePermission (typeof (SecurityPermission)), "Empty");
SecurityPermission sp = new SecurityPermission (SecurityPermissionFlag.Assertion);
ps.AddPermission (sp);
- AssertNull ("SecurityPermissionn", ps.RemovePermission (typeof (SecurityPermission)));
+ Assert.IsNull (ps.RemovePermission (typeof (SecurityPermission)), "SecurityPermissionn");
ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
ps.AddPermission (zip);
ZoneIdentityPermission removed = (ZoneIdentityPermission)ps.RemovePermission (typeof (ZoneIdentityPermission));
#if NET_2_0
// identity permissions aren't added to unrestricted permission sets
// so they cannot be removed later (hence the null)
- AssertNull ("ZoneIdentityPermission", removed);
+ Assert.IsNull (removed, "ZoneIdentityPermission");
#else
- AssertNotNull ("ZoneIdentityPermission", removed);
+ Assert.IsNotNull (removed, "ZoneIdentityPermission");
#endif
}
public void SetPermission_Null ()
{
PermissionSet ps = new PermissionSet (PermissionState.None);
- AssertNull (ps.SetPermission (null));
+ Assert.IsNull (ps.SetPermission (null));
}
[Test]
public void SetPermission_None ()
{
PermissionSet ps = new PermissionSet (PermissionState.None);
- AssertEquals ("Empty", 0, ps.Count);
- Assert ("State-None", !ps.IsUnrestricted ());
+ Assert.AreEqual (0, ps.Count, "Empty");
+ Assert.IsTrue (!ps.IsUnrestricted (), "State-None");
SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
SecurityPermission result = (SecurityPermission)ps.SetPermission (sp);
- AssertEquals ("SecurityPermission", 1, ps.Count);
- AssertEquals ("Flags", SecurityPermissionFlag.AllFlags, result.Flags);
- Assert ("State-None-2", !ps.IsUnrestricted ());
+ Assert.AreEqual (1, ps.Count, "SecurityPermission");
+ Assert.AreEqual (SecurityPermissionFlag.AllFlags, result.Flags, "Flags");
+ Assert.IsTrue (!ps.IsUnrestricted (), "State-None-2");
sp = new SecurityPermission (SecurityPermissionFlag.ControlAppDomain);
result = (SecurityPermission)ps.SetPermission (sp);
- AssertEquals ("SecurityPermission-2", 1, ps.Count);
- AssertEquals ("Flags", SecurityPermissionFlag.ControlAppDomain, result.Flags);
+ Assert.AreEqual (1, ps.Count, "SecurityPermission-2");
+ Assert.AreEqual (SecurityPermissionFlag.ControlAppDomain, result.Flags, "Flags");
ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
ZoneIdentityPermission zipr = (ZoneIdentityPermission) ps.SetPermission (zip);
- AssertEquals ("ZoneIdentityPermission", 2, ps.Count);
- AssertEquals ("SecurityZone", SecurityZone.MyComputer, zipr.SecurityZone);
+ Assert.AreEqual (2, ps.Count, "ZoneIdentityPermission");
+ Assert.AreEqual (SecurityZone.MyComputer, zipr.SecurityZone, "SecurityZone");
zip = new ZoneIdentityPermission (SecurityZone.Intranet);
zipr = (ZoneIdentityPermission)ps.SetPermission (zip);
- AssertEquals ("ZoneIdentityPermission", 2, ps.Count);
- AssertEquals ("SecurityZone", SecurityZone.Intranet, zipr.SecurityZone);
+ Assert.AreEqual (2, ps.Count, "ZoneIdentityPermission");
+ Assert.AreEqual (SecurityZone.Intranet, zipr.SecurityZone, "SecurityZone");
}
[Test]
{
SecurityPermission sp = new SecurityPermission (PermissionState.Unrestricted);
PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
- AssertEquals ("Empty", 0, ps.Count);
- Assert ("State-Unrestricted", ps.IsUnrestricted ());
+ Assert.AreEqual (0, ps.Count, "Empty");
+ Assert.IsTrue (ps.IsUnrestricted (), "State-Unrestricted");
ZoneIdentityPermission zip = new ZoneIdentityPermission (SecurityZone.MyComputer);
ZoneIdentityPermission zipr = (ZoneIdentityPermission)ps.SetPermission (zip);
- AssertEquals ("ZoneIdentityPermission", 1, ps.Count);
- AssertEquals ("SecurityZone", SecurityZone.MyComputer, zipr.SecurityZone);
+ Assert.AreEqual (1, ps.Count, "ZoneIdentityPermission");
+ Assert.AreEqual (SecurityZone.MyComputer, zipr.SecurityZone, "SecurityZone");
#if NET_2_0
// Adding a non unrestricted identity permission now results in
// a permission set loosing it's unrestricted status
- Assert ("State-Unrestricted-2", !ps.IsUnrestricted ());
+ Assert.IsTrue (!ps.IsUnrestricted (), "State-Unrestricted-2");
#else
- Assert ("State-Unrestricted-2", ps.IsUnrestricted ());
+ Assert.IsTrue (ps.IsUnrestricted (), "State-Unrestricted-2");
#endif
zip = new ZoneIdentityPermission (SecurityZone.Intranet);
zipr = (ZoneIdentityPermission)ps.SetPermission (zip);
- AssertEquals ("ZoneIdentityPermission-2", 1, ps.Count);
- AssertEquals ("SecurityZone-2", SecurityZone.Intranet, zipr.SecurityZone);
+ Assert.AreEqual (1, ps.Count, "ZoneIdentityPermission-2");
+ Assert.AreEqual (SecurityZone.Intranet, zipr.SecurityZone, "SecurityZone-2");
SecurityPermission result = (SecurityPermission)ps.SetPermission (sp);
- AssertEquals ("SecurityPermission", 2, ps.Count);
- AssertEquals ("Flags", SecurityPermissionFlag.AllFlags, result.Flags);
- Assert ("State-None", !ps.IsUnrestricted ());
+ Assert.AreEqual (2, ps.Count, "SecurityPermission");
+ Assert.AreEqual (SecurityPermissionFlag.AllFlags, result.Flags, "Flags");
+ Assert.IsTrue (!ps.IsUnrestricted (), "State-None");
sp = new SecurityPermission (SecurityPermissionFlag.ControlAppDomain);
result = (SecurityPermission)ps.SetPermission (sp);
- AssertEquals ("SecurityPermission-2", 2, ps.Count);
- AssertEquals ("Flags-2", SecurityPermissionFlag.ControlAppDomain, result.Flags);
+ Assert.AreEqual (2, ps.Count, "SecurityPermission-2");
+ Assert.AreEqual (SecurityPermissionFlag.ControlAppDomain, result.Flags, "Flags-2");
}
[Test]
{
PermissionSet ps = new PermissionSet (PermissionState.None);
SecurityElement se = ps.ToXml ();
- Assert ("None.ToString().StartsWith", ps.ToString().StartsWith ("<PermissionSet"));
- AssertEquals ("None.class", "System.Security.PermissionSet", (se.Attributes ["class"] as string));
- AssertEquals ("None.version", "1", (se.Attributes ["version"] as string));
- AssertNull ("None.Unrestricted", (se.Attributes ["Unrestricted"] as string));
+ Assert.IsTrue (ps.ToString().StartsWith ("<PermissionSet"), "None.ToString().StartsWith");
+ Assert.AreEqual ("System.Security.PermissionSet", (se.Attributes ["class"] as string), "None.class");
+ Assert.AreEqual ("1", (se.Attributes ["version"] as string), "None.version");
+ Assert.IsNull ((se.Attributes ["Unrestricted"] as string), "None.Unrestricted");
}
[Test]
{
PermissionSet ps = new PermissionSet (PermissionState.Unrestricted);
SecurityElement se = ps.ToXml ();
- Assert ("Unrestricted.ToString().StartsWith", ps.ToString().StartsWith ("<PermissionSet"));
- AssertEquals ("Unrestricted.class", "System.Security.PermissionSet", (se.Attributes ["class"] as string));
- AssertEquals ("Unrestricted.version", "1", (se.Attributes ["version"] as string));
- AssertEquals ("Unrestricted.Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
+ Assert.IsTrue (ps.ToString().StartsWith ("<PermissionSet"), "Unrestricted.ToString().StartsWith");
+ Assert.AreEqual ("System.Security.PermissionSet", (se.Attributes ["class"] as string), "Unrestricted.class");
+ Assert.AreEqual ("1", (se.Attributes ["version"] as string), "Unrestricted.version");
+ Assert.AreEqual ("true", (se.Attributes ["Unrestricted"] as string), "Unrestricted.Unrestricted");
}
[Test]
{
PermissionSet ps = new PermissionSet (PermissionState.None);
ps.AddPermission (new PrincipalPermission (PermissionState.None));
- Assert ("ContainsNonCodeAccessPermissions", ps.ContainsNonCodeAccessPermissions ());
- AssertEquals ("Count", 1, ps.Count);
+ Assert.IsTrue (ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
+ Assert.AreEqual (1, ps.Count, "Count");
ps.Assert ();
// it's simply ignored
}
{
PermissionSet ps = new PermissionSet (PermissionState.None);
ps.AddPermission (new PrincipalPermission (PermissionState.None));
- Assert ("ContainsNonCodeAccessPermissions", ps.ContainsNonCodeAccessPermissions ());
- AssertEquals ("Count", 1, ps.Count);
+ Assert.IsTrue (ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
+ Assert.AreEqual (1, ps.Count, "Count");
ps.Deny ();
// it's simply ignored
}
{
PermissionSet ps = new PermissionSet (PermissionState.None);
ps.AddPermission (new PrincipalPermission (PermissionState.None));
- Assert ("ContainsNonCodeAccessPermissions", ps.ContainsNonCodeAccessPermissions ());
- AssertEquals ("Count", 1, ps.Count);
+ Assert.IsTrue (ps.ContainsNonCodeAccessPermissions (), "ContainsNonCodeAccessPermissions");
+ Assert.AreEqual (1, ps.Count, "Count");
ps.PermitOnly ();
// it's simply ignored
}
psa.XML = xml;
string pset = psa.CreatePermissionSet ().ToString ();
string currentVersion = typeof (string).Assembly.GetName ().Version.ToString ();
- Assert (currentVersion, pset.IndexOf (currentVersion) > 0);
+ Assert.IsTrue (pset.IndexOf (currentVersion) > 0, currentVersion);
}
[Test]
projects / mono.git / commitdiff