* *.cs: Convert all tests to new-style nunit classes/methods.
svn path=/trunk/mcs/; revision=136751
+2009-06-24 Zoltan Varga <vargaz@gmail.com>
+
+ * *.cs: Convert all tests to new-style nunit classes/methods.
+
2006-08-21 Sebastien Pouliot <sebastien@ximian.com>
* FileIOPermissionTest.cs: Added new test cases for union (#79118) and
namespace MonoTests.System.Security.Permissions {
[TestFixture]
- public class EnvironmentPermissionTest : Assertion {
+ public class EnvironmentPermissionTest {
private static string className = "System.Security.Permissions.EnvironmentPermission, ";
private static string envVariables = "TMP;TEMP";
public void PermissionStateNone ()
{
EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
- AssertNotNull ("EnvironmentPermission(PermissionState.None)", ep);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsNotNull (ep, "EnvironmentPermission(PermissionState.None)");
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
EnvironmentPermission copy = (EnvironmentPermission) ep.Copy ();
- AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
+ Assert.AreEqual (ep.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = ep.ToXml ();
- Assert ("ToXml-class", (se.Attributes ["class"] as string).StartsWith (className));
- AssertEquals ("ToXml-version", "1", (se.Attributes ["version"] as string));
+ Assert.IsTrue ((se.Attributes ["class"] as string).StartsWith (className), "ToXml-class");
+ Assert.AreEqual ("1", (se.Attributes ["version"] as string), "ToXml-version");
}
[Test]
public void PermissionStateUnrestricted ()
{
EnvironmentPermission ep = new EnvironmentPermission (PermissionState.Unrestricted);
- AssertNotNull ("EnvironmentPermission(PermissionState.Unrestricted)", ep);
- Assert ("IsUnrestricted", ep.IsUnrestricted ());
+ Assert.IsNotNull (ep, "EnvironmentPermission(PermissionState.Unrestricted)");
+ Assert.IsTrue (ep.IsUnrestricted (), "IsUnrestricted");
EnvironmentPermission copy = (EnvironmentPermission) ep.Copy ();
- AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
+ Assert.AreEqual (ep.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = ep.ToXml ();
- AssertEquals ("ToXml-Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
+ Assert.AreEqual ("true", (se.Attributes ["Unrestricted"] as string), "ToXml-Unrestricted");
}
[Test]
public void AllAccess ()
{
EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, envVariables);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
}
[Test]
public void NoAccess ()
{
EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.NoAccess, envVariables);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
}
[Test]
public void ReadAccess ()
{
EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
}
[Test]
public void WriteAccess ()
{
EnvironmentPermission ep = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
}
[Test]
ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
SecurityElement se = ep.ToXml ();
// Note: Debugger can mess results (try to run without stepping)
- AssertEquals ("AddPathList-ToXml-Read", "TMP;TEMP;UID", (se.Attributes ["Read"] as string));
- AssertEquals ("AddPathList-ToXml-Write", "TMP;TEMP;PROMPT", (se.Attributes ["Write"] as string));
+ Assert.AreEqual ("TMP;TEMP;UID", (se.Attributes ["Read"] as string), "AddPathList-ToXml-Read");
+ Assert.AreEqual ("TMP;TEMP;PROMPT", (se.Attributes ["Write"] as string), "AddPathList-ToXml-Write");
}
[Test]
EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
- AssertEquals ("GetPathList-AllAccess", "", ep.GetPathList (EnvironmentPermissionAccess.AllAccess));
+ Assert.AreEqual ("", ep.GetPathList (EnvironmentPermissionAccess.AllAccess), "GetPathList-AllAccess");
}
[Test]
EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
- AssertEquals ("GetPathList-NoAccess", "", ep.GetPathList (EnvironmentPermissionAccess.NoAccess));
+ Assert.AreEqual ("", ep.GetPathList (EnvironmentPermissionAccess.NoAccess), "GetPathList-NoAccess");
}
[Test]
{
EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
#if NET_2_0
- AssertEquals ("GetPathList-Read-Empty", String.Empty, ep.GetPathList (EnvironmentPermissionAccess.Read));
- AssertEquals ("GetPathList-Write-Empty", String.Empty, ep.GetPathList (EnvironmentPermissionAccess.Write));
+ Assert.AreEqual (String.Empty, ep.GetPathList (EnvironmentPermissionAccess.Read), "GetPathList-Read-Empty");
+ Assert.AreEqual (String.Empty, ep.GetPathList (EnvironmentPermissionAccess.Write), "GetPathList-Write-Empty");
#else
- AssertNull ("GetPathList-Read-Empty", ep.GetPathList (EnvironmentPermissionAccess.Read));
- AssertNull ("GetPathList-Write-Empty", ep.GetPathList (EnvironmentPermissionAccess.Write));
+ Assert.IsNull (ep.GetPathList (EnvironmentPermissionAccess.Read), "GetPathList-Read-Empty");
+ Assert.IsNull (ep.GetPathList (EnvironmentPermissionAccess.Write), "GetPathList-Write-Empty");
#endif
ep.AddPathList (EnvironmentPermissionAccess.Read, "UID");
ep.AddPathList (EnvironmentPermissionAccess.Write, "PROMPT");
- AssertEquals ("GetPathList-Read", "UID", ep.GetPathList (EnvironmentPermissionAccess.Read));
- AssertEquals ("GetPathList-Write", "PROMPT", ep.GetPathList (EnvironmentPermissionAccess.Write));
+ Assert.AreEqual ("UID", ep.GetPathList (EnvironmentPermissionAccess.Read), "GetPathList-Read");
+ Assert.AreEqual ("PROMPT", ep.GetPathList (EnvironmentPermissionAccess.Write), "GetPathList-Write");
}
[Test]
ep.SetPathList (EnvironmentPermissionAccess.Read, "UID");
ep.SetPathList (EnvironmentPermissionAccess.Write, "PROMPT");
SecurityElement se = ep.ToXml ();
- AssertEquals ("SetPathList-ToXml-Read", "UID", (se.Attributes ["Read"] as string));
- AssertEquals ("SetPathList-ToXml-Write", "PROMPT", (se.Attributes ["Write"] as string));
+ Assert.AreEqual ("UID", (se.Attributes ["Read"] as string), "SetPathList-ToXml-Read");
+ Assert.AreEqual ("PROMPT", (se.Attributes ["Write"] as string), "SetPathList-ToXml-Write");
}
[Test]
{
EnvironmentPermission ep = new EnvironmentPermission (PermissionState.None);
SecurityElement se = ep.ToXml ();
- AssertNotNull ("ToXml()", se);
+ Assert.IsNotNull (se, "ToXml()");
ep.FromXml (se);
se.AddAttribute ("Read", envVariables);
ep.FromXml (se);
- AssertEquals ("FromXml-Read", envVariables, ep.GetPathList (EnvironmentPermissionAccess.Read));
+ Assert.AreEqual (envVariables, ep.GetPathList (EnvironmentPermissionAccess.Read), "FromXml-Read");
se.AddAttribute ("Write", envVariables);
ep.FromXml (se);
- AssertEquals ("FromXml-Read", envVariables, ep.GetPathList (EnvironmentPermissionAccess.Read));
- AssertEquals ("FromXml-Write", envVariables, ep.GetPathList (EnvironmentPermissionAccess.Write));
+ Assert.AreEqual (envVariables, ep.GetPathList (EnvironmentPermissionAccess.Read), "FromXml-Read");
+ Assert.AreEqual (envVariables, ep.GetPathList (EnvironmentPermissionAccess.Write), "FromXml-Write");
}
[Test]
EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
EnvironmentPermission ep2 = null;
EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (ep2);
- AssertEquals ("EP1 U null == EP1", ep1.ToXml ().ToString (), ep3.ToXml ().ToString ());
+ Assert.AreEqual (ep1.ToXml ().ToString (), ep3.ToXml ().ToString (), "EP1 U null == EP1");
}
[Test]
EnvironmentPermission ep1 = new EnvironmentPermission (PermissionState.Unrestricted);
EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (ep2);
- Assert ("Unrestricted U EP2 == Unrestricted", ep3.IsUnrestricted ());
+ Assert.IsTrue (ep3.IsUnrestricted (), "Unrestricted U EP2 == Unrestricted");
ep3 = (EnvironmentPermission) ep2.Union (ep1);
- Assert ("EP2 U Unrestricted == Unrestricted", ep3.IsUnrestricted ());
+ Assert.IsTrue (ep3.IsUnrestricted (), "EP2 U Unrestricted == Unrestricted");
}
#if NET_2_0
[Category ("NotWorking")]
EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Union (ep2);
EnvironmentPermission ep4 = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, envVariables);
- AssertEquals ("EP1 U EP2 == EP1+2", ep3.ToXml ().ToString (), ep4.ToXml ().ToString ());
+ Assert.AreEqual (ep3.ToXml ().ToString (), ep4.ToXml ().ToString (), "EP1 U EP2 == EP1+2");
}
[Test]
EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
EnvironmentPermission ep2 = null;
EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (ep2);
- AssertNull ("EP1 N null == null", ep3);
+ Assert.IsNull (ep3, "EP1 N null == null");
}
[Test]
EnvironmentPermission ep1 = new EnvironmentPermission (PermissionState.Unrestricted);
EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (ep2);
- Assert ("Unrestricted N EP2 == EP2", !ep3.IsUnrestricted ());
- AssertEquals ("Unrestricted N EP2 == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
+ Assert.IsTrue (!ep3.IsUnrestricted (), "Unrestricted N EP2 == EP2");
+ Assert.AreEqual (ep2.ToXml ().ToString (), ep3.ToXml ().ToString (), "Unrestricted N EP2 == EP2");
ep3 = (EnvironmentPermission) ep2.Intersect (ep1);
- Assert ("EP2 N Unrestricted == EP2", !ep3.IsUnrestricted ());
- AssertEquals ("EP2 N Unrestricted == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
+ Assert.IsTrue (!ep3.IsUnrestricted (), "EP2 N Unrestricted == EP2");
+ Assert.AreEqual (ep2.ToXml ().ToString (), ep3.ToXml ().ToString (), "EP2 N Unrestricted == EP2");
}
[Test]
EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
EnvironmentPermission ep3 = (EnvironmentPermission) ep1.Intersect (ep2);
- AssertNull ("EP1 N EP2 == null", ep3);
+ Assert.IsNull (ep3, "EP1 N EP2 == null");
// intersection in read
EnvironmentPermission ep4 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, "TMP");
ep3 = (EnvironmentPermission) ep4.Intersect (ep2);
- AssertEquals ("Intersect-Read", "TMP", ep3.GetPathList (EnvironmentPermissionAccess.Read));
+ Assert.AreEqual ("TMP", ep3.GetPathList (EnvironmentPermissionAccess.Read), "Intersect-Read");
// intersection in write
EnvironmentPermission ep5 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, "TEMP");
ep3 = (EnvironmentPermission) ep5.Intersect (ep1);
- AssertEquals ("Intersect-Read", "TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Write));
+ Assert.AreEqual ("TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Write), "Intersect-Read");
// intersection in read and write
EnvironmentPermission ep6 = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, "TEMP");
EnvironmentPermission ep7 = new EnvironmentPermission (EnvironmentPermissionAccess.AllAccess, envVariables);
ep3 = (EnvironmentPermission) ep6.Intersect (ep7);
- AssertEquals ("Intersect-AllAccess-Read", "TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Read));
- AssertEquals ("Intersect-AllAccess-Write", "TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Write));
+ Assert.AreEqual ("TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Read), "Intersect-AllAccess-Read");
+ Assert.AreEqual ("TEMP", ep3.GetPathList (EnvironmentPermissionAccess.Write), "Intersect-AllAccess-Write");
}
[Test]
public void IsSubsetOfNull ()
{
EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
- Assert ("IsSubsetOf(null)", !ep1.IsSubsetOf (null));
+ Assert.IsTrue (!ep1.IsSubsetOf (null), "IsSubsetOf(null)");
}
[Test]
EnvironmentPermission ep1 = new EnvironmentPermission (PermissionState.Unrestricted);
EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
EnvironmentPermission ep3 = new EnvironmentPermission (PermissionState.Unrestricted);
- Assert ("Unrestricted.IsSubsetOf()", !ep1.IsSubsetOf (ep2));
- Assert ("IsSubsetOf(Unrestricted)", ep2.IsSubsetOf (ep1));
- Assert ("Unrestricted.IsSubsetOf(Unrestricted)", ep1.IsSubsetOf (ep3));
+ Assert.IsTrue (!ep1.IsSubsetOf (ep2), "Unrestricted.IsSubsetOf()");
+ Assert.IsTrue (ep2.IsSubsetOf (ep1), "IsSubsetOf(Unrestricted)");
+ Assert.IsTrue (ep1.IsSubsetOf (ep3), "Unrestricted.IsSubsetOf(Unrestricted)");
}
[Test]
{
EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, envVariables);
EnvironmentPermission ep2 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
- Assert ("IsSubsetOf(nosubset1)", !ep1.IsSubsetOf (ep2));
- Assert ("IsSubsetOf(nosubset2)", !ep2.IsSubsetOf (ep1));
+ Assert.IsTrue (!ep1.IsSubsetOf (ep2), "IsSubsetOf(nosubset1)");
+ Assert.IsTrue (!ep2.IsSubsetOf (ep1), "IsSubsetOf(nosubset2)");
EnvironmentPermission ep3 = new EnvironmentPermission (EnvironmentPermissionAccess.Write, "TMP");
- Assert ("IsSubsetOf(TMP)", !ep1.IsSubsetOf (ep3));
- Assert ("TMP.IsSubsetOf()", ep3.IsSubsetOf (ep1));
+ Assert.IsTrue (!ep1.IsSubsetOf (ep3), "IsSubsetOf(TMP)");
+ Assert.IsTrue (ep3.IsSubsetOf (ep1), "TMP.IsSubsetOf()");
}
[Test]
{
EnvironmentPermission ep1 = new EnvironmentPermission (EnvironmentPermissionAccess.Read, envVariables);
FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
- Assert ("IsSubsetOf(FileDialogPermission)", ep1.IsSubsetOf (fdp2));
+ Assert.IsTrue (ep1.IsSubsetOf (fdp2), "IsSubsetOf(FileDialogPermission)");
}
}
}
namespace MonoTests.System.Security.Permissions {
[TestFixture]
- public class FileDialogPermissionTest : Assertion {
+ public class FileDialogPermissionTest {
private static string className = "System.Security.Permissions.FileDialogPermission, ";
public void PermissionStateNone ()
{
FileDialogPermission p = new FileDialogPermission (PermissionState.None);
- AssertNotNull ("FileDialogPermission(PermissionState.None)", p);
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsNotNull (p, "FileDialogPermission(PermissionState.None)");
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
FileDialogPermission copy = (FileDialogPermission) p.Copy ();
- AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ());
+ Assert.AreEqual (p.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = p.ToXml ();
- Assert ("ToXml-class", (se.Attributes ["class"] as string).StartsWith (className));
- AssertEquals ("ToXml-version", "1", (se.Attributes ["version"] as string));
+ Assert.IsTrue ((se.Attributes ["class"] as string).StartsWith (className), "ToXml-class");
+ Assert.AreEqual ("1", (se.Attributes ["version"] as string), "ToXml-version");
}
[Test]
public void PermissionStateUnrestricted ()
{
FileDialogPermission p = new FileDialogPermission (PermissionState.Unrestricted);
- AssertNotNull ("FileDialogPermission(PermissionState.Unrestricted)", p);
- Assert ("IsUnrestricted", p.IsUnrestricted ());
+ Assert.IsNotNull (p, "FileDialogPermission(PermissionState.Unrestricted)");
+ Assert.IsTrue (p.IsUnrestricted (), "IsUnrestricted");
FileDialogPermission copy = (FileDialogPermission) p.Copy ();
- AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ());
+ Assert.AreEqual (p.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertEquals ("ToXml-Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
+ Assert.AreEqual ("true", (se.Attributes ["Unrestricted"] as string), "ToXml-Unrestricted");
}
[Test]
public void Derestricted ()
{
FileDialogPermission p = new FileDialogPermission (PermissionState.Unrestricted);
- Assert ("IsUnrestricted", p.IsUnrestricted ());
+ Assert.IsTrue (p.IsUnrestricted (), "IsUnrestricted");
p.Access = FileDialogPermissionAccess.None;
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
}
[Test]
public void None ()
{
FileDialogPermission p = new FileDialogPermission (FileDialogPermissionAccess.None);
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertNull ("ToXml-Access=None", (se.Attributes ["Access"] as string));
+ Assert.IsNull ((se.Attributes ["Access"] as string), "ToXml-Access=None");
}
[Test]
public void Open ()
{
FileDialogPermission p = new FileDialogPermission (FileDialogPermissionAccess.Open);
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertEquals ("ToXml-Access=Open", "Open", (se.Attributes ["Access"] as string));
+ Assert.AreEqual ("Open", (se.Attributes ["Access"] as string), "ToXml-Access=Open");
}
[Test]
public void Save ()
{
FileDialogPermission p = new FileDialogPermission (FileDialogPermissionAccess.Save);
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertEquals ("ToXml-Access=Save", "Save", (se.Attributes ["Access"] as string));
+ Assert.AreEqual ("Save", (se.Attributes ["Access"] as string), "ToXml-Access=Save");
}
[Test]
public void OpenSave ()
{
FileDialogPermission p = new FileDialogPermission (FileDialogPermissionAccess.OpenSave);
- Assert ("IsUnrestricted", p.IsUnrestricted ());
+ Assert.IsTrue (p.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertEquals ("ToXml-Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
+ Assert.AreEqual ("true", (se.Attributes ["Unrestricted"] as string), "ToXml-Unrestricted");
}
[Test]
public void Access ()
{
FileDialogPermission p = new FileDialogPermission (PermissionState.None);
- Assert ("Access(default).IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "Access(default).IsUnrestricted");
p.Access = FileDialogPermissionAccess.None;
- Assert ("Access(None).IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "Access(None).IsUnrestricted");
p.Access = FileDialogPermissionAccess.Open;
- Assert ("Access(Open).IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "Access(Open).IsUnrestricted");
p.Access = FileDialogPermissionAccess.Save;
- Assert ("Access(Save).IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "Access(Save).IsUnrestricted");
p.Access = FileDialogPermissionAccess.OpenSave;
- Assert ("Access(OpenSave).IsUnrestricted", p.IsUnrestricted ());
+ Assert.IsTrue (p.IsUnrestricted (), "Access(OpenSave).IsUnrestricted");
}
[Test]
{
FileDialogPermission p = new FileDialogPermission (PermissionState.None);
SecurityElement se = p.ToXml ();
- AssertNotNull ("ToXml()", se);
+ Assert.IsNotNull (se, "ToXml()");
FileDialogPermission p2 = (FileDialogPermission) p.Copy ();
p2.FromXml (se);
- AssertEquals ("FromXml-None", FileDialogPermissionAccess.None, p2.Access);
+ Assert.AreEqual (FileDialogPermissionAccess.None, p2.Access, "FromXml-None");
se.AddAttribute ("Access", "Open");
p2.FromXml (se);
- AssertEquals ("FromXml-Open", FileDialogPermissionAccess.Open, p2.Access);
+ Assert.AreEqual (FileDialogPermissionAccess.Open, p2.Access, "FromXml-Open");
se = p.ToXml ();
se.AddAttribute ("Access", "Save");
p2.FromXml (se);
- AssertEquals ("FromXml-Save", FileDialogPermissionAccess.Save, p2.Access);
+ Assert.AreEqual (FileDialogPermissionAccess.Save, p2.Access, "FromXml-Save");
se = p.ToXml ();
se.AddAttribute ("Unrestricted", "true");
p2.FromXml (se);
- Assert ("FromXml-Unrestricted", p2.IsUnrestricted ());
+ Assert.IsTrue (p2.IsUnrestricted (), "FromXml-Unrestricted");
}
[Test]
FileDialogPermission p1 = new FileDialogPermission (FileDialogPermissionAccess.Open);
FileDialogPermission p2 = null;
FileDialogPermission p3 = (FileDialogPermission) p1.Union (p2);
- AssertEquals ("P1 U null == P1", p1.ToXml ().ToString (), p3.ToXml ().ToString ());
+ Assert.AreEqual (p1.ToXml ().ToString (), p3.ToXml ().ToString (), "P1 U null == P1");
}
[Test]
FileDialogPermission p1 = new FileDialogPermission (PermissionState.Unrestricted);
FileDialogPermission p2 = new FileDialogPermission (FileDialogPermissionAccess.Open);
FileDialogPermission p3 = (FileDialogPermission) p1.Union (p2);
- Assert ("Unrestricted U P2 == Unrestricted", p3.IsUnrestricted ());
+ Assert.IsTrue (p3.IsUnrestricted (), "Unrestricted U P2 == Unrestricted");
p3 = (FileDialogPermission) p2.Union (p1);
- Assert ("P2 U Unrestricted == Unrestricted", p3.IsUnrestricted ());
+ Assert.IsTrue (p3.IsUnrestricted (), "P2 U Unrestricted == Unrestricted");
}
[Test]
FileDialogPermission p2 = new FileDialogPermission (FileDialogPermissionAccess.Save);
FileDialogPermission p3 = (FileDialogPermission) p1.Union (p2);
FileDialogPermission p4 = new FileDialogPermission (FileDialogPermissionAccess.OpenSave);
- AssertEquals ("P1 U P2 == P1+2", p3.ToXml ().ToString (), p4.ToXml ().ToString ());
- Assert ("P1+2==Unrestricted", p3.IsUnrestricted ());
+ Assert.AreEqual (p3.ToXml ().ToString (), p4.ToXml ().ToString (), "P1 U P2 == P1+2");
+ Assert.IsTrue (p3.IsUnrestricted (), "P1+2==Unrestricted");
}
[Test]
FileDialogPermission p1 = new FileDialogPermission (FileDialogPermissionAccess.Open);
FileDialogPermission p2 = null;
FileDialogPermission p3 = (FileDialogPermission) p1.Intersect (p2);
- AssertNull ("P1 N null == null", p3);
+ Assert.IsNull (p3, "P1 N null == null");
}
[Test]
FileDialogPermission p1 = new FileDialogPermission (PermissionState.Unrestricted);
FileDialogPermission p2 = new FileDialogPermission (FileDialogPermissionAccess.Open);
FileDialogPermission p3 = (FileDialogPermission) p1.Intersect (p2);
- Assert ("Unrestricted N P2 == P2", !p3.IsUnrestricted ());
- AssertEquals ("Unrestricted N EP2 == EP2", p2.ToXml ().ToString (), p3.ToXml ().ToString ());
+ Assert.IsTrue (!p3.IsUnrestricted (), "Unrestricted N P2 == P2");
+ Assert.AreEqual (p2.ToXml ().ToString (), p3.ToXml ().ToString (), "Unrestricted N EP2 == EP2");
p3 = (FileDialogPermission) p2.Intersect (p1);
- Assert ("P2 N Unrestricted == P2", !p3.IsUnrestricted ());
- AssertEquals ("P2 N Unrestricted == P2", p2.ToXml ().ToString (), p3.ToXml ().ToString ());
+ Assert.IsTrue (!p3.IsUnrestricted (), "P2 N Unrestricted == P2");
+ Assert.AreEqual (p2.ToXml ().ToString (), p3.ToXml ().ToString (), "P2 N Unrestricted == P2");
}
[Test]
FileDialogPermission p1 = new FileDialogPermission (FileDialogPermissionAccess.Open);
FileDialogPermission p2 = new FileDialogPermission (FileDialogPermissionAccess.Save);
FileDialogPermission p3 = (FileDialogPermission) p1.Intersect (p2);
- AssertNull ("EP1 N EP2 == null", p3);
+ Assert.IsNull (p3, "EP1 N EP2 == null");
// intersection in open
FileDialogPermission p4 = new FileDialogPermission (FileDialogPermissionAccess.Open);
p3 = (FileDialogPermission) p4.Intersect (p1);
- AssertEquals ("Intersect-Open", FileDialogPermissionAccess.Open, p3.Access);
+ Assert.AreEqual (FileDialogPermissionAccess.Open, p3.Access, "Intersect-Open");
// intersection in save
FileDialogPermission p5 = new FileDialogPermission (FileDialogPermissionAccess.Save);
p3 = (FileDialogPermission) p5.Intersect (p2);
- AssertEquals ("Intersect-Save", FileDialogPermissionAccess.Save, p3.Access);
+ Assert.AreEqual (FileDialogPermissionAccess.Save, p3.Access, "Intersect-Save");
// intersection in open and save
FileDialogPermission p6 = new FileDialogPermission (FileDialogPermissionAccess.OpenSave);
FileDialogPermission p7 = new FileDialogPermission (FileDialogPermissionAccess.OpenSave);
p3 = (FileDialogPermission) p6.Intersect (p7);
- AssertEquals ("Intersect-AllAccess-OpenSave", FileDialogPermissionAccess.OpenSave, p3.Access);
- Assert ("Intersect-OpenSave-Unrestricted", p3.IsUnrestricted ());
+ Assert.AreEqual (FileDialogPermissionAccess.OpenSave, p3.Access, "Intersect-AllAccess-OpenSave");
+ Assert.IsTrue (p3.IsUnrestricted (), "Intersect-OpenSave-Unrestricted");
}
[Test]
public void IsSubsetOfNull ()
{
FileDialogPermission p1 = new FileDialogPermission (FileDialogPermissionAccess.Open);
- Assert ("IsSubsetOf(null)", !p1.IsSubsetOf (null));
+ Assert.IsTrue (!p1.IsSubsetOf (null), "IsSubsetOf(null)");
}
[Test]
FileDialogPermission p1 = new FileDialogPermission (PermissionState.Unrestricted);
FileDialogPermission p2 = new FileDialogPermission (FileDialogPermissionAccess.Open);
FileDialogPermission p3 = new FileDialogPermission (PermissionState.Unrestricted);
- Assert ("Unrestricted.IsSubsetOf()", !p1.IsSubsetOf (p2));
- Assert ("IsSubsetOf(Unrestricted)", p2.IsSubsetOf (p1));
- Assert ("Unrestricted.IsSubsetOf(Unrestricted)", p1.IsSubsetOf (p3));
+ Assert.IsTrue (!p1.IsSubsetOf (p2), "Unrestricted.IsSubsetOf()");
+ Assert.IsTrue (p2.IsSubsetOf (p1), "IsSubsetOf(Unrestricted)");
+ Assert.IsTrue (p1.IsSubsetOf (p3), "Unrestricted.IsSubsetOf(Unrestricted)");
}
[Test]
{
FileDialogPermission p1 = new FileDialogPermission (FileDialogPermissionAccess.Open);
FileDialogPermission p2 = new FileDialogPermission (FileDialogPermissionAccess.Save);
- Assert ("IsSubsetOf(nosubset1)", !p1.IsSubsetOf (p2));
- Assert ("IsSubsetOf(nosubset2)", !p2.IsSubsetOf (p1));
+ Assert.IsTrue (!p1.IsSubsetOf (p2), "IsSubsetOf(nosubset1)");
+ Assert.IsTrue (!p2.IsSubsetOf (p1), "IsSubsetOf(nosubset2)");
FileDialogPermission p3 = new FileDialogPermission (FileDialogPermissionAccess.OpenSave);
- Assert ("IsSubsetOf(OpenSave)", p1.IsSubsetOf (p3));
- Assert ("OpenSave.IsSubsetOf()", !p3.IsSubsetOf (p1));
+ Assert.IsTrue (p1.IsSubsetOf (p3), "IsSubsetOf(OpenSave)");
+ Assert.IsTrue (!p3.IsSubsetOf (p1), "OpenSave.IsSubsetOf()");
}
[Test]
{
FileDialogPermission p1 = new FileDialogPermission (FileDialogPermissionAccess.Open);
EnvironmentPermission ep2 = new EnvironmentPermission (PermissionState.Unrestricted);
- Assert ("IsSubsetOf(EnvironmentPermission)", p1.IsSubsetOf (ep2));
+ Assert.IsTrue (p1.IsSubsetOf (ep2), "IsSubsetOf(EnvironmentPermission)");
}
}
}
-//\r
-// MonoTests.System.Security.Permissions.FileIOPermissionTest.cs\r
-//\r
-// Author:\r
-// Nick Drochak (ndrochak@gol.com)\r
-//\r
-// (C) 2001-2002 Nick Drochak II\r
-//\r
-// Note: Only Unix and Windows file paths are tested. To run the tests on Mac OS's\r
-// search for the "FIXME" notes below and adjust accordingly.\r
-\r
-using System;\r
-using System.IO;\r
+//
+// MonoTests.System.Security.Permissions.FileIOPermissionTest.cs
+//
+// Author:
+// Nick Drochak (ndrochak@gol.com)
+//
+// (C) 2001-2002 Nick Drochak II
+//
+// Note: Only Unix and Windows file paths are tested. To run the tests on Mac OS's
+// search for the "FIXME" notes below and adjust accordingly.
+
+using System;
+using System.IO;
using System.Runtime.InteropServices;
-using System.Reflection;\r
-using System.Security;\r
-using System.Security.Permissions;\r
-using System.Text;\r
-\r
-using NUnit.Framework;\r
-\r
-namespace MonoTests.System.Security.Permissions {\r
-#if !TARGET_JVM\r
- public class FilePathUtil {\r
- [DllImport("kernel32.dll")]\r
- private static extern uint GetLongPathName (string shortPath, \r
- StringBuilder buffer, uint bufLength);\r
-\r
- static public string GetLongPathName (string somePath) \r
- {\r
- StringBuilder buffer = new StringBuilder(260);\r
- if (0 != GetLongPathName (somePath, buffer, (uint) buffer.Capacity))\r
- return buffer.ToString ();\r
- else\r
- return null;\r
- }\r
-\r
- [DllImport("kernel32.dll", SetLastError=true)] \r
- private static extern uint GetShortPathName ( string longPath, \r
- StringBuilder buffer, uint bufLength);\r
-\r
- static public string GetShortPathName (string somePath) \r
- {\r
- StringBuilder buffer = new StringBuilder(260);\r
- if (0 != GetShortPathName (somePath, buffer, (uint) buffer.Capacity))\r
- return buffer.ToString ();\r
- else\r
- return null;\r
- }\r
- }\r
-#endif\r
-\r
- [TestFixture]\r
- public class FileIOPermissionTest : Assertion {\r
- \r
- string[] pathArrayGood;\r
- string[] pathArrayBad;\r
- FileIOPermission p;\r
- FileIOPermission p2;\r
- string[] pathsInPermission;\r
- string[] pathArrayGood2;\r
- FileIOPermission unrestricted;\r
-\r
+using System.Reflection;
+using System.Security;
+using System.Security.Permissions;
+using System.Text;
+
+using NUnit.Framework;
+
+namespace MonoTests.System.Security.Permissions {
+#if !TARGET_JVM
+ public class FilePathUtil {
+ [DllImport("kernel32.dll")]
+ private static extern uint GetLongPathName (string shortPath,
+ StringBuilder buffer, uint bufLength);
+
+ static public string GetLongPathName (string somePath)
+ {
+ StringBuilder buffer = new StringBuilder(260);
+ if (0 != GetLongPathName (somePath, buffer, (uint) buffer.Capacity))
+ return buffer.ToString ();
+ else
+ return null;
+ }
+
+ [DllImport("kernel32.dll", SetLastError=true)]
+ private static extern uint GetShortPathName ( string longPath,
+ StringBuilder buffer, uint bufLength);
+
+ static public string GetShortPathName (string somePath)
+ {
+ StringBuilder buffer = new StringBuilder(260);
+ if (0 != GetShortPathName (somePath, buffer, (uint) buffer.Capacity))
+ return buffer.ToString ();
+ else
+ return null;
+ }
+ }
+#endif
+
+ [TestFixture]
+ public class FileIOPermissionTest {
+
+ string[] pathArrayGood;
+ string[] pathArrayBad;
+ FileIOPermission p;
+ FileIOPermission p2;
+ string[] pathsInPermission;
+ string[] pathArrayGood2;
+ FileIOPermission unrestricted;
+
private string filename;
- private bool unix;\r
-\r
- [SetUp]\r
- public void SetUp () \r
- {\r
- Environment.CurrentDirectory = Path.GetTempPath();\r
- filename = Path.GetTempFileName ();\r
+ private bool unix;
+
+ [SetUp]
+ public void SetUp ()
+ {
+ Environment.CurrentDirectory = Path.GetTempPath();
+ filename = Path.GetTempFileName ();
int os = (int) Environment.OSVersion.Platform;
unix = ((os == 4) || (os == 128) || (os == 6));
-\r
- p = null;\r
- pathsInPermission = null;\r
- pathArrayGood = new string[2];\r
- pathArrayBad = new string[2];\r
- pathArrayGood2 = new string[3];\r
- // FIXME: Adjust to run on Mac OS's\r
- if (Path.VolumeSeparatorChar == ':') {\r
- pathArrayGood[0] = "c:\\temp1";\r
- pathArrayGood[1] = "d:\\temp2";\r
- pathArrayBad[0] = "c:\\temp1";\r
- pathArrayBad[1] = "d:\\temp*";\r
- pathArrayGood2[0] = "c:\\temp1";\r
- pathArrayGood2[1] = "d:\\temp2";\r
- pathArrayGood2[2] = "z:\\something";\r
- }\r
- else {\r
- pathArrayGood[0] = "/temp1";\r
- pathArrayGood[1] = "/usr/temp2";\r
- pathArrayBad[0] = "/temp1";\r
- pathArrayBad[1] = "/usr/temp*"; // not really bad under Unix...\r
- pathArrayGood2[0] = "/temp1";\r
- pathArrayGood2[1] = "/usr/temp2";\r
- pathArrayGood2[2] = "/usr/bin/something";\r
- }\r
- }\r
-\r
- [TearDown]\r
- public void TearDown () \r
- {\r
- if (File.Exists (filename))\r
- File.Delete (filename);\r
- }\r
-\r
- [Test]\r
- public void ConstructorPermissionState ()\r
- {\r
- p = new FileIOPermission(PermissionState.None);\r
- AssertEquals("Should be Restricted", false, p.IsUnrestricted());\r
- p = new FileIOPermission(PermissionState.Unrestricted);\r
- AssertEquals("Should be Unrestricted", true, p.IsUnrestricted());\r
- try{\r
- p = new FileIOPermission((PermissionState)77);\r
- Fail("Should have thrown an exception on invalid PermissionState");\r
- }\r
- catch{\r
- // we should be here if things are working. nothing to do\r
- }\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentNullException))]\r
- public void ConstructorString_Null () \r
- {\r
- p = new FileIOPermission(FileIOPermissionAccess.Append, (string)null);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void ConstructorString_NotRooted ()\r
- {\r
- p = new FileIOPermission(FileIOPermissionAccess.Append, "this path is not rooted");\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void ConstructorString_InvalidPath () \r
- {\r
- p = new FileIOPermission(FileIOPermissionAccess.Append, "<this is not a valid path>");\r
- }\r
-\r
- [Test]\r
- public void ConstructorString_Wildcard () \r
+
+ p = null;
+ pathsInPermission = null;
+ pathArrayGood = new string[2];
+ pathArrayBad = new string[2];
+ pathArrayGood2 = new string[3];
+ // FIXME: Adjust to run on Mac OS's
+ if (Path.VolumeSeparatorChar == ':') {
+ pathArrayGood[0] = "c:\\temp1";
+ pathArrayGood[1] = "d:\\temp2";
+ pathArrayBad[0] = "c:\\temp1";
+ pathArrayBad[1] = "d:\\temp*";
+ pathArrayGood2[0] = "c:\\temp1";
+ pathArrayGood2[1] = "d:\\temp2";
+ pathArrayGood2[2] = "z:\\something";
+ }
+ else {
+ pathArrayGood[0] = "/temp1";
+ pathArrayGood[1] = "/usr/temp2";
+ pathArrayBad[0] = "/temp1";
+ pathArrayBad[1] = "/usr/temp*"; // not really bad under Unix...
+ pathArrayGood2[0] = "/temp1";
+ pathArrayGood2[1] = "/usr/temp2";
+ pathArrayGood2[2] = "/usr/bin/something";
+ }
+ }
+
+ [TearDown]
+ public void TearDown ()
+ {
+ if (File.Exists (filename))
+ File.Delete (filename);
+ }
+
+ [Test]
+ public void ConstructorPermissionState ()
+ {
+ p = new FileIOPermission(PermissionState.None);
+ Assert.AreEqual(false, p.IsUnrestricted(), "Should be Restricted");
+ p = new FileIOPermission(PermissionState.Unrestricted);
+ Assert.AreEqual(true, p.IsUnrestricted(), "Should be Unrestricted");
+ try{
+ p = new FileIOPermission((PermissionState)77);
+ Assert.Fail("Should have thrown an exception on invalid PermissionState");
+ }
+ catch{
+ // we should be here if things are working. nothing to do
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void ConstructorString_Null ()
+ {
+ p = new FileIOPermission(FileIOPermissionAccess.Append, (string)null);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void ConstructorString_NotRooted ()
+ {
+ p = new FileIOPermission(FileIOPermissionAccess.Append, "this path is not rooted");
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void ConstructorString_InvalidPath ()
+ {
+ p = new FileIOPermission(FileIOPermissionAccess.Append, "<this is not a valid path>");
+ }
+
+ [Test]
+ public void ConstructorString_Wildcard ()
{
try {
// note: this is a valid path on UNIX so we must be able to protect it
}
catch (ArgumentException) {
if (unix)
- Fail ("Wildcard * is valid in filenames");
+ Assert.Fail ("Wildcard * is valid in filenames");
// else it's normal for Windows to throw ArgumentException
}
catch (Exception e) {
- Fail ("Bad or wrong exception: " + e.ToString ());
- }\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void ConstructorString_InvalidAccess () \r
- {\r
- p = new FileIOPermission((FileIOPermissionAccess)77, "c:\\temp");\r
- }\r
-\r
- [Test]\r
- public void ConstructorString ()\r
- {\r
- string pathToAdd;\r
- // FIXME: Adjust to run on Mac OS's\r
- if (Path.VolumeSeparatorChar == ':')\r
- pathToAdd = "c:\\temp";\r
- else\r
- pathToAdd = "/temp";\r
-\r
- p = new FileIOPermission(FileIOPermissionAccess.Read, pathToAdd);\r
- pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Does not contain correct number of paths. Expected 1 but got: "+pathsInPermission.Length, pathsInPermission.Length == 1);\r
- Assert("Does not contain expected path from constructor: "+pathToAdd, pathsInPermission[0] == pathToAdd);\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentNullException))]\r
- public void ConstructorStringArray_Null () \r
- {\r
- p = new FileIOPermission(FileIOPermissionAccess.Append, (string[])null);\r
- }\r
-\r
- [Test]\r
- public void ConstructorStringArray_Wildcard () \r
- {\r
+ Assert.Fail ("Bad or wrong exception: " + e.ToString ());
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void ConstructorString_InvalidAccess ()
+ {
+ p = new FileIOPermission((FileIOPermissionAccess)77, "c:\\temp");
+ }
+
+ [Test]
+ public void ConstructorString ()
+ {
+ string pathToAdd;
+ // FIXME: Adjust to run on Mac OS's
+ if (Path.VolumeSeparatorChar == ':')
+ pathToAdd = "c:\\temp";
+ else
+ pathToAdd = "/temp";
+
+ p = new FileIOPermission(FileIOPermissionAccess.Read, pathToAdd);
+ pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue (pathsInPermission.Length == 1, "Does not contain correct number of paths. Expected 1 but got: "+pathsInPermission.Length);
+ Assert.IsTrue(pathsInPermission[0] == pathToAdd, "Does not contain expected path from constructor: "+pathToAdd);
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentNullException))]
+ public void ConstructorStringArray_Null ()
+ {
+ p = new FileIOPermission(FileIOPermissionAccess.Append, (string[])null);
+ }
+
+ [Test]
+ public void ConstructorStringArray_Wildcard ()
+ {
try {
// note: this is a valid path on UNIX so we must be able to protect it
- p = new FileIOPermission(FileIOPermissionAccess.Append, pathArrayBad);\r
+ p = new FileIOPermission(FileIOPermissionAccess.Append, pathArrayBad);
}
catch (ArgumentException) {
if (unix)
- Fail ("Wildcard * is valid in filenames");
+ Assert.Fail ("Wildcard * is valid in filenames");
// else it's normal for Windows to throw ArgumentException
}
catch (Exception e) {
- Fail ("Bad or wrong exception: " + e.ToString ());
- }\r
- }\r
-\r
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
- public void ConstructorStringArray_InvalidAccess () \r
- {\r
- p = new FileIOPermission((FileIOPermissionAccess)77, pathArrayGood);\r
- }\r
-\r
- [Test]\r
- public void ConstructorStringArray () \r
- {\r
- p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);\r
- pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Does not contain correct number of paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);\r
- foreach (string s in pathsInPermission){\r
- Assert("Unexpected path in the Permission: " + s, Array.IndexOf(pathsInPermission, s) >=0);\r
- }\r
- }\r
-\r
- [Test]\r
- public void AddPathListStringArray ()\r
- {\r
- p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);\r
- pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Does not contain correct number of paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);\r
- foreach (string s in pathsInPermission){\r
- Assert("Unexpected path in the Permission: " + s, Array.IndexOf(pathsInPermission, s) >=0);\r
- }\r
-\r
- p.AddPathList(FileIOPermissionAccess.Append, pathArrayGood);\r
- pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Should still contain correct number Read paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);\r
- foreach (string s in pathsInPermission){\r
- Assert("Unexpected path in the Permission: " + s, Array.IndexOf(pathsInPermission, s) >=0);\r
- }\r
- pathsInPermission = p.GetPathList(FileIOPermissionAccess.Append);\r
- Assert("Should contain correct number of Append paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);\r
- foreach (string s in pathsInPermission){\r
- Assert("Unexpected path in the Permission: " + s, Array.IndexOf(pathsInPermission, s) >=0);\r
- }\r
- }\r
-\r
- [Test]\r
- public void Intersect ()\r
- {\r
- p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);\r
- p.AllFiles = FileIOPermissionAccess.Append;\r
- p.AllLocalFiles = FileIOPermissionAccess.Write;\r
- \r
- unrestricted = new FileIOPermission(PermissionState.Unrestricted);\r
- \r
- FileIOPermission intersection = (FileIOPermission)p.Intersect(unrestricted);\r
- pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Should contain correct number of Read paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);\r
- Assert("Should have Append bit in AllFiles.", (intersection.AllFiles & FileIOPermissionAccess.Append) != 0);\r
- Assert("Should have Write bit in AllLocalFiles.", (intersection.AllLocalFiles & FileIOPermissionAccess.Write) != 0);\r
-\r
- intersection = (FileIOPermission)unrestricted.Intersect(p);\r
- pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Should contain correct number of Read paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);\r
- Assert("Should have Append bit in AllFiles.", (intersection.AllFiles & FileIOPermissionAccess.Append) != 0);\r
- Assert("Should have Write bit in AllLocalFiles.", (intersection.AllLocalFiles & FileIOPermissionAccess.Write) != 0);\r
-\r
- p2 = new FileIOPermission(FileIOPermissionAccess.Append | FileIOPermissionAccess.Read, pathArrayGood2);\r
- p2.AllFiles = FileIOPermissionAccess.Append | FileIOPermissionAccess.Write;\r
- p2.AllLocalFiles = FileIOPermissionAccess.Write | FileIOPermissionAccess.Read;\r
- intersection = (FileIOPermission)p.Intersect(p2);\r
- pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);\r
- AssertNotNull ("Should have some paths", pathsInPermission);\r
- AssertEquals ("Should contain correct number of Read paths", 2, pathsInPermission.Length);\r
- AssertEquals ("Should have only Append bit in AllFiles.", FileIOPermissionAccess.Append, intersection.AllFiles);\r
- AssertEquals ("Should have only Write bit in AllLocalFiles.", FileIOPermissionAccess.Write, intersection.AllLocalFiles);\r
-\r
- intersection = (FileIOPermission)p2.Intersect(p);\r
- pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Should contain correct number of Read paths. Expected 2 but got: "+pathsInPermission.Length, pathsInPermission.Length == 2);\r
- Assert("Should have only Append bit in AllFiles.", intersection.AllFiles == FileIOPermissionAccess.Append);\r
- Assert("Should have only Write bit in AllLocalFiles.", intersection.AllLocalFiles == FileIOPermissionAccess.Write);\r
- }\r
-\r
- [Test]\r
- public void IsSubsetOf ()\r
- {\r
- unrestricted = new FileIOPermission(PermissionState.Unrestricted);\r
- Assert("IsSubsetOf reflective test failed", unrestricted.IsSubsetOf(unrestricted));\r
-\r
- p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);\r
- p.AllFiles = FileIOPermissionAccess.Append;\r
- p.AllLocalFiles = FileIOPermissionAccess.Write;\r
- Assert("#1 IsSubsetOf reflective test failed", p.IsSubsetOf(p));\r
- Assert("#1 IsSubsetOf false test failed", !unrestricted.IsSubsetOf(p));\r
- Assert("#1 IsSubsetOf true test failed", p.IsSubsetOf(unrestricted));\r
-\r
- p2 = new FileIOPermission(FileIOPermissionAccess.Append | FileIOPermissionAccess.Read, pathArrayGood2);\r
- p2.AllFiles = FileIOPermissionAccess.Append | FileIOPermissionAccess.Write;\r
- p2.AllLocalFiles = FileIOPermissionAccess.Write | FileIOPermissionAccess.Read;\r
- Assert("#2 IsSubsetOf reflective test failed", p2.IsSubsetOf(p2));\r
- Assert("#2 IsSubsetOf true test failed", p.IsSubsetOf(p2));\r
- Assert("#2 IsSubsetOf false test failed", !p2.IsSubsetOf(p));\r
- }\r
-\r
- [Test]\r
- public void Union ()\r
- {\r
- unrestricted = new FileIOPermission(PermissionState.Unrestricted);\r
- p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);\r
-\r
- FileIOPermission union = (FileIOPermission)unrestricted.Union(p);\r
- pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Should get an unrestricted permission", union.IsUnrestricted());\r
- Assert("Path list should be empty", pathsInPermission == null);\r
-\r
- union = (FileIOPermission)p.Union(unrestricted);\r
- pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Should get an unrestricted permission", union.IsUnrestricted());\r
- Assert("Path list should be empty", pathsInPermission == null);\r
-\r
- p2 = new FileIOPermission(FileIOPermissionAccess.Append, pathArrayGood2);\r
-\r
- union = (FileIOPermission)p.Union(p2);\r
- pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Path list should have 2 for Read", pathsInPermission.Length == pathArrayGood.Length);\r
- pathsInPermission = union.GetPathList(FileIOPermissionAccess.Append);\r
- Assert("Path list should have 3 for Append", pathsInPermission.Length == pathArrayGood2.Length);\r
-\r
- union = (FileIOPermission)p2.Union(p);\r
- pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Path list should have 2 for Read", pathsInPermission.Length == pathArrayGood.Length);\r
- pathsInPermission = union.GetPathList(FileIOPermissionAccess.Append);\r
- Assert("Path list should have 3 for Append", pathsInPermission.Length == pathArrayGood2.Length);\r
+ Assert.Fail ("Bad or wrong exception: " + e.ToString ());
+ }
+ }
+
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void ConstructorStringArray_InvalidAccess ()
+ {
+ p = new FileIOPermission((FileIOPermissionAccess)77, pathArrayGood);
+ }
+
+ [Test]
+ public void ConstructorStringArray ()
+ {
+ p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
+ pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue (pathsInPermission.Length == 2, "Does not contain correct number of paths. Expected 2 but got: "+pathsInPermission.Length);
+ foreach (string s in pathsInPermission){
+ Assert.IsTrue (Array.IndexOf(pathsInPermission, s) >=0, "Unexpected path in the Permission: " + s);
+ }
+ }
+
+ [Test]
+ public void AddPathListStringArray ()
+ {
+ p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
+ pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue (pathsInPermission.Length == 2, "Does not contain correct number of paths. Expected 2 but got: "+pathsInPermission.Length);
+ foreach (string s in pathsInPermission){
+ Assert.IsTrue (Array.IndexOf(pathsInPermission, s) >=0, "Unexpected path in the Permission: " + s);
+ }
+
+ p.AddPathList(FileIOPermissionAccess.Append, pathArrayGood);
+ pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue (pathsInPermission.Length == 2, "Should still contain correct number Read paths. Expected 2 but got: "+pathsInPermission.Length);
+ foreach (string s in pathsInPermission){
+ Assert.IsTrue (Array.IndexOf(pathsInPermission, s) >=0, "Unexpected path in the Permission: " + s);
+ }
+ pathsInPermission = p.GetPathList(FileIOPermissionAccess.Append);
+ Assert.IsTrue (pathsInPermission.Length == 2, "Should contain correct number of Append paths. Expected 2 but got: "+pathsInPermission.Length);
+ foreach (string s in pathsInPermission){
+ Assert.IsTrue (Array.IndexOf(pathsInPermission, s) >=0, "Unexpected path in the Permission: " + s);
+ }
+ }
+
+ [Test]
+ public void Intersect ()
+ {
+ p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
+ p.AllFiles = FileIOPermissionAccess.Append;
+ p.AllLocalFiles = FileIOPermissionAccess.Write;
+
+ unrestricted = new FileIOPermission(PermissionState.Unrestricted);
+
+ FileIOPermission intersection = (FileIOPermission)p.Intersect(unrestricted);
+ pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue (pathsInPermission.Length == 2, "Should contain correct number of Read paths. Expected 2 but got: "+pathsInPermission.Length);
+ Assert.IsTrue((intersection.AllFiles & FileIOPermissionAccess.Append) != 0, "Should have Append bit in AllFiles.");
+ Assert.IsTrue((intersection.AllLocalFiles & FileIOPermissionAccess.Write) != 0, "Should have Write bit in AllLocalFiles.");
+
+ intersection = (FileIOPermission)unrestricted.Intersect(p);
+ pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue (pathsInPermission.Length == 2, "Should contain correct number of Read paths. Expected 2 but got: "+pathsInPermission.Length);
+ Assert.IsTrue((intersection.AllFiles & FileIOPermissionAccess.Append) != 0, "Should have Append bit in AllFiles.");
+ Assert.IsTrue((intersection.AllLocalFiles & FileIOPermissionAccess.Write) != 0, "Should have Write bit in AllLocalFiles.");
+
+ p2 = new FileIOPermission(FileIOPermissionAccess.Append | FileIOPermissionAccess.Read, pathArrayGood2);
+ p2.AllFiles = FileIOPermissionAccess.Append | FileIOPermissionAccess.Write;
+ p2.AllLocalFiles = FileIOPermissionAccess.Write | FileIOPermissionAccess.Read;
+ intersection = (FileIOPermission)p.Intersect(p2);
+ pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsNotNull (pathsInPermission, "Should have some paths");
+ Assert.AreEqual (2, pathsInPermission.Length, "Should contain correct number of Read paths");
+ Assert.AreEqual ( FileIOPermissionAccess.Append, intersection.AllFiles, "Should have only Append bit in AllFiles.");
+ Assert.AreEqual ( FileIOPermissionAccess.Write, intersection.AllLocalFiles, "Should have only Write bit in AllLocalFiles.");
+
+ intersection = (FileIOPermission)p2.Intersect(p);
+ pathsInPermission = intersection.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue (pathsInPermission.Length == 2, "Should contain correct number of Read paths. Expected 2 but got: "+pathsInPermission.Length);
+ Assert.IsTrue(intersection.AllFiles == FileIOPermissionAccess.Append, "Should have only Append bit in AllFiles.");
+ Assert.IsTrue(intersection.AllLocalFiles == FileIOPermissionAccess.Write, "Should have only Write bit in AllLocalFiles.");
+ }
+
+ [Test]
+ public void IsSubsetOf ()
+ {
+ unrestricted = new FileIOPermission(PermissionState.Unrestricted);
+ Assert.IsTrue(unrestricted.IsSubsetOf(unrestricted), "IsSubsetOf reflective test failed");
+
+ p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
+ p.AllFiles = FileIOPermissionAccess.Append;
+ p.AllLocalFiles = FileIOPermissionAccess.Write;
+ Assert.IsTrue(p.IsSubsetOf(p), "#1 IsSubsetOf reflective test failed");
+ Assert.IsTrue(!unrestricted.IsSubsetOf(p), "#1 IsSubsetOf false test failed");
+ Assert.IsTrue(p.IsSubsetOf(unrestricted), "#1 IsSubsetOf true test failed");
+
+ p2 = new FileIOPermission(FileIOPermissionAccess.Append | FileIOPermissionAccess.Read, pathArrayGood2);
+ p2.AllFiles = FileIOPermissionAccess.Append | FileIOPermissionAccess.Write;
+ p2.AllLocalFiles = FileIOPermissionAccess.Write | FileIOPermissionAccess.Read;
+ Assert.IsTrue(p2.IsSubsetOf(p2), "#2 IsSubsetOf reflective test failed");
+ Assert.IsTrue(p.IsSubsetOf(p2), "#2 IsSubsetOf true test failed");
+ Assert.IsTrue(!p2.IsSubsetOf(p), "#2 IsSubsetOf false test failed");
+ }
+
+ [Test]
+ public void Union ()
+ {
+ unrestricted = new FileIOPermission(PermissionState.Unrestricted);
+ p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
+
+ FileIOPermission union = (FileIOPermission)unrestricted.Union(p);
+ pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue(union.IsUnrestricted(), "Should get an unrestricted permission");
+ Assert.IsTrue(pathsInPermission == null, "Path list should be empty");
+
+ union = (FileIOPermission)p.Union(unrestricted);
+ pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue(union.IsUnrestricted(), "Should get an unrestricted permission");
+ Assert.IsTrue(pathsInPermission == null, "Path list should be empty");
+
+ p2 = new FileIOPermission(FileIOPermissionAccess.Append, pathArrayGood2);
+
+ union = (FileIOPermission)p.Union(p2);
+ pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue(pathsInPermission.Length == pathArrayGood.Length, "Path list should have 2 for Read");
+ pathsInPermission = union.GetPathList(FileIOPermissionAccess.Append);
+ Assert.IsTrue(pathsInPermission.Length == pathArrayGood2.Length, "Path list should have 3 for Append");
+
+ union = (FileIOPermission)p2.Union(p);
+ pathsInPermission = union.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue(pathsInPermission.Length == pathArrayGood.Length, "Path list should have 2 for Read");
+ pathsInPermission = union.GetPathList(FileIOPermissionAccess.Append);
+ Assert.IsTrue(pathsInPermission.Length == pathArrayGood2.Length, "Path list should have 3 for Append");
}
[Test]
FileIOPermission union = (FileIOPermission) p.Union (p2);
string[] paths = union.GetPathList(FileIOPermissionAccess.Read);
- AssertEquals ("Length", 2, paths.Length);
- AssertEquals ("0", f1[0], paths[0]);
- AssertEquals ("1", f1[1], paths[1]);
+ Assert.AreEqual (2, paths.Length, "Length");
+ Assert.AreEqual (f1[0], paths[0], "0");
+ Assert.AreEqual (f1[1], paths[1], "1");
}
private void Partial (string msg, string[] path1, string[] path2, int expected)
FileIOPermission union = (FileIOPermission) p.Union (p2);
string[] paths = union.GetPathList(FileIOPermissionAccess.Read);
- AssertEquals (msg + ".Length", expected, paths.Length);
- AssertEquals (msg + "[0]", path1[0], paths[0]);
+ Assert.AreEqual (expected, paths.Length, msg + ".Length");
+ Assert.AreEqual (path1[0], paths[0], msg + "[0]");
if (expected > 1)
- AssertEquals (msg + "[1]", path2[0], paths[1]);
- }\r
-\r
+ Assert.AreEqual (path2[0], paths[1], msg + "[1]");
+ }
+
[Test]
public void Union_Partial ()
{
Partial ("2", f2, f1, 2);
f1 = unix ? new string[] { "/dir/part/" } : new string[] { "c:\\dir\\part\\" };
- f2 = unix ? new string[] { "/dir/partial/" } : new string[] { "c:\\dir\\partial\\" };\r
- Partial ("3", f1, f2, 2);\r
+ f2 = unix ? new string[] { "/dir/partial/" } : new string[] { "c:\\dir\\partial\\" };
+ Partial ("3", f1, f2, 2);
Partial ("4", f2, f1, 2);
f1 = unix ? new string[] { "/dir/part/ial" } : new string[] { "c:\\dir\\part\\ial" };
- f2 = unix ? new string[] { "/dir/part/ial" } : new string[] { "c:\\dir\\part\\ial" };\r
+ f2 = unix ? new string[] { "/dir/part/ial" } : new string[] { "c:\\dir\\part\\ial" };
Partial ("5", f1, f2, 1);
Partial ("6", f2, f1, 1);
- }\r
-\r
- [Test]\r
- public void FromXML ()\r
- {\r
- p = new FileIOPermission(PermissionState.None);\r
- SecurityElement esd = new SecurityElement("IPermission");\r
- esd.AddAttribute("class", "FileIOPermission");\r
- esd.AddAttribute("version", "1");\r
- esd.AddAttribute("Unrestricted", "true");\r
- p.FromXml(esd);\r
- Assert("Should get an unrestricted permission", p.IsUnrestricted());\r
-\r
- esd = new SecurityElement("IPermission");\r
- esd.AddAttribute("class", "FileIOPermission");\r
- esd.AddAttribute("version", "1");\r
- // FIXME: Adjust to run on Mac OS's\r
- if (Path.VolumeSeparatorChar == ':') {\r
- esd.AddAttribute("Read", "c:\\temp;d:\\temp2");\r
- esd.AddAttribute("Write", "c:\\temp;d:\\temp2;z:\\temp3");\r
- }\r
- else {\r
- esd.AddAttribute("Read", "/temp;/usr/temp2");\r
- esd.AddAttribute("Write", "/temp;/usr/temp2;/usr/bin/temp3");\r
- }\r
- p = new FileIOPermission(PermissionState.None);\r
- p.FromXml(esd);\r
- pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);\r
- Assert("Path list should have 2 for Read", pathsInPermission.Length == 2);\r
- pathsInPermission = p.GetPathList(FileIOPermissionAccess.Write);\r
- Assert("Path list should have 2 for Write", pathsInPermission.Length == 3);\r
- }\r
-\r
- [Test]\r
- public void ToXML ()\r
- {\r
- p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);\r
- SecurityElement esd = p.ToXml();\r
- Assert("Esd tag incorrect", esd.Tag == "IPermission");\r
- Assert("Esd version incorrect", (String)esd.Attributes["version"] == "1");\r
- string read = (String)esd.Attributes["Read"];\r
- pathsInPermission = read.Split(';');\r
- Assert("Path list should have 2 for Read", pathsInPermission.Length == 2);\r
- }\r
-#if !TARGET_JVM\r
- [Test]\r
- [Ignore("should compatibility go that far ?")]\r
- public void ShortToLong () \r
- {\r
- // on windows this returns a "short" (8.3) path and filename\r
- string filename = Path.GetTempFileName ();\r
- p = new FileIOPermission(FileIOPermissionAccess.Read, filename);\r
- string[] files = p.GetPathList (FileIOPermissionAccess.Read);\r
- AssertEquals ("GetPathList.Count", 1, files.Length);\r
- // FIXME: here GetTempFileName != GetPathList[0] for MS but == for Mono\r
- AssertEquals ("Path.GetFileName(GetTempFileName)==Path.GetFileName(GetPathList[0])", Path.GetFileName (filename), Path.GetFileName (files [0]));\r
- // note: this will fail on Linux as kernel32.dll isn't available\r
- AssertEquals ("GetLongPathName(GetTempFileName)==GetPathList[0]", FilePathUtil.GetLongPathName (filename), files [0]);\r
+ }
+
+ [Test]
+ public void FromXML ()
+ {
+ p = new FileIOPermission(PermissionState.None);
+ SecurityElement esd = new SecurityElement("IPermission");
+ esd.AddAttribute("class", "FileIOPermission");
+ esd.AddAttribute("version", "1");
+ esd.AddAttribute("Unrestricted", "true");
+ p.FromXml(esd);
+ Assert.IsTrue(p.IsUnrestricted(), "Should get an unrestricted permission");
+
+ esd = new SecurityElement("IPermission");
+ esd.AddAttribute("class", "FileIOPermission");
+ esd.AddAttribute("version", "1");
+ // FIXME: Adjust to run on Mac OS's
+ if (Path.VolumeSeparatorChar == ':') {
+ esd.AddAttribute("Read", "c:\\temp;d:\\temp2");
+ esd.AddAttribute("Write", "c:\\temp;d:\\temp2;z:\\temp3");
+ }
+ else {
+ esd.AddAttribute("Read", "/temp;/usr/temp2");
+ esd.AddAttribute("Write", "/temp;/usr/temp2;/usr/bin/temp3");
+ }
+ p = new FileIOPermission(PermissionState.None);
+ p.FromXml(esd);
+ pathsInPermission = p.GetPathList(FileIOPermissionAccess.Read);
+ Assert.IsTrue(pathsInPermission.Length == 2, "Path list should have 2 for Read");
+ pathsInPermission = p.GetPathList(FileIOPermissionAccess.Write);
+ Assert.IsTrue(pathsInPermission.Length == 3, "Path list should have 2 for Write");
+ }
+
+ [Test]
+ public void ToXML ()
+ {
+ p = new FileIOPermission(FileIOPermissionAccess.Read, pathArrayGood);
+ SecurityElement esd = p.ToXml();
+ Assert.IsTrue(esd.Tag == "IPermission", "Esd tag incorrect");
+ Assert.IsTrue((String)esd.Attributes["version"] == "1", "Esd version incorrect");
+ string read = (String)esd.Attributes["Read"];
+ pathsInPermission = read.Split(';');
+ Assert.IsTrue(pathsInPermission.Length == 2, "Path list should have 2 for Read");
+ }
+#if !TARGET_JVM
+ [Test]
+ [Ignore("should compatibility go that far ?")]
+ public void ShortToLong ()
+ {
+ // on windows this returns a "short" (8.3) path and filename
+ string filename = Path.GetTempFileName ();
+ p = new FileIOPermission(FileIOPermissionAccess.Read, filename);
+ string[] files = p.GetPathList (FileIOPermissionAccess.Read);
+ Assert.AreEqual (1, files.Length, "GetPathList.Count");
+ // FIXME: here GetTempFileName != GetPathList[0] for MS but == for Mono
+ Assert.AreEqual (Path.GetFileName (filename), Path.GetFileName (files [0]), "Path.GetFileName(GetTempFileName)==Path.GetFileName(GetPathList[0])");
+ // note: this will fail on Linux as kernel32.dll isn't available
+ Assert.AreEqual (FilePathUtil.GetLongPathName (filename), files [0], "GetLongPathName(GetTempFileName)==GetPathList[0]");
}
#endif
- [Test]\r
- [ExpectedException (typeof (ArgumentException))]\r
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
public void FileUrl ()
{
// file://... isn't accepted
- string filename = Assembly.GetExecutingAssembly ().CodeBase;\r
- p = new FileIOPermission (FileIOPermissionAccess.Read, filename);\r
- }\r
- }\r
-}\r
+ string filename = Assembly.GetExecutingAssembly ().CodeBase;
+ p = new FileIOPermission (FileIOPermissionAccess.Read, filename);
+ }
+ }
+}
namespace MonoTests.System.Security.Permissions {
[TestFixture]
- public class PrincipalPermissionTest : Assertion {
+ public class PrincipalPermissionTest {
private static string className = "System.Security.Permissions.PrincipalPermission, ";
public void PermissionStateNone ()
{
PrincipalPermission p = new PrincipalPermission (PermissionState.None);
- AssertNotNull ("PrincipalPermission(PermissionState.None)", p);
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsNotNull (p, "PrincipalPermission(PermissionState.None)");
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
PrincipalPermission copy = (PrincipalPermission) p.Copy ();
- AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ());
+ Assert.AreEqual (p.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = p.ToXml ();
- Assert ("ToXml-class", (se.Attributes ["class"] as string).StartsWith (className));
- AssertEquals ("ToXml-version", "1", (se.Attributes ["version"] as string));
+ Assert.IsTrue ((se.Attributes ["class"] as string).StartsWith (className), "ToXml-class");
+ Assert.AreEqual ("1", (se.Attributes ["version"] as string), "ToXml-version");
}
[Test]
public void PermissionStateUnrestricted ()
{
PrincipalPermission p = new PrincipalPermission (PermissionState.Unrestricted);
- AssertNotNull ("PrincipalPermission(PermissionState.Unrestricted)", p);
- Assert ("IsUnrestricted", p.IsUnrestricted ());
+ Assert.IsNotNull (p, "PrincipalPermission(PermissionState.Unrestricted)");
+ Assert.IsTrue (p.IsUnrestricted (), "IsUnrestricted");
PrincipalPermission copy = (PrincipalPermission) p.Copy ();
- AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ());
+ Assert.AreEqual (p.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
// Note: Unrestricted isn't shown in XML
}
public void Name ()
{
PrincipalPermission p = new PrincipalPermission ("user", null);
- Assert("Name.IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue(!p.IsUnrestricted (), "Name.IsUnrestricted");
}
[Test]
public void UnauthenticatedName ()
{
PrincipalPermission p = new PrincipalPermission ("user", null, false);
- Assert("UnauthenticatedName.IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue(!p.IsUnrestricted (), "UnauthenticatedName.IsUnrestricted");
}
[Test]
public void Role ()
{
PrincipalPermission p = new PrincipalPermission (null, "users");
- Assert("Role.IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue(!p.IsUnrestricted (), "Role.IsUnrestricted");
}
[Test]
public void UnauthenticatedRole ()
{
PrincipalPermission p = new PrincipalPermission (null, "users", false);
- Assert("UnauthenticatedRole.IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue(!p.IsUnrestricted (), "UnauthenticatedRole.IsUnrestricted");
}
[Test]
public void NameRole ()
{
PrincipalPermission p = new PrincipalPermission ("user", "users", true);
- Assert("NameRole.IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue(!p.IsUnrestricted (), "NameRole.IsUnrestricted");
}
[Test]
public void UnauthenticatedNameRole ()
{
PrincipalPermission p = new PrincipalPermission ("user", "users", false);
- Assert("UnauthenticatedNameRole.IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue(!p.IsUnrestricted (), "UnauthenticatedNameRole.IsUnrestricted");
}
[Test]
public void AuthenticatedNullNull ()
{
PrincipalPermission p = new PrincipalPermission (null, null, true);
- Assert("UnauthenticatedNameRole.IsUnrestricted", p.IsUnrestricted ());
+ Assert.IsTrue(p.IsUnrestricted (), "UnauthenticatedNameRole.IsUnrestricted");
}
[Test]
{
PrincipalPermission p = new PrincipalPermission (PermissionState.None);
SecurityElement se = p.ToXml ();
- AssertNotNull ("ToXml()", se);
+ Assert.IsNotNull (se, "ToXml()");
PrincipalPermission p2 = (PrincipalPermission) p.Copy ();
p2.FromXml (se);
- AssertEquals ("FromXml-Copy", p.ToString (), p2.ToString ());
+ Assert.AreEqual (p.ToString (), p2.ToString (), "FromXml-Copy");
string className = (string) se.Attributes ["class"];
string version = (string) se.Attributes ["version"];
sec.AddAttribute ("Authenticated", "true");
se2.AddChild (sec);
p2.FromXml (se2);
- Assert ("FromXml-Unrestricted", p2.IsUnrestricted ());
+ Assert.IsTrue (p2.IsUnrestricted (), "FromXml-Unrestricted");
}
[Test]
PrincipalPermission p1 = new PrincipalPermission ("user", null);
PrincipalPermission p2 = null;
PrincipalPermission p3 = (PrincipalPermission) p1.Union (p2);
- AssertEquals ("P1 U null == P1", p1.ToXml ().ToString (), p3.ToXml ().ToString ());
+ Assert.AreEqual (p1.ToXml ().ToString (), p3.ToXml ().ToString (), "P1 U null == P1");
}
[Test]
PrincipalPermission p1 = new PrincipalPermission (PermissionState.Unrestricted);
PrincipalPermission p2 = new PrincipalPermission ("user", "role");
PrincipalPermission p3 = (PrincipalPermission) p1.Union (p2);
- Assert ("Unrestricted U P2 == Unrestricted", p3.IsUnrestricted ());
+ Assert.IsTrue (p3.IsUnrestricted (), "Unrestricted U P2 == Unrestricted");
p3 = (PrincipalPermission) p2.Union (p1);
- Assert ("P2 U Unrestricted == Unrestricted", p3.IsUnrestricted ());
+ Assert.IsTrue (p3.IsUnrestricted (), "P2 U Unrestricted == Unrestricted");
}
[Test]
PrincipalPermission p1 = new PrincipalPermission ("user A", "role A");
PrincipalPermission p2 = new PrincipalPermission ("user B", "role B", false);
PrincipalPermission p3 = (PrincipalPermission) p1.Union (p2);
- Assert ("Union.UserA", p3.ToString ().IndexOf ("user A") >= 0);
- Assert ("Union.UserB", p3.ToString ().IndexOf ("user B") >= 0);
+ Assert.IsTrue (p3.ToString ().IndexOf ("user A") >= 0, "Union.UserA");
+ Assert.IsTrue (p3.ToString ().IndexOf ("user B") >= 0, "Union.UserB");
}
[Test]
PrincipalPermission p1 = new PrincipalPermission ("user", "role");
PrincipalPermission p2 = null;
PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (p2);
- AssertNull ("P1 N null == null", p3);
+ Assert.IsNull (p3, "P1 N null == null");
}
[Test]
PrincipalPermission p1 = new PrincipalPermission (PermissionState.Unrestricted);
PrincipalPermission p2 = new PrincipalPermission ("user", "role");
PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (p2);
- Assert ("Unrestricted N P2 == P2", !p3.IsUnrestricted ());
- AssertEquals ("Unrestricted N EP2 == EP2", p2.ToXml ().ToString (), p3.ToXml ().ToString ());
+ Assert.IsTrue (!p3.IsUnrestricted (), "Unrestricted N P2 == P2");
+ Assert.AreEqual (p2.ToXml ().ToString (), p3.ToXml ().ToString (), "Unrestricted N EP2 == EP2");
p3 = (PrincipalPermission) p2.Intersect (p1);
- Assert ("P2 N Unrestricted == P2", !p3.IsUnrestricted ());
- AssertEquals ("P2 N Unrestricted == P2", p2.ToXml ().ToString (), p3.ToXml ().ToString ());
+ Assert.IsTrue (!p3.IsUnrestricted (), "P2 N Unrestricted == P2");
+ Assert.AreEqual (p2.ToXml ().ToString (), p3.ToXml ().ToString (), "P2 N Unrestricted == P2");
}
[Test]
PrincipalPermission p1 = new PrincipalPermission ("user A", "role 1");
PrincipalPermission p2 = new PrincipalPermission ("user B", "role 2");
PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (p2);
- AssertNull ("EP1 N EP2 == null", p3);
+ Assert.IsNull (p3, "EP1 N EP2 == null");
// intersection in role
PrincipalPermission p4 = new PrincipalPermission ("user C", "role 1");
p3 = (PrincipalPermission) p4.Intersect (p1);
- Assert ("Intersect (!user A)", p3.ToString ().IndexOf ("user A") < 0);
- Assert ("Intersect (!user C)", p3.ToString ().IndexOf ("user C") < 0);
- Assert ("Intersect (role 1)", p3.ToString ().IndexOf ("role 1") >= 0);
+ Assert.IsTrue (p3.ToString ().IndexOf ("user A") < 0, "Intersect (!user A)");
+ Assert.IsTrue (p3.ToString ().IndexOf ("user C") < 0, "Intersect (!user C)");
+ Assert.IsTrue (p3.ToString ().IndexOf ("role 1") >= 0, "Intersect (role 1)");
// intersection in role without authentication
PrincipalPermission p5 = new PrincipalPermission ("user C", "role 1", false);
p3 = (PrincipalPermission) p5.Intersect (p1);
- AssertNull ("EP5 N EP1 == null", p3);
+ Assert.IsNull (p3, "EP5 N EP1 == null");
}
[Test]
PrincipalPermission p1 = new PrincipalPermission ("user", "role");
PrincipalPermission p2 = new PrincipalPermission (null, "role");
PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (p2);
- AssertEquals ("p1 N p2 == p1", p1.ToString (), p3.ToString ());
+ Assert.AreEqual (p1.ToString (), p3.ToString (), "p1 N p2 == p1");
p3 = (PrincipalPermission) p2.Intersect (p1);
- AssertEquals ("p2 N p1 == p1", p1.ToString (), p3.ToString ());
+ Assert.AreEqual (p1.ToString (), p3.ToString (), "p2 N p1 == p1");
}
[Test]
PrincipalPermission p1 = new PrincipalPermission ("user", "role");
PrincipalPermission p2 = new PrincipalPermission ("user", null);
PrincipalPermission p3 = (PrincipalPermission) p1.Intersect (p2);
- AssertEquals ("p1 N p2 == p1", p1.ToString (), p3.ToString ());
+ Assert.AreEqual (p1.ToString (), p3.ToString (), "p1 N p2 == p1");
p3 = (PrincipalPermission) p2.Intersect (p1);
- AssertEquals ("p2 N p1 == p1", p1.ToString (), p3.ToString ());
+ Assert.AreEqual (p1.ToString (), p3.ToString (), "p2 N p1 == p1");
}
[Test]
public void IsSubsetOfNull ()
{
PrincipalPermission p = new PrincipalPermission ("user", null);
- Assert ("User.IsSubsetOf(null)", !p.IsSubsetOf (null));\r
-\r
- p = new PrincipalPermission (PermissionState.None);\r
- Assert ("None.IsSubsetOf(null)", p.IsSubsetOf (null));\r
-\r
- p = new PrincipalPermission (PermissionState.Unrestricted);\r
- Assert ("Unrestricted.IsSubsetOf(null)", !p.IsSubsetOf (null));\r
- }\r
-\r
- [Test]\r
- public void IsSubsetOfNone ()\r
- {\r
- PrincipalPermission none = new PrincipalPermission (PermissionState.None);\r
- PrincipalPermission p = new PrincipalPermission ("user", null);\r
- Assert ("User.IsSubsetOf(null)", !p.IsSubsetOf (none));\r
-\r
- p = new PrincipalPermission (PermissionState.None);\r
- Assert ("None.IsSubsetOf(null)", p.IsSubsetOf (none));\r
-\r
- p = new PrincipalPermission (PermissionState.Unrestricted);\r
- Assert ("Unrestricted.IsSubsetOf(null)", !p.IsSubsetOf (none));\r
+ Assert.IsTrue (!p.IsSubsetOf (null), "User.IsSubsetOf(null)");
+
+ p = new PrincipalPermission (PermissionState.None);
+ Assert.IsTrue (p.IsSubsetOf (null), "None.IsSubsetOf(null)");
+
+ p = new PrincipalPermission (PermissionState.Unrestricted);
+ Assert.IsTrue (!p.IsSubsetOf (null), "Unrestricted.IsSubsetOf(null)");
+ }
+
+ [Test]
+ public void IsSubsetOfNone ()
+ {
+ PrincipalPermission none = new PrincipalPermission (PermissionState.None);
+ PrincipalPermission p = new PrincipalPermission ("user", null);
+ Assert.IsTrue (!p.IsSubsetOf (none), "User.IsSubsetOf(null)");
+
+ p = new PrincipalPermission (PermissionState.None);
+ Assert.IsTrue (p.IsSubsetOf (none), "None.IsSubsetOf(null)");
+
+ p = new PrincipalPermission (PermissionState.Unrestricted);
+ Assert.IsTrue (!p.IsSubsetOf (none), "Unrestricted.IsSubsetOf(null)");
}
[Test]
{
PrincipalPermission p1 = new PrincipalPermission (PermissionState.Unrestricted);
PrincipalPermission p2 = new PrincipalPermission ("user", "role", false);
- Assert ("Unrestricted.IsSubsetOf(user)", !p1.IsSubsetOf (p2));
- Assert ("user.IsSubsetOf(Unrestricted)", p2.IsSubsetOf (p1));
+ Assert.IsTrue (!p1.IsSubsetOf (p2), "Unrestricted.IsSubsetOf(user)");
+ Assert.IsTrue (p2.IsSubsetOf (p1), "user.IsSubsetOf(Unrestricted)");
}
[Test]
{
PrincipalPermission p1 = new PrincipalPermission ("user A", "role 1");
PrincipalPermission p2 = new PrincipalPermission (null, "role 1");
- Assert ("UserRole.IsSubsetOf(Role)", p1.IsSubsetOf (p2));
- Assert ("Role.IsSubsetOf(UserRole)", !p2.IsSubsetOf (p1));
+ Assert.IsTrue (p1.IsSubsetOf (p2), "UserRole.IsSubsetOf(Role)");
+ Assert.IsTrue (!p2.IsSubsetOf (p1), "Role.IsSubsetOf(UserRole)");
PrincipalPermission p3 = new PrincipalPermission ("user A", "role 1", false);
- Assert ("UserRoleAuth.IsSubsetOf(UserRoleNA)", !p3.IsSubsetOf (p1));
- Assert ("UserRoleNA.IsSubsetOf(UserRoleAuth)", !p1.IsSubsetOf (p3));
+ Assert.IsTrue (!p3.IsSubsetOf (p1), "UserRoleAuth.IsSubsetOf(UserRoleNA)");
+ Assert.IsTrue (!p1.IsSubsetOf (p3), "UserRoleNA.IsSubsetOf(UserRoleAuth)");
PrincipalPermission p4 = new PrincipalPermission (null, null, true); // unrestricted
- Assert ("unrestricted.IsSubsetOf(UserRole)", !p4.IsSubsetOf (p1));
- Assert ("UserRole.IsSubsetOf(unrestricted)", p1.IsSubsetOf (p4));
+ Assert.IsTrue (!p4.IsSubsetOf (p1), "unrestricted.IsSubsetOf(UserRole)");
+ Assert.IsTrue (p1.IsSubsetOf (p4), "UserRole.IsSubsetOf(unrestricted)");
}
[Test]
{
PrincipalPermission p1 = new PrincipalPermission ("user", null);
EnvironmentPermission ep2 = new EnvironmentPermission (PermissionState.Unrestricted);
- Assert ("IsSubsetOf(EnvironmentPermission)", p1.IsSubsetOf (ep2));
+ Assert.IsTrue (p1.IsSubsetOf (ep2), "IsSubsetOf(EnvironmentPermission)");
}
}
}
namespace MonoTests.System.Security.Permissions {
[TestFixture]
- public class PublisherIdentityPermissionTest : Assertion {
+ public class PublisherIdentityPermissionTest {
private static string className = "System.Security.Permissions.PublisherIdentityPermission, ";
public void PermissionStateNone ()
{
PublisherIdentityPermission p = new PublisherIdentityPermission (PermissionState.None);
- AssertNotNull ("PublisherIdentityPermission(PermissionState.None)", p);
+ Assert.IsNotNull (p, "PublisherIdentityPermission(PermissionState.None)");
PublisherIdentityPermission copy = (PublisherIdentityPermission) p.Copy ();
SecurityElement se = p.ToXml ();
- Assert ("ToXml-class", se.Attribute ("class").StartsWith (className));
- AssertEquals ("ToXml-version", "1", se.Attribute("version"));
- AssertNull ("ToXml-Unrestricted", se.Attribute("Unrestricted"));
- AssertNull ("Certificate==null", p.Certificate);
+ Assert.IsTrue (se.Attribute ("class").StartsWith (className), "ToXml-class");
+ Assert.AreEqual ("1", se.Attribute("version"), "ToXml-version");
+ Assert.IsNull (se.Attribute("Unrestricted"), "ToXml-Unrestricted");
+ Assert.IsNull (p.Certificate, "Certificate==null");
}
#if NET_2_0
[Test]
{
// In 2.0 Unrestricted are permitted for identity permissions
PublisherIdentityPermission p = new PublisherIdentityPermission (PermissionState.Unrestricted);
- AssertNotNull ("PublisherIdentityPermission(PermissionState.None)", p);
+ Assert.IsNotNull (p, "PublisherIdentityPermission(PermissionState.None)");
PublisherIdentityPermission copy = (PublisherIdentityPermission)p.Copy ();
SecurityElement se = p.ToXml ();
- Assert ("ToXml-class", se.Attribute ("class").StartsWith (className));
- AssertEquals ("ToXml-version", "1", se.Attribute("version"));
- AssertEquals ("ToXml-Unrestricted", "true", se.Attribute("Unrestricted"));
- AssertNull ("Certificate==null", p.Certificate);
+ Assert.IsTrue (se.Attribute ("class").StartsWith (className), "ToXml-class");
+ Assert.AreEqual ("1", se.Attribute("version"), "ToXml-version");
+ Assert.AreEqual ("true", se.Attribute("Unrestricted"), "ToXml-Unrestricted");
+ Assert.IsNull (p.Certificate, "Certificate==null");
// and they aren't equals to None
- Assert (!p.Equals (new PublisherIdentityPermission (PermissionState.None)));
+ Assert.IsTrue (!p.Equals (new PublisherIdentityPermission (PermissionState.None)));
}
#else
[Test]
PublisherIdentityPermission p2 = new PublisherIdentityPermission (PermissionState.None);
p2.Certificate = x509;
- AssertEquals ("Certificate", p1.ToXml ().ToString (), p2.ToXml ().ToString ());
+ Assert.AreEqual (p1.ToXml ().ToString (), p2.ToXml ().ToString (), "Certificate");
}
[Test]
{
PublisherIdentityPermission p = new PublisherIdentityPermission (PermissionState.None);
SecurityElement se = p.ToXml ();
- AssertNotNull ("ToXml()", se);
+ Assert.IsNotNull (se, "ToXml()");
p.FromXml (se);
se.AddAttribute ("X509v3Certificate", x509.GetRawCertDataString ());
p.FromXml (se);
- AssertEquals ("CertificateHash", x509.GetCertHashString (), p.Certificate.GetCertHashString ());
+ Assert.AreEqual (x509.GetCertHashString (), p.Certificate.GetCertHashString (), "CertificateHash");
}
[Test]
PublisherIdentityPermission p1 = new PublisherIdentityPermission (x509);
PublisherIdentityPermission p2 = null;
PublisherIdentityPermission p3 = (PublisherIdentityPermission) p1.Union (p2);
- AssertEquals ("P1 U null == P1", p1.ToXml ().ToString (), p3.ToXml ().ToString ());
+ Assert.AreEqual (p1.ToXml ().ToString (), p3.ToXml ().ToString (), "P1 U null == P1");
}
[Test]
PublisherIdentityPermission p1 = new PublisherIdentityPermission (PermissionState.None);
PublisherIdentityPermission p2 = new PublisherIdentityPermission (PermissionState.None);
PublisherIdentityPermission p3 = (PublisherIdentityPermission) p1.Union (p2);
- AssertNull ("None U None == null", p3);
+ Assert.IsNull (p3, "None U None == null");
// with 1 certificate
p1 = new PublisherIdentityPermission (x509);
p2 = new PublisherIdentityPermission (PermissionState.None);
p3 = (PublisherIdentityPermission) p1.Union (p2);
- AssertEquals ("cert U None == cert", p3.ToXml ().ToString (), p1.ToXml ().ToString ());
+ Assert.AreEqual (p3.ToXml ().ToString (), p1.ToXml ().ToString (), "cert U None == cert");
X509Certificate x2 = new X509Certificate (cert2);
// 2 certificates (same)
x2 = new X509Certificate (cert);
p2 = new PublisherIdentityPermission (x2);
p3 = (PublisherIdentityPermission) p1.Union (p2);
- AssertEquals ("cert1 U cert1 == cert1", p3.ToString (), p1.ToString ());
+ Assert.AreEqual (p3.ToString (), p1.ToString (), "cert1 U cert1 == cert1");
}
[Test]
#if NET_2_0
// new XML format is used to contain more than one X.509 certificate
SecurityElement se = p.ToXml ();
- AssertEquals ("Childs", 2, se.Children.Count);
- AssertEquals ("Cert#1", (se.Children [0] as SecurityElement).Attribute ("X509v3Certificate"), p1.ToXml ().Attribute ("X509v3Certificate"));
- AssertEquals ("Cert#2", (se.Children [1] as SecurityElement).Attribute ("X509v3Certificate"), p2.ToXml ().Attribute ("X509v3Certificate"));
+ Assert.AreEqual (2, se.Children.Count, "Childs");
+ Assert.AreEqual ((se.Children [0] as SecurityElement).Attribute ("X509v3Certificate"), p1.ToXml ().Attribute ("X509v3Certificate"), "Cert#1");
+ Assert.AreEqual ((se.Children [1] as SecurityElement).Attribute ("X509v3Certificate"), p2.ToXml ().Attribute ("X509v3Certificate"), "Cert#2");
// strangely it is still versioned as 'version="1"'.
- AssertEquals ("Version", "1", se.Attribute ("version"));
+ Assert.AreEqual ("1", se.Attribute ("version"), "Version");
#else
- AssertNull ("cert1 U cert2 == null", p);
+ Assert.IsNull (p, "cert1 U cert2 == null");
#endif
}
PublisherIdentityPermission p1 = new PublisherIdentityPermission (x509);
PublisherIdentityPermission p2 = null;
PublisherIdentityPermission p3 = (PublisherIdentityPermission) p1.Intersect (p2);
- AssertNull ("P1 N null == null", p3);
+ Assert.IsNull (p3, "P1 N null == null");
}
[Test]
PublisherIdentityPermission p1 = new PublisherIdentityPermission (PermissionState.None);
PublisherIdentityPermission p2 = new PublisherIdentityPermission (PermissionState.None);
PublisherIdentityPermission p3 = (PublisherIdentityPermission) p1.Intersect (p2);
- AssertNull ("None N None == null", p3);
+ Assert.IsNull (p3, "None N None == null");
// with 1 certificate
p1 = new PublisherIdentityPermission (x509);
p2 = new PublisherIdentityPermission (PermissionState.None);
p3 = (PublisherIdentityPermission) p1.Intersect (p2);
- AssertNull ("cert N None == None", p3);
+ Assert.IsNull (p3, "cert N None == None");
// 2 different certificates
X509Certificate x2 = new X509Certificate (cert2);
p2 = new PublisherIdentityPermission (x2);
p3 = (PublisherIdentityPermission) p1.Intersect (p2);
- AssertNull ("cert1 N cert2 == null", p3);
+ Assert.IsNull (p3, "cert1 N cert2 == null");
// 2 certificates (same)
x2 = new X509Certificate (cert);
p2 = new PublisherIdentityPermission (x2);
p3 = (PublisherIdentityPermission) p1.Intersect (p2);
- AssertEquals ("cert1 N cert1 == cert1", p3.ToString (), p1.ToString ());
+ Assert.AreEqual (p3.ToString (), p1.ToString (), "cert1 N cert1 == cert1");
}
[Test]
public void IsSubsetOfNull ()
{
PublisherIdentityPermission p1 = new PublisherIdentityPermission (x509);
- Assert ("IsSubsetOf(null)", !p1.IsSubsetOf (null));
+ Assert.IsTrue (!p1.IsSubsetOf (null), "IsSubsetOf(null)");
}
[Test]
{
PublisherIdentityPermission p1 = new PublisherIdentityPermission (PermissionState.None);
PublisherIdentityPermission p2 = new PublisherIdentityPermission (PermissionState.None);
- Assert ("None.IsSubsetOf(None)", p1.IsSubsetOf (p2));
+ Assert.IsTrue (p1.IsSubsetOf (p2), "None.IsSubsetOf(None)");
PublisherIdentityPermission p3 = new PublisherIdentityPermission (x509);
- Assert ("Cert.IsSubsetOf(None)", !p3.IsSubsetOf (p2));
- Assert ("None.IsSubsetOf(Cert)", p2.IsSubsetOf (p3));
+ Assert.IsTrue (!p3.IsSubsetOf (p2), "Cert.IsSubsetOf(None)");
+ Assert.IsTrue (p2.IsSubsetOf (p3), "None.IsSubsetOf(Cert)");
PublisherIdentityPermission p4 = new PublisherIdentityPermission (x509);
- Assert ("Cert.IsSubsetOf(Cert)", p3.IsSubsetOf (p4));
+ Assert.IsTrue (p3.IsSubsetOf (p4), "Cert.IsSubsetOf(Cert)");
X509Certificate x2 = new X509Certificate (cert2);
PublisherIdentityPermission p5 = new PublisherIdentityPermission (x2);
- Assert ("Cert2.IsSubsetOf(Cert)", !p5.IsSubsetOf (p3));
- Assert ("Cert.IsSubsetOf(Cert2)", !p3.IsSubsetOf (p5));
+ Assert.IsTrue (!p5.IsSubsetOf (p3), "Cert2.IsSubsetOf(Cert)");
+ Assert.IsTrue (!p3.IsSubsetOf (p5), "Cert.IsSubsetOf(Cert2)");
}
[Test]
{
PublisherIdentityPermission p1 = new PublisherIdentityPermission (x509);
FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
- Assert ("IsSubsetOf(PublisherIdentityPermission)", p1.IsSubsetOf (fdp2));
+ Assert.IsTrue (p1.IsSubsetOf (fdp2), "IsSubsetOf(PublisherIdentityPermission)");
}
}
}
namespace MonoTests.System.Security.Permissions {
[TestFixture]
- public class ReflectionPermissionTest : Assertion {
+ public class ReflectionPermissionTest {
private static string className = "System.Security.Permissions.ReflectionPermission, ";
[Test]
- public void PermissionStateNone ()
+ public void PermissionStateNone ()
{
ReflectionPermission p = new ReflectionPermission (PermissionState.None);
- AssertNotNull ("ReflectionPermission(PermissionState.None)", p);
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsNotNull (p, "ReflectionPermission(PermissionState.None)");
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
ReflectionPermission copy = (ReflectionPermission) p.Copy ();
- AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ());
+ Assert.AreEqual (p.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = p.ToXml ();
- Assert ("ToXml-class", (se.Attributes ["class"] as string).StartsWith (className));
- AssertEquals ("ToXml-version", "1", (se.Attributes ["version"] as string));
+ Assert.IsTrue ((se.Attributes ["class"] as string).StartsWith (className), "ToXml-class");
+ Assert.AreEqual ("1", (se.Attributes ["version"] as string), "ToXml-version");
}
[Test]
public void PermissionStateUnrestricted ()
{
ReflectionPermission p = new ReflectionPermission (PermissionState.Unrestricted);
- AssertNotNull ("ReflectionPermission(PermissionState.Unrestricted)", p);
- Assert ("IsUnrestricted", p.IsUnrestricted ());
+ Assert.IsNotNull (p, "ReflectionPermission(PermissionState.Unrestricted)");
+ Assert.IsTrue (p.IsUnrestricted (), "IsUnrestricted");
ReflectionPermission copy = (ReflectionPermission) p.Copy ();
- AssertEquals ("Copy.IsUnrestricted", p.IsUnrestricted (), copy.IsUnrestricted ());
+ Assert.AreEqual (p.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertEquals ("ToXml-Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
+ Assert.AreEqual ("true", (se.Attributes ["Unrestricted"] as string), "ToXml-Unrestricted");
}
[Test]
public void Derestricted ()
{
ReflectionPermission p = new ReflectionPermission (PermissionState.Unrestricted);
- Assert ("IsUnrestricted", p.IsUnrestricted ());
+ Assert.IsTrue (p.IsUnrestricted (), "IsUnrestricted");
p.Flags = ReflectionPermissionFlag.NoFlags;
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
}
[Test]
public void NoFlags ()
{
ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertEquals ("ToXml-Flags=NoFlags", "NoFlags", (se.Attributes ["Flags"] as string));
+ Assert.AreEqual ("NoFlags", (se.Attributes ["Flags"] as string), "ToXml-Flags=NoFlags");
}
[Test]
public void TypeInformation ()
{
ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation);
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertEquals ("ToXml-Flags=TypeInformation", "TypeInformation", (se.Attributes ["Flags"] as string));
+ Assert.AreEqual ("TypeInformation", (se.Attributes ["Flags"] as string), "ToXml-Flags=TypeInformation");
}
[Test]
public void MemberAccess ()
{
ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertEquals ("ToXml-Flags=MemberAccess", "MemberAccess", (se.Attributes ["Flags"] as string));
+ Assert.AreEqual ("MemberAccess", (se.Attributes ["Flags"] as string), "ToXml-Flags=MemberAccess");
}
[Test]
public void ReflectionEmit ()
{
ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.ReflectionEmit);
- Assert ("IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertEquals ("ToXml-Flags=ReflectionEmit", "ReflectionEmit", (se.Attributes ["Flags"] as string));
+ Assert.AreEqual ("ReflectionEmit", (se.Attributes ["Flags"] as string), "ToXml-Flags=ReflectionEmit");
}
[Test]
public void AllFlags ()
{
ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.AllFlags);
- Assert ("IsUnrestricted", p.IsUnrestricted ());
+ Assert.IsTrue (p.IsUnrestricted (), "IsUnrestricted");
SecurityElement se = p.ToXml ();
- AssertEquals ("ToXml-Unrestricted", "true", (se.Attributes ["Unrestricted"] as string));
+ Assert.AreEqual ("true", (se.Attributes ["Unrestricted"] as string), "ToXml-Unrestricted");
}
[Test]
public void Flags ()
{
ReflectionPermission p = new ReflectionPermission (PermissionState.None);
- Assert ("Flags(default).IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "Flags(default).IsUnrestricted");
p.Flags = ReflectionPermissionFlag.NoFlags;
- Assert ("Flags(NoFlags).IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "Flags(NoFlags).IsUnrestricted");
p.Flags = ReflectionPermissionFlag.TypeInformation;
- Assert ("Flags(TypeInformation).IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "Flags(TypeInformation).IsUnrestricted");
p.Flags = ReflectionPermissionFlag.MemberAccess;
- Assert ("Flags(MemberAccess).IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "Flags(MemberAccess).IsUnrestricted");
p.Flags = ReflectionPermissionFlag.ReflectionEmit;
- Assert ("Flags(ReflectionEmit).IsUnrestricted", !p.IsUnrestricted ());
+ Assert.IsTrue (!p.IsUnrestricted (), "Flags(ReflectionEmit).IsUnrestricted");
p.Flags = ReflectionPermissionFlag.AllFlags;
- Assert ("Flags(AllFlags).IsUnrestricted", p.IsUnrestricted ());
+ Assert.IsTrue (p.IsUnrestricted (), "Flags(AllFlags).IsUnrestricted");
}
[Test]
{
ReflectionPermission p = new ReflectionPermission (PermissionState.None);
SecurityElement se = p.ToXml ();
- AssertNotNull ("ToXml()", se);
+ Assert.IsNotNull (se, "ToXml()");
ReflectionPermission p2 = (ReflectionPermission) p.Copy ();
p2.FromXml (se);
- AssertEquals ("FromXml-None", ReflectionPermissionFlag.NoFlags, p2.Flags);
+ Assert.AreEqual (ReflectionPermissionFlag.NoFlags, p2.Flags, "FromXml-None");
string className = (string) se.Attributes ["class"];
string version = (string) se.Attributes ["version"];
se2.AddAttribute ("version", version);
se2.AddAttribute ("Flags", "TypeInformation");
p2.FromXml (se2);
- AssertEquals ("FromXml-TypeInformation", ReflectionPermissionFlag.TypeInformation, p2.Flags);
+ Assert.AreEqual (ReflectionPermissionFlag.TypeInformation, p2.Flags, "FromXml-TypeInformation");
se2 = new SecurityElement (se.Tag);
se2.AddAttribute ("class", className);
se2.AddAttribute ("version", version);
se2.AddAttribute ("Flags", "MemberAccess");
p2.FromXml (se2);
- AssertEquals ("FromXml-MemberAccess", ReflectionPermissionFlag.MemberAccess, p2.Flags);
+ Assert.AreEqual (ReflectionPermissionFlag.MemberAccess, p2.Flags, "FromXml-MemberAccess");
se2 = new SecurityElement (se.Tag);
se2.AddAttribute ("class", className);
se2.AddAttribute ("version", version);
se2.AddAttribute ("Flags", "ReflectionEmit");
p2.FromXml (se2);
- AssertEquals ("FromXml-ReflectionEmit", ReflectionPermissionFlag.ReflectionEmit, p2.Flags);
+ Assert.AreEqual (ReflectionPermissionFlag.ReflectionEmit, p2.Flags, "FromXml-ReflectionEmit");
se = p.ToXml ();
se.AddAttribute ("Unrestricted", "true");
p2.FromXml (se);
- Assert ("FromXml-Unrestricted", p2.IsUnrestricted ());
- AssertEquals ("FromXml-AllFlags", ReflectionPermissionFlag.AllFlags, p2.Flags);
+ Assert.IsTrue (p2.IsUnrestricted (), "FromXml-Unrestricted");
+ Assert.AreEqual (ReflectionPermissionFlag.AllFlags, p2.Flags, "FromXml-AllFlags");
}
[Test]
ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
ReflectionPermission p2 = null;
ReflectionPermission p3 = (ReflectionPermission) p1.Union (p2);
- AssertEquals ("P1 U null == P1", p1.ToXml ().ToString (), p3.ToXml ().ToString ());
+ Assert.AreEqual (p1.ToXml ().ToString (), p3.ToXml ().ToString (), "P1 U null == P1");
}
[Test]
ReflectionPermission p1 = new ReflectionPermission (PermissionState.Unrestricted);
ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
ReflectionPermission p3 = (ReflectionPermission) p1.Union (p2);
- Assert ("Unrestricted U P2 == Unrestricted", p3.IsUnrestricted ());
+ Assert.IsTrue (p3.IsUnrestricted (), "Unrestricted U P2 == Unrestricted");
p3 = (ReflectionPermission) p2.Union (p1);
- Assert ("P2 U Unrestricted == Unrestricted", p3.IsUnrestricted ());
+ Assert.IsTrue (p3.IsUnrestricted (), "P2 U Unrestricted == Unrestricted");
}
[Test]
ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation);
ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
ReflectionPermission p3 = (ReflectionPermission) p1.Union (p2);
- AssertEquals (ReflectionPermissionFlag.MemberAccess | ReflectionPermissionFlag.TypeInformation, p3.Flags);
+ Assert.AreEqual (ReflectionPermissionFlag.MemberAccess | ReflectionPermissionFlag.TypeInformation, p3.Flags);
ReflectionPermission p4 = new ReflectionPermission (ReflectionPermissionFlag.ReflectionEmit);
ReflectionPermission p5 = (ReflectionPermission) p4.Union (p3);
- Assert ("P3 U P4==Unrestricted", p5.IsUnrestricted ());
+ Assert.IsTrue (p5.IsUnrestricted (), "P3 U P4==Unrestricted");
}
[Test]
ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
ReflectionPermission p2 = null;
ReflectionPermission p3 = (ReflectionPermission) p1.Intersect (p2);
- AssertNull ("P1 N null == null", p3);
+ Assert.IsNull (p3, "P1 N null == null");
}
[Test]
ReflectionPermission p1 = new ReflectionPermission (PermissionState.Unrestricted);
ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
ReflectionPermission p3 = (ReflectionPermission) p1.Intersect (p2);
- Assert ("Unrestricted N P2 == P2", !p3.IsUnrestricted ());
- AssertEquals ("Unrestricted N EP2 == EP2", p2.ToXml ().ToString (), p3.ToXml ().ToString ());
+ Assert.IsTrue (!p3.IsUnrestricted (), "Unrestricted N P2 == P2");
+ Assert.AreEqual (p2.ToXml ().ToString (), p3.ToXml ().ToString (), "Unrestricted N EP2 == EP2");
p3 = (ReflectionPermission) p2.Intersect (p1);
- Assert ("P2 N Unrestricted == P2", !p3.IsUnrestricted ());
- AssertEquals ("P2 N Unrestricted == P2", p2.ToXml ().ToString (), p3.ToXml ().ToString ());
+ Assert.IsTrue (!p3.IsUnrestricted (), "P2 N Unrestricted == P2");
+ Assert.AreEqual (p2.ToXml ().ToString (), p3.ToXml ().ToString (), "P2 N Unrestricted == P2");
p2 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
p3 = (ReflectionPermission) p1.Intersect (p2);
- AssertNull ("Unrestricted N None == null", p3);
+ Assert.IsNull (p3, "Unrestricted N None == null");
}
[Test]
ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation);
ReflectionPermission p3 = (ReflectionPermission) p1.Intersect (p2);
- AssertNull ("EP1 N EP2 == null", p3);
+ Assert.IsNull (p3, "EP1 N EP2 == null");
// intersection in MemberAccess
ReflectionPermission p4 = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess | ReflectionPermissionFlag.ReflectionEmit);
p3 = (ReflectionPermission) p4.Intersect (p1);
- AssertEquals ("Intersect-MemberAccess", ReflectionPermissionFlag.MemberAccess, p3.Flags);
+ Assert.AreEqual (ReflectionPermissionFlag.MemberAccess, p3.Flags, "Intersect-MemberAccess");
// intersection in TypeInformation
ReflectionPermission p5 = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation | ReflectionPermissionFlag.ReflectionEmit);
p3 = (ReflectionPermission) p5.Intersect (p2);
- AssertEquals ("Intersect-TypeInformation", ReflectionPermissionFlag.TypeInformation, p3.Flags);
+ Assert.AreEqual (ReflectionPermissionFlag.TypeInformation, p3.Flags, "Intersect-TypeInformation");
// intersection in AllFlags
ReflectionPermission p6 = new ReflectionPermission (ReflectionPermissionFlag.AllFlags);
ReflectionPermission p7 = new ReflectionPermission (ReflectionPermissionFlag.AllFlags);
p3 = (ReflectionPermission) p6.Intersect (p7);
- AssertEquals ("Intersect-AllFlags", ReflectionPermissionFlag.AllFlags, p3.Flags);
- Assert ("Intersect-AllFlags-Unrestricted", p3.IsUnrestricted ());
+ Assert.AreEqual (ReflectionPermissionFlag.AllFlags, p3.Flags, "Intersect-AllFlags");
+ Assert.IsTrue (p3.IsUnrestricted (), "Intersect-AllFlags-Unrestricted");
}
[Test]
public void IsSubsetOfNull ()
{
ReflectionPermission p = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
- Assert ("NoFlags.IsSubsetOf(null)", p.IsSubsetOf (null));
+ Assert.IsTrue (p.IsSubsetOf (null), "NoFlags.IsSubsetOf(null)");
p = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
- Assert ("MemberAccess.IsSubsetOf(null)", !p.IsSubsetOf (null));
+ Assert.IsTrue (!p.IsSubsetOf (null), "MemberAccess.IsSubsetOf(null)");
}
[Test]
ReflectionPermission p1 = new ReflectionPermission (PermissionState.Unrestricted);
ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
ReflectionPermission p3 = new ReflectionPermission (PermissionState.Unrestricted);
- Assert ("Unrestricted.IsSubsetOf()", !p1.IsSubsetOf (p2));
- Assert ("IsSubsetOf(Unrestricted)", p2.IsSubsetOf (p1));
- Assert ("Unrestricted.IsSubsetOf(Unrestricted)", p1.IsSubsetOf (p3));
+ Assert.IsTrue (!p1.IsSubsetOf (p2), "Unrestricted.IsSubsetOf()");
+ Assert.IsTrue (p2.IsSubsetOf (p1), "IsSubsetOf(Unrestricted)");
+ Assert.IsTrue (p1.IsSubsetOf (p3), "Unrestricted.IsSubsetOf(Unrestricted)");
}
[Test]
ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.MemberAccess);
ReflectionPermission p2 = new ReflectionPermission (ReflectionPermissionFlag.TypeInformation);
ReflectionPermission p3 = new ReflectionPermission (ReflectionPermissionFlag.ReflectionEmit);
- Assert ("MemberAccess.IsSubsetOf(TypeInformation)", !p1.IsSubsetOf (p2));
- Assert ("MemberAccess.IsSubsetOf(ReflectionEmit)", !p1.IsSubsetOf (p3));
- Assert ("TypeInformation.IsSubsetOf(MemberAccess)", !p2.IsSubsetOf (p1));
- Assert ("TypeInformation.IsSubsetOf(ReflectionEmit)", !p2.IsSubsetOf (p3));
- Assert ("ReflectionEmit.IsSubsetOf(MemberAccess)", !p3.IsSubsetOf (p1));
- Assert ("ReflectionEmit.IsSubsetOf(TypeInformation)", !p3.IsSubsetOf (p2));
+ Assert.IsTrue (!p1.IsSubsetOf (p2), "MemberAccess.IsSubsetOf(TypeInformation)");
+ Assert.IsTrue (!p1.IsSubsetOf (p3), "MemberAccess.IsSubsetOf(ReflectionEmit)");
+ Assert.IsTrue (!p2.IsSubsetOf (p1), "TypeInformation.IsSubsetOf(MemberAccess)");
+ Assert.IsTrue (!p2.IsSubsetOf (p3), "TypeInformation.IsSubsetOf(ReflectionEmit)");
+ Assert.IsTrue (!p3.IsSubsetOf (p1), "ReflectionEmit.IsSubsetOf(MemberAccess)");
+ Assert.IsTrue (!p3.IsSubsetOf (p2), "ReflectionEmit.IsSubsetOf(TypeInformation)");
ReflectionPermission p4 = new ReflectionPermission (ReflectionPermissionFlag.AllFlags);
- Assert ("MemberAccess.IsSubsetOf(AllFlags)", p1.IsSubsetOf (p4));
- Assert ("TypeInformation.IsSubsetOf(AllFlags)", p2.IsSubsetOf (p4));
- Assert ("ReflectionEmit.IsSubsetOf(AllFlags)", p3.IsSubsetOf (p4));
- Assert ("AllFlags.IsSubsetOf(MemberAccess)", !p4.IsSubsetOf (p1));
- Assert ("AllFlags.IsSubsetOf(TypeInformation)", !p4.IsSubsetOf (p2));
- Assert ("AllFlags.IsSubsetOf(ReflectionEmit)", !p4.IsSubsetOf (p3));
+ Assert.IsTrue (p1.IsSubsetOf (p4), "MemberAccess.IsSubsetOf(AllFlags)");
+ Assert.IsTrue (p2.IsSubsetOf (p4), "TypeInformation.IsSubsetOf(AllFlags)");
+ Assert.IsTrue (p3.IsSubsetOf (p4), "ReflectionEmit.IsSubsetOf(AllFlags)");
+ Assert.IsTrue (!p4.IsSubsetOf (p1), "AllFlags.IsSubsetOf(MemberAccess)");
+ Assert.IsTrue (!p4.IsSubsetOf (p2), "AllFlags.IsSubsetOf(TypeInformation)");
+ Assert.IsTrue (!p4.IsSubsetOf (p3), "AllFlags.IsSubsetOf(ReflectionEmit)");
}
[Test]
{
ReflectionPermission p1 = new ReflectionPermission (ReflectionPermissionFlag.NoFlags);
EnvironmentPermission ep2 = new EnvironmentPermission (PermissionState.Unrestricted);
- Assert ("IsSubsetOf(EnvironmentPermission)", p1.IsSubsetOf (ep2));
+ Assert.IsTrue (p1.IsSubsetOf (ep2), "IsSubsetOf(EnvironmentPermission)");
}
}
}
namespace MonoTests.System.Security.Permissions {
[TestFixture]
- public class RegistryPermissionTest : Assertion {
+ public class RegistryPermissionTest {
private static string className = "System.Security.Permissions.RegistryPermission, ";
private static string keyCurrentUser = @"HKEY_CURRENT_USER\Software\Novell iFolder\spouliot\Home";
public void PermissionStateNone ()
{
RegistryPermission ep = new RegistryPermission (PermissionState.None);
- AssertNotNull ("RegistryPermission(PermissionState.None)", ep);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsNotNull (ep, "RegistryPermission(PermissionState.None)");
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
RegistryPermission copy = (RegistryPermission)ep.Copy ();
- AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
+ Assert.AreEqual (ep.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = ep.ToXml ();
- Assert ("ToXml-class", se.Attribute ("class").StartsWith (className));
- AssertEquals ("ToXml-version", "1", se.Attribute ("version"));
+ Assert.IsTrue (se.Attribute ("class").StartsWith (className), "ToXml-class");
+ Assert.AreEqual ("1", se.Attribute ("version"), "ToXml-version");
}
[Test]
public void PermissionStateUnrestricted ()
{
RegistryPermission ep = new RegistryPermission (PermissionState.Unrestricted);
- AssertNotNull ("RegistryPermission(PermissionState.Unrestricted)", ep);
- Assert ("IsUnrestricted", ep.IsUnrestricted ());
+ Assert.IsNotNull (ep, "RegistryPermission(PermissionState.Unrestricted)");
+ Assert.IsTrue (ep.IsUnrestricted (), "IsUnrestricted");
RegistryPermission copy = (RegistryPermission)ep.Copy ();
- AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
+ Assert.AreEqual (ep.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = ep.ToXml ();
- AssertEquals ("ToXml-Unrestricted", "true", se.Attribute ("Unrestricted"));
+ Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "ToXml-Unrestricted");
}
[Test]
public void AllAccess ()
{
RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
}
[Test]
public void NoAccess ()
{
RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.NoAccess, keyLocalMachine);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
}
[Test]
public void CreateAccess ()
{
RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachine);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
}
[Test]
public void ReadAccess ()
{
RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
}
[Test]
public void WriteAccess ()
{
RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Write, keyLocalMachine);
- Assert ("IsUnrestricted", !ep.IsUnrestricted ());
+ Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
}
[Test]
ep.AddPathList (RegistryPermissionAccess.Write, keyCurrentUser);
SecurityElement se = ep.ToXml ();
// Note: Debugger can mess results (try to run without stepping)
- AssertEquals ("AddPathList-ToXml-Create", @"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000", se.Attribute ("Create"));
- AssertEquals ("AddPathList-ToXml-Read", @"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000;HKEY_CURRENT_USER\Software\Novell iFolder\spouliot\Home", se.Attribute ("Read"));
- AssertEquals ("AddPathList-ToXml-Write", @"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000;HKEY_CURRENT_USER\Software\Novell iFolder\spouliot\Home", se.Attribute ("Write"));
+ Assert.AreEqual (@"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000", se.Attribute ("Create"), "AddPathList-ToXml-Create");
+ Assert.AreEqual (@"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000;HKEY_CURRENT_USER\Software\Novell iFolder\spouliot\Home", se.Attribute ("Read"), "AddPathList-ToXml-Read");
+ Assert.AreEqual (@"HKEY_LOCAL_MACHINE\SOFTWARE\Novell\Novell iFolder\1.00.000;HKEY_CURRENT_USER\Software\Novell iFolder\spouliot\Home", se.Attribute ("Write"), "AddPathList-ToXml-Write");
}
[Test]
ep.AddPathList (RegistryPermissionAccess.AllAccess, keyLocalMachine);
ep.AddPathList (RegistryPermissionAccess.AllAccess, keyLocalMachineSubset);
SecurityElement se = ep.ToXml ();
- AssertEquals ("AddPathList-ToXml-Create", keyLocalMachineSubset, se.Attribute ("Create"));
- AssertEquals ("AddPathList-ToXml-Read", keyLocalMachineSubset, se.Attribute ("Read"));
- AssertEquals ("AddPathList-ToXml-Write", keyLocalMachineSubset, se.Attribute ("Write"));
+ Assert.AreEqual (keyLocalMachineSubset, se.Attribute ("Create"), "AddPathList-ToXml-Create");
+ Assert.AreEqual (keyLocalMachineSubset, se.Attribute ("Read"), "AddPathList-ToXml-Read");
+ Assert.AreEqual (keyLocalMachineSubset, se.Attribute ("Write"), "AddPathList-ToXml-Write");
ep = new RegistryPermission (PermissionState.None);
ep.AddPathList (RegistryPermissionAccess.AllAccess, keyLocalMachine);
ep.AddPathList (RegistryPermissionAccess.Create, keyLocalMachineSubset);
ep.AddPathList (RegistryPermissionAccess.Read, keyCurrentUser);
se = ep.ToXml ();
- AssertEquals ("AddPathList-ToXml-Create", keyLocalMachineSubset, se.Attribute ("Create"));
- AssertEquals ("AddPathList-ToXml-Read", keyLocalMachine + ";" + keyCurrentUser, se.Attribute ("Read"));
- AssertEquals ("AddPathList-ToXml-Write", keyLocalMachine, se.Attribute ("Write"));
+ Assert.AreEqual (keyLocalMachineSubset, se.Attribute ("Create"), "AddPathList-ToXml-Create");
+ Assert.AreEqual (keyLocalMachine + ";" + keyCurrentUser, se.Attribute ("Read"), "AddPathList-ToXml-Read");
+ Assert.AreEqual (keyLocalMachine, se.Attribute ("Write"), "AddPathList-ToXml-Write");
}
[Test]
RegistryPermission ep = new RegistryPermission (PermissionState.None);
ep.AddPathList (RegistryPermissionAccess.Read, keyCurrentUser);
ep.AddPathList (RegistryPermissionAccess.Write, keyLocalMachine);
- AssertEquals ("GetPathList-NoAccess", String.Empty, ep.GetPathList (RegistryPermissionAccess.NoAccess));
+ Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.NoAccess), "GetPathList-NoAccess");
}
[Test]
{
RegistryPermission ep = new RegistryPermission (PermissionState.None);
#if NET_2_0
- AssertEquals ("GetPathList-Create-Empty", String.Empty, ep.GetPathList (RegistryPermissionAccess.Create));
- AssertEquals ("GetPathList-Read-Empty", String.Empty, ep.GetPathList (RegistryPermissionAccess.Read));
- AssertEquals ("GetPathList-Write-Empty", String.Empty, ep.GetPathList (RegistryPermissionAccess.Write));
+ Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.Create), "GetPathList-Create-Empty");
+ Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.Read), "GetPathList-Read-Empty");
+ Assert.AreEqual (String.Empty, ep.GetPathList (RegistryPermissionAccess.Write), "GetPathList-Write-Empty");
#else
- AssertNull ("GetPathList-Create-Empty", ep.GetPathList (RegistryPermissionAccess.Create));
- AssertNull ("GetPathList-Read-Empty", ep.GetPathList (RegistryPermissionAccess.Read));
- AssertNull ("GetPathList-Write-Empty", ep.GetPathList (RegistryPermissionAccess.Write));
+ Assert.IsNull (ep.GetPathList (RegistryPermissionAccess.Create), "GetPathList-Create-Empty");
+ Assert.IsNull (ep.GetPathList (RegistryPermissionAccess.Read), "GetPathList-Read-Empty");
+ Assert.IsNull (ep.GetPathList (RegistryPermissionAccess.Write), "GetPathList-Write-Empty");
#endif
ep.AddPathList (RegistryPermissionAccess.Create, keyLocalMachine);
ep.AddPathList (RegistryPermissionAccess.Create, keyCurrentUser);
- AssertEquals ("GetPathList-Read", keyLocalMachine + ";" + keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create));
+ Assert.AreEqual (keyLocalMachine + ";" + keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create), "GetPathList-Read");
ep.AddPathList (RegistryPermissionAccess.Read, keyLocalMachine);
- AssertEquals ("GetPathList-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
+ Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "GetPathList-Read");
ep.AddPathList (RegistryPermissionAccess.Write, keyCurrentUser);
- AssertEquals ("GetPathList-Write", keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Write));
+ Assert.AreEqual (keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Write), "GetPathList-Write");
}
[Test]
ep.SetPathList (RegistryPermissionAccess.Read, keyCurrentUser);
ep.SetPathList (RegistryPermissionAccess.Write, keyCurrentUser);
SecurityElement se = ep.ToXml ();
- AssertEquals ("SetPathList-ToXml-Read", keyCurrentUser, se.Attribute ("Read"));
- AssertEquals ("SetPathList-ToXml-Write", keyCurrentUser, se.Attribute ("Write"));
+ Assert.AreEqual (keyCurrentUser, se.Attribute ("Read"), "SetPathList-ToXml-Read");
+ Assert.AreEqual (keyCurrentUser, se.Attribute ("Write"), "SetPathList-ToXml-Write");
}
[Test]
{
RegistryPermission ep = new RegistryPermission (PermissionState.None);
SecurityElement se = ep.ToXml ();
- AssertNotNull ("ToXml()", se);
+ Assert.IsNotNull (se, "ToXml()");
ep.FromXml (se);
se.AddAttribute ("Read", keyLocalMachine);
ep.FromXml (se);
- AssertEquals ("FromXml-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
+ Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "FromXml-Read");
se.AddAttribute ("Write", keyLocalMachine);
ep.FromXml (se);
- AssertEquals ("FromXml-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
- AssertEquals ("FromXml-Write", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write));
+ Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "FromXml-Read");
+ Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write), "FromXml-Write");
se.AddAttribute ("Create", keyCurrentUser);
ep.FromXml (se);
- AssertEquals ("FromXml-Read", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read));
- AssertEquals ("FromXml-Write", keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write));
- AssertEquals ("FromXml-Create", keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create));
+ Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Read), "FromXml-Read");
+ Assert.AreEqual (keyLocalMachine, ep.GetPathList (RegistryPermissionAccess.Write), "FromXml-Write");
+ Assert.AreEqual (keyCurrentUser, ep.GetPathList (RegistryPermissionAccess.Create), "FromXml-Create");
}
[Test]
RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
RegistryPermission ep2 = null;
RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
- AssertEquals ("EP1 U null == EP1", ep1.ToXml ().ToString (), ep3.ToXml ().ToString ());
+ Assert.AreEqual (ep1.ToXml ().ToString (), ep3.ToXml ().ToString (), "EP1 U null == EP1");
}
[Test]
RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
- Assert ("Unrestricted U EP2 == Unrestricted", ep3.IsUnrestricted ());
+ Assert.IsTrue (ep3.IsUnrestricted (), "Unrestricted U EP2 == Unrestricted");
ep3 = (RegistryPermission)ep2.Union (ep1);
- Assert ("EP2 U Unrestricted == Unrestricted", ep3.IsUnrestricted ());
+ Assert.IsTrue (ep3.IsUnrestricted (), "EP2 U Unrestricted == Unrestricted");
}
#if NET_2_0
RegistryPermission ep4 = (RegistryPermission)ep1.Union (ep2);
ep4 = (RegistryPermission)ep4.Union (ep3);
RegistryPermission ep5 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
- AssertEquals ("EP1 U EP2 U EP3 == EP1+2+3", ep4.ToXml ().ToString (), ep5.ToXml ().ToString ());
+ Assert.AreEqual (ep4.ToXml ().ToString (), ep5.ToXml ().ToString (), "EP1 U EP2 U EP3 == EP1+2+3");
}
#if NET_2_0
RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachineSubset);
RegistryPermission ep3 = (RegistryPermission)ep1.Union (ep2);
- AssertEquals ("Create", keyLocalMachineSubset, ep3.GetPathList (RegistryPermissionAccess.Create));
- AssertEquals ("Read", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read));
- AssertEquals ("Write", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write));
+ Assert.AreEqual (keyLocalMachineSubset, ep3.GetPathList (RegistryPermissionAccess.Create), "Create");
+ Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read), "Read");
+ Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write), "Write");
}
[Test]
RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
RegistryPermission ep2 = null;
RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
- AssertNull ("EP1 N null == null", ep3);
+ Assert.IsNull (ep3, "EP1 N null == null");
}
[Test]
RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
- Assert ("Unrestricted N EP2 == EP2", !ep3.IsUnrestricted ());
- AssertEquals ("Unrestricted N EP2 == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
+ Assert.IsTrue (!ep3.IsUnrestricted (), "Unrestricted N EP2 == EP2");
+ Assert.AreEqual (ep2.ToXml ().ToString (), ep3.ToXml ().ToString (), "Unrestricted N EP2 == EP2");
ep3 = (RegistryPermission)ep2.Intersect (ep1);
- Assert ("EP2 N Unrestricted == EP2", !ep3.IsUnrestricted ());
- AssertEquals ("EP2 N Unrestricted == EP2", ep2.ToXml ().ToString (), ep3.ToXml ().ToString ());
+ Assert.IsTrue (!ep3.IsUnrestricted (), "EP2 N Unrestricted == EP2");
+ Assert.AreEqual (ep2.ToXml ().ToString (), ep3.ToXml ().ToString (), "EP2 N Unrestricted == EP2");
}
[Test]
RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Write, keyCurrentUser);
RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
- AssertNull ("EP1 N EP2 == null", ep3);
+ Assert.IsNull (ep3, "EP1 N EP2 == null");
// intersection in read
RegistryPermission ep4 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
ep3 = (RegistryPermission)ep4.Intersect (ep2);
- AssertEquals ("Intersect-Read", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read));
+ Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read), "Intersect-Read");
// intersection in write
RegistryPermission ep5 = new RegistryPermission (RegistryPermissionAccess.Write, keyCurrentUser);
ep3 = (RegistryPermission)ep5.Intersect (ep1);
- AssertEquals ("Intersect-Write", keyCurrentUser, ep3.GetPathList (RegistryPermissionAccess.Write));
+ Assert.AreEqual (keyCurrentUser, ep3.GetPathList (RegistryPermissionAccess.Write), "Intersect-Write");
// intersection in read and write
RegistryPermission ep6 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
RegistryPermission ep7 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
ep3 = (RegistryPermission)ep6.Intersect (ep7);
- AssertEquals ("Intersect-AllAccess-Create", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create));
- AssertEquals ("Intersect-AllAccess-Read", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read));
- AssertEquals ("Intersect-AllAccess-Write", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write));
+ Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create), "Intersect-AllAccess-Create");
+ Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Read), "Intersect-AllAccess-Read");
+ Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Write), "Intersect-AllAccess-Write");
}
#if NET_2_0
RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachineSubset);
RegistryPermission ep3 = (RegistryPermission)ep1.Intersect (ep2);
- AssertEquals ("Create", keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create));
- AssertNull ("Read", ep3.GetPathList (RegistryPermissionAccess.Read));
- AssertNull ("Write", ep3.GetPathList (RegistryPermissionAccess.Write));
+ Assert.AreEqual (keyLocalMachine, ep3.GetPathList (RegistryPermissionAccess.Create), "Create");
+ Assert.IsNull (ep3.GetPathList (RegistryPermissionAccess.Read), "Read");
+ Assert.IsNull (ep3.GetPathList (RegistryPermissionAccess.Write), "Write");
}
[Test]
public void IsSubsetOfNull ()
{
RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
- Assert ("IsSubsetOf(null)", !ep1.IsSubsetOf (null));
+ Assert.IsTrue (!ep1.IsSubsetOf (null), "IsSubsetOf(null)");
}
[Test]
RegistryPermission ep1 = new RegistryPermission (PermissionState.Unrestricted);
RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
RegistryPermission ep3 = new RegistryPermission (PermissionState.Unrestricted);
- Assert ("Unrestricted.IsSubsetOf()", !ep1.IsSubsetOf (ep2));
- Assert ("IsSubsetOf(Unrestricted)", ep2.IsSubsetOf (ep1));
- Assert ("Unrestricted.IsSubsetOf(Unrestricted)", ep1.IsSubsetOf (ep3));
+ Assert.IsTrue (!ep1.IsSubsetOf (ep2), "Unrestricted.IsSubsetOf()");
+ Assert.IsTrue (ep2.IsSubsetOf (ep1), "IsSubsetOf(Unrestricted)");
+ Assert.IsTrue (ep1.IsSubsetOf (ep3), "Unrestricted.IsSubsetOf(Unrestricted)");
}
[Test]
{
RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Write, keyLocalMachine);
RegistryPermission ep2 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
- Assert ("IsSubsetOf(nosubset1)", !ep1.IsSubsetOf (ep2));
- Assert ("IsSubsetOf(nosubset2)", !ep2.IsSubsetOf (ep1));
+ Assert.IsTrue (!ep1.IsSubsetOf (ep2), "IsSubsetOf(nosubset1)");
+ Assert.IsTrue (!ep2.IsSubsetOf (ep1), "IsSubsetOf(nosubset2)");
RegistryPermission ep3 = new RegistryPermission (RegistryPermissionAccess.AllAccess, keyLocalMachine);
- Assert ("Write.IsSubsetOf(All)", ep1.IsSubsetOf (ep3));
- Assert ("All.IsSubsetOf(Write)", !ep3.IsSubsetOf (ep1));
+ Assert.IsTrue (ep1.IsSubsetOf (ep3), "Write.IsSubsetOf(All)");
+ Assert.IsTrue (!ep3.IsSubsetOf (ep1), "All.IsSubsetOf(Write)");
}
[Test]
{
RegistryPermission ep1 = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
FileDialogPermission fdp2 = new FileDialogPermission (PermissionState.Unrestricted);
- Assert ("IsSubsetOf(FileDialogPermission)", ep1.IsSubsetOf (fdp2));
+ Assert.IsTrue (ep1.IsSubsetOf (fdp2), "IsSubsetOf(FileDialogPermission)");
}
}
}
-//\r
-// ZoneIdentityPermissionAttributeTest.cs - \r
-// NUnit Test Cases for ZoneIdentityPermissionAttribute\r
-//\r
-// Author:\r
-// Sebastien Pouliot <sebastien@ximian.com>\r
-//\r
-// (C) 2003 Motus Technologies Inc. (http://www.motus.com)\r
-// Copyright (C) 2004 Novell, Inc (http://www.novell.com)\r
-//\r
-// Permission is hereby granted, free of charge, to any person obtaining\r
-// a copy of this software and associated documentation files (the\r
-// "Software"), to deal in the Software without restriction, including\r
-// without limitation the rights to use, copy, modify, merge, publish,\r
-// distribute, sublicense, and/or sell copies of the Software, and to\r
-// permit persons to whom the Software is furnished to do so, subject to\r
-// the following conditions:\r
-// \r
-// The above copyright notice and this permission notice shall be\r
-// included in all copies or substantial portions of the Software.\r
-// \r
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
-//\r
-\r
-using NUnit.Framework;\r
-using System;\r
-using System.Security;\r
-using System.Security.Permissions;\r
-\r
-namespace MonoTests.System.Security.Permissions {\r
-\r
- [TestFixture]\r
- public class ZoneIdentityPermissionAttributeTest {\r
-\r
- [Test]\r
- public void Default () \r
- {\r
- ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);\r
- Assert.AreEqual (a.ToString (), a.TypeId.ToString (), "TypeId");\r
- Assert.IsFalse (a.Unrestricted, "Unrestricted");\r
- Assert.AreEqual (SecurityZone.NoZone, a.Zone, "Zone");\r
-\r
- ZoneIdentityPermission perm = (ZoneIdentityPermission) a.CreatePermission ();\r
- Assert.AreEqual (SecurityZone.NoZone, perm.SecurityZone, "CreatePermission-SecurityZone");\r
- }\r
-\r
- [Test]\r
- public void Action () \r
- {\r
- ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);\r
- Assert.AreEqual (SecurityAction.Assert, a.Action, "Action=Assert");\r
- a.Action = SecurityAction.Demand;\r
- Assert.AreEqual (SecurityAction.Demand, a.Action, "Action=Demand");\r
- a.Action = SecurityAction.Deny;\r
- Assert.AreEqual (SecurityAction.Deny, a.Action, "Action=Deny");\r
- a.Action = SecurityAction.InheritanceDemand;\r
- Assert.AreEqual (SecurityAction.InheritanceDemand, a.Action, "Action=InheritanceDemand");\r
- a.Action = SecurityAction.LinkDemand;\r
- Assert.AreEqual (SecurityAction.LinkDemand, a.Action, "Action=LinkDemand");\r
- a.Action = SecurityAction.PermitOnly;\r
- Assert.AreEqual (SecurityAction.PermitOnly, a.Action, "Action=PermitOnly");\r
- a.Action = SecurityAction.RequestMinimum;\r
- Assert.AreEqual (SecurityAction.RequestMinimum, a.Action, "Action=RequestMinimum");\r
- a.Action = SecurityAction.RequestOptional;\r
- Assert.AreEqual (SecurityAction.RequestOptional, a.Action, "Action=RequestOptional");\r
- a.Action = SecurityAction.RequestRefuse;\r
- Assert.AreEqual (SecurityAction.RequestRefuse, a.Action, "Action=RequestRefuse");\r
- }\r
-\r
- [Test]\r
- public void Action_Invalid ()\r
- {\r
- ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute ((SecurityAction)Int32.MinValue);\r
- // no validation in attribute\r
- }\r
-\r
- [Test]\r
- public void Zone () \r
- {\r
- ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);\r
- Assert.AreEqual (SecurityZone.NoZone, a.Zone, "Zone=default");\r
- a.Zone = SecurityZone.Internet;\r
- Assert.AreEqual (SecurityZone.Internet, a.Zone, "Zone=Internet");\r
- a.Zone = SecurityZone.Intranet;\r
- Assert.AreEqual (SecurityZone.Intranet, a.Zone, "Zone=Intranet");\r
- a.Zone = SecurityZone.MyComputer;\r
- Assert.AreEqual (SecurityZone.MyComputer, a.Zone, "Zone=MyComputer");\r
- a.Zone = SecurityZone.NoZone;\r
- Assert.AreEqual (SecurityZone.NoZone, a.Zone, "Zone=NoZone");\r
- a.Zone = SecurityZone.Trusted;\r
- Assert.AreEqual (SecurityZone.Trusted, a.Zone, "Zone=Trusted");\r
- a.Zone = SecurityZone.Untrusted;\r
- Assert.AreEqual (SecurityZone.Untrusted, a.Zone, "Zone=Untrusted");\r
- }\r
-\r
- [Test]\r
- public void Zone_Invalid ()\r
- {\r
- ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);\r
- a.Zone = (SecurityZone)Int32.MinValue;\r
- // no validation in attribute\r
- }\r
-\r
- [Test]\r
- public void TypeId () \r
- {\r
- ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);\r
- Assert.AreEqual (a.ToString (), a.TypeId.ToString (), "TypeId");\r
- }\r
-\r
+//
+// ZoneIdentityPermissionAttributeTest.cs -
+// NUnit Test Cases for ZoneIdentityPermissionAttribute
+//
+// Author:
+// Sebastien Pouliot <sebastien@ximian.com>
+//
+// (C) 2003 Motus Technologies Inc. (http://www.motus.com)
+// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using NUnit.Framework;
+using System;
+using System.Security;
+using System.Security.Permissions;
+
+namespace MonoTests.System.Security.Permissions {
+
+ [TestFixture]
+ public class ZoneIdentityPermissionAttributeTest {
+
+ [Test]
+ public void Default ()
+ {
+ ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);
+ Assert.AreEqual (a.ToString (), a.TypeId.ToString (), "TypeId");
+ Assert.IsFalse (a.Unrestricted, "Unrestricted");
+ Assert.AreEqual (SecurityZone.NoZone, a.Zone, "Zone");
+
+ ZoneIdentityPermission perm = (ZoneIdentityPermission) a.CreatePermission ();
+ Assert.AreEqual (SecurityZone.NoZone, perm.SecurityZone, "CreatePermission-SecurityZone");
+ }
+
+ [Test]
+ public void Action ()
+ {
+ ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);
+ Assert.AreEqual (SecurityAction.Assert, a.Action, "Action=Assert");
+ a.Action = SecurityAction.Demand;
+ Assert.AreEqual (SecurityAction.Demand, a.Action, "Action=Demand");
+ a.Action = SecurityAction.Deny;
+ Assert.AreEqual (SecurityAction.Deny, a.Action, "Action=Deny");
+ a.Action = SecurityAction.InheritanceDemand;
+ Assert.AreEqual (SecurityAction.InheritanceDemand, a.Action, "Action=InheritanceDemand");
+ a.Action = SecurityAction.LinkDemand;
+ Assert.AreEqual (SecurityAction.LinkDemand, a.Action, "Action=LinkDemand");
+ a.Action = SecurityAction.PermitOnly;
+ Assert.AreEqual (SecurityAction.PermitOnly, a.Action, "Action=PermitOnly");
+ a.Action = SecurityAction.RequestMinimum;
+ Assert.AreEqual (SecurityAction.RequestMinimum, a.Action, "Action=RequestMinimum");
+ a.Action = SecurityAction.RequestOptional;
+ Assert.AreEqual (SecurityAction.RequestOptional, a.Action, "Action=RequestOptional");
+ a.Action = SecurityAction.RequestRefuse;
+ Assert.AreEqual (SecurityAction.RequestRefuse, a.Action, "Action=RequestRefuse");
+ }
+
+ [Test]
+ public void Action_Invalid ()
+ {
+ ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute ((SecurityAction)Int32.MinValue);
+ // no validation in attribute
+ }
+
+ [Test]
+ public void Zone ()
+ {
+ ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);
+ Assert.AreEqual (SecurityZone.NoZone, a.Zone, "Zone=default");
+ a.Zone = SecurityZone.Internet;
+ Assert.AreEqual (SecurityZone.Internet, a.Zone, "Zone=Internet");
+ a.Zone = SecurityZone.Intranet;
+ Assert.AreEqual (SecurityZone.Intranet, a.Zone, "Zone=Intranet");
+ a.Zone = SecurityZone.MyComputer;
+ Assert.AreEqual (SecurityZone.MyComputer, a.Zone, "Zone=MyComputer");
+ a.Zone = SecurityZone.NoZone;
+ Assert.AreEqual (SecurityZone.NoZone, a.Zone, "Zone=NoZone");
+ a.Zone = SecurityZone.Trusted;
+ Assert.AreEqual (SecurityZone.Trusted, a.Zone, "Zone=Trusted");
+ a.Zone = SecurityZone.Untrusted;
+ Assert.AreEqual (SecurityZone.Untrusted, a.Zone, "Zone=Untrusted");
+ }
+
+ [Test]
+ public void Zone_Invalid ()
+ {
+ ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);
+ a.Zone = (SecurityZone)Int32.MinValue;
+ // no validation in attribute
+ }
+
+ [Test]
+ public void TypeId ()
+ {
+ ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);
+ Assert.AreEqual (a.ToString (), a.TypeId.ToString (), "TypeId");
+ }
+
[Test]
#if NET_2_0
[Category ("NotWorking")]
-#else\r
+#else
[ExpectedException (typeof (ArgumentException))]
-#endif\r
- public void Unrestricted () \r
- {\r
- ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);\r
- a.Unrestricted = true;\r
- IPermission perm = a.CreatePermission ();\r
- }\r
-\r
- [Test]\r
- public void Attributes ()\r
- {\r
- Type t = typeof (ZoneIdentityPermissionAttribute);\r
- Assert.IsTrue (t.IsSerializable, "IsSerializable");\r
-\r
- object[] attrs = t.GetCustomAttributes (typeof (AttributeUsageAttribute), false);\r
- Assert.AreEqual (1, attrs.Length, "AttributeUsage");\r
- AttributeUsageAttribute aua = (AttributeUsageAttribute)attrs [0];\r
- Assert.IsTrue (aua.AllowMultiple, "AllowMultiple");\r
- Assert.IsFalse (aua.Inherited, "Inherited");\r
- AttributeTargets at = (AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method);\r
- Assert.AreEqual (at, aua.ValidOn, "ValidOn");\r
- }\r
- }\r
-}\r
+#endif
+ public void Unrestricted ()
+ {
+ ZoneIdentityPermissionAttribute a = new ZoneIdentityPermissionAttribute (SecurityAction.Assert);
+ a.Unrestricted = true;
+ IPermission perm = a.CreatePermission ();
+ }
+
+ [Test]
+ public void Attributes ()
+ {
+ Type t = typeof (ZoneIdentityPermissionAttribute);
+ Assert.IsTrue (t.IsSerializable, "IsSerializable");
+
+ object[] attrs = t.GetCustomAttributes (typeof (AttributeUsageAttribute), false);
+ Assert.AreEqual (1, attrs.Length, "AttributeUsage");
+ AttributeUsageAttribute aua = (AttributeUsageAttribute)attrs [0];
+ Assert.IsTrue (aua.AllowMultiple, "AllowMultiple");
+ Assert.IsFalse (aua.Inherited, "Inherited");
+ AttributeTargets at = (AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method);
+ Assert.AreEqual (at, aua.ValidOn, "ValidOn");
+ }
+ }
+}
projects / mono.git / commitdiff