+2005-01-04 Sebastien Pouliot <sebastien@ximian.com>
+
+ * GacIdentityPermissionTest.cs, IBuiltInPermissionTest.cs,
+ PublisherIdentityPermissionAttributeTest.cs,
+ PublisherIdentityPermissionTest.cs,
+ SiteIdentityPermissionAttributeTest.cs, SiteIdentityPermissionTest.cs,
+ StrongNameIdentityPermissionAttributeTest.cs,
+ StrongNameIdentityPermissionTest.cs,
+ UrlIdentityPermissionAttributeTest.cs, UrlIdentityPermissionTest.cs,
+ ZoneIdentityPermissionTest.cs: Adjusted unit tests so they now execute
+ without errors on 2.0 Dec CTP.
+
2004-10-15 Sebastien Pouliot <sebastien@ximian.com>
* PrincipalPermissionTest.cs: Added two new tests to check for nulls
}
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void PermissionStateUnrestricted ()
{
GacIdentityPermission gip = new GacIdentityPermission (PermissionState.Unrestricted);
+
+ // FX 2.0 now supports Unrestricted for Identity Permissions
+ // However the XML doesn't show the Unrestricted status...
+
+ SecurityElement se = gip.ToXml ();
+ // only class and version are present
+ Assert.AreEqual (2, se.Attributes.Count, "Xml-Attributes");
+ Assert.IsNull (se.Children, "Xml-Children");
+
+ GacIdentityPermission copy = (GacIdentityPermission)gip.Copy ();
+ Assert.IsFalse (Object.ReferenceEquals (gip, copy), "ReferenceEquals");
+
+ // ... and because it doesn't implement IUnrestrictedPermission
+ // there is not way to know if it's unrestricted so...
+ Assert.IsTrue (gip.Equals (new GacIdentityPermission (PermissionState.None)), "Unrestricted==None");
+ // there is not much difference after all ;-)
}
[Test]
-//\r
+//\r
// IBuiltInPermissionTest.cs - NUnit Test Cases for IBuiltInPermission\r
//\r
// Author:\r
IPermission p = (IPermission)new KeyContainerPermission (PermissionState.None);\r
Assert.AreEqual (17, GetTokenIndex (p));\r
}\r
-\r
- [Test]\r
- public void DataProtection ()\r
- {\r
- IPermission p = (IPermission) new DataProtectionPermission (PermissionState.None);\r
- Assert.AreEqual (18, GetTokenIndex (p));\r
- }\r
#endif\r
}\r
}\r
}
[Test]
+#if !NET_2_0
[ExpectedException (typeof (ArgumentException))]
+#endif
public void Unrestricted ()
{
PublisherIdentityPermissionAttribute a = new PublisherIdentityPermissionAttribute (SecurityAction.Assert);
AssertNotNull ("PublisherIdentityPermission(PermissionState.None)", p);
PublisherIdentityPermission copy = (PublisherIdentityPermission) p.Copy ();
SecurityElement se = p.ToXml ();
- Assert ("ToXml-class", (se.Attributes ["class"] as string).StartsWith (className));
- AssertEquals ("ToXml-version", "1", (se.Attributes ["version"] as string));
+ 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);
}
-
+#if NET_2_0
+ [Test]
+ public void PermissionStateUnrestricted ()
+ {
+ // In 2.0 Unrestricted are permitted for identity permissions
+ PublisherIdentityPermission p = new PublisherIdentityPermission (PermissionState.Unrestricted);
+ AssertNotNull ("PublisherIdentityPermission(PermissionState.None)", p);
+ 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);
+ // and they aren't equals to None
+ Assert (!p.Equals (new PublisherIdentityPermission (PermissionState.None)));
+ }
+#else
[Test]
[ExpectedException (typeof (ArgumentException))]
public void PermissionStateUnrestricted ()
// Unrestricted isn't permitted for identity permissions
PublisherIdentityPermission p = new PublisherIdentityPermission (PermissionState.Unrestricted);
}
-
+#endif
[Test]
public void Certificate ()
{
AssertEquals ("cert1 U cert1 == cert1", p3.ToString (), p1.ToString ());
}
-#if NET_2_0
[Test]
+#if !NET_2_0
[ExpectedException (typeof (ArgumentException))]
+#endif
public void Union_DifferentCertificates ()
{
PublisherIdentityPermission p1 = new PublisherIdentityPermission (x509);
X509Certificate x2 = new X509Certificate (cert2);
PublisherIdentityPermission p2 = new PublisherIdentityPermission (x2);
- p1.Union (p2);
- }
+ IPermission p = p1.Union (p2);
+#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"));
+ // strangely it is still versioned as 'version="1"'.
+ AssertEquals ("Version", "1", se.Attribute ("version"));
#endif
+ }
[Test]
[ExpectedException (typeof (ArgumentException))]
}
[Test]
+#if !NET_2_0
[ExpectedException (typeof (NullReferenceException))]
+#endif
public void DefaultPermission ()
{
SiteIdentityPermissionAttribute a = new SiteIdentityPermissionAttribute (SecurityAction.Assert);
SiteIdentityPermission perm = (SiteIdentityPermission) a.CreatePermission ();
// ... but this works ...
Assert.IsNotNull (perm, "CreatePermission(null site)");
- // ... but this doesn't!
+ // ... but this doesn't! (FIXED IN 2.0 NOV CTP)
string site = perm.Site;
}
}
[Test]
+#if !NET_2_0
[ExpectedException (typeof (ArgumentException))]
+#endif
public void Unrestricted ()
{
SiteIdentityPermissionAttribute a = new SiteIdentityPermissionAttribute (SecurityAction.Assert);
"www.mono-project.com:80",
"*www.mono-project.com",
"*-project.com",
+ "www.*.com",
};
[Test]
public void PermissionState_None ()
{
SiteIdentityPermission sip = new SiteIdentityPermission (PermissionState.None);
-// Assert.IsNull (sip.Site, "Site");
-
+ Assert.AreEqual (String.Empty, sip.Site, "Site");
SecurityElement se = sip.ToXml ();
// only class and version are present
Assert.AreEqual (2, se.Attributes.Count, "Xml-Attributes");
Assert.IsNull (se.Children, "Xml-Children");
-
SiteIdentityPermission copy = (SiteIdentityPermission)sip.Copy ();
Assert.IsFalse (Object.ReferenceEquals (sip, copy), "ReferenceEquals");
}
+#if NET_2_0
[Test]
-// MS BUG
- [ExpectedException (typeof (NullReferenceException))]
- public void PermissionState_None_Site ()
+ public void PermissionStateUnrestricted ()
{
- SiteIdentityPermission sip = new SiteIdentityPermission (PermissionState.None);
- Assert.IsNull (sip.Site, "Site");
+ // In 2.0 Unrestricted are permitted for identity permissions
+ SiteIdentityPermission sip = new SiteIdentityPermission (PermissionState.Unrestricted);
+ Assert.AreEqual (String.Empty, sip.Site, "Site");
+ SecurityElement se = sip.ToXml ();
+ Assert.AreEqual (3, se.Attributes.Count, "Xml-Attributes");
+ Assert.IsNull (se.Children, "Xml-Children");
+ SiteIdentityPermission copy = (SiteIdentityPermission)sip.Copy ();
+ Assert.IsFalse (Object.ReferenceEquals (sip, copy), "ReferenceEquals");
+ // and they aren't equals to None
+ Assert.IsFalse (sip.Equals (new SiteIdentityPermission (PermissionState.None)));
}
-
+#else
[Test]
[ExpectedException (typeof (ArgumentException))]
public void PermissionState_Unrestricted ()
{
SiteIdentityPermission sip = new SiteIdentityPermission (PermissionState.Unrestricted);
}
-
+#endif
[Test]
[ExpectedException (typeof (ArgumentException))]
public void PermissionState_Bad ()
SiteIdentityPermission sip = new SiteIdentityPermission (null);
}
+ [Test]
+ [ExpectedException (typeof (ArgumentException))]
+ public void SiteIdentityPermission_EmptySite ()
+ {
+ SiteIdentityPermission sip = new SiteIdentityPermission (String.Empty);
+ }
+
[Test]
public void Site ()
{
Assert.IsFalse (sip2.IsSubsetOf (sip1), "Novell subset Mono");
}
+ [Test]
+ public void IsSubset_Wildcard ()
+ {
+ SiteIdentityPermission sip1 = new SiteIdentityPermission (GoodSites [0]);
+ SiteIdentityPermission sip2 = new SiteIdentityPermission ("*.mono-project.com");
+ Assert.IsTrue (sip1.IsSubsetOf (sip2), "www.mono-project.com subset *.mono-project.com");
+ Assert.IsFalse (sip2.IsSubsetOf (sip1), "*.mono-project.com subset www.mono-project.com");
+ }
+
[Test]
public void Union_Null ()
{
{
SiteIdentityPermission sip = new SiteIdentityPermission (PermissionState.None);
SiteIdentityPermission union = (SiteIdentityPermission)sip.Union (sip);
+#if NET_2_0
+ Assert.IsNull (union, "None U None");
+#else
Assert.IsNotNull (union, "None U None"); // can't get null Site property
foreach (string s in GoodSites) {
sip.Site = s;
union = (SiteIdentityPermission)sip.Union (sip);
Assert.AreEqual (s, union.Site, s);
}
+#endif
}
[Test]
-#if NET_2_0
- [ExpectedException (typeof (ArgumentException))]
-#endif
public void Union_Different ()
{
SiteIdentityPermission sip1 = new SiteIdentityPermission (GoodSites [0]);
SiteIdentityPermission sip2 = new SiteIdentityPermission (GoodSites [1]);
SiteIdentityPermission result = (SiteIdentityPermission)sip1.Union (sip2);
+#if NET_2_0
+ Assert.IsNotNull (result, "Mono U Novell");
+ // new XML format is used to contain more than one site
+ SecurityElement se = result.ToXml ();
+ Assert.AreEqual (2, se.Children.Count, "Childs");
+ Assert.AreEqual ((se.Children [0] as SecurityElement).Attribute ("Site"), sip1.Site, "Site#1");
+ Assert.AreEqual ((se.Children [1] as SecurityElement).Attribute ("Site"), sip2.Site, "Site#2");
+ // strangely it is still versioned as 'version="1"'.
+ Assert.AreEqual ("1", se.Attribute ("version"), "Version");
+#else
+ // It's null for FX 1.0 and 1.1
Assert.IsNull (result, "Mono U Novell");
+#endif
}
-
+#if NET_2_0
+ [Test]
+ [ExpectedException (typeof (NotSupportedException))]
+ public void Union_Different_Site ()
+ {
+ SiteIdentityPermission sip1 = new SiteIdentityPermission (GoodSites [0]);
+ SiteIdentityPermission sip2 = new SiteIdentityPermission (GoodSites [1]);
+ SiteIdentityPermission result = (SiteIdentityPermission)sip1.Union (sip2);
+ // it's not possible to return many sites using the Site property so it throws
+ Assert.IsNull (result.Site);
+ }
+#endif
[Test]
[ExpectedException (typeof (ArgumentNullException))]
public void FromXml_Null ()
}
[Test]
+#if !NET_2_0
[ExpectedException (typeof (ArgumentException))]
+#endif
public void Unrestricted ()
{
StrongNameIdentityPermissionAttribute a = new StrongNameIdentityPermissionAttribute (SecurityAction.Assert);
Assert.AreEqual ("0.0", snip.Version.ToString (), "Version");
SecurityElement se = snip.ToXml ();
+#if NET_2_0
+ Assert.IsNull (se.Attribute ("Name"), "Xml-Name");
+ Assert.IsNull (se.Attribute ("AssemblyVersion"), "Xml-AssemblyVersion");
+#else
Assert.AreEqual (String.Empty, se.Attribute ("Name"), "Xml-Name");
- Assert.IsNull (se.Attribute ("PublicKeyBlob"), "Xml-PublicKeyBlob");
Assert.AreEqual ("0.0", se.Attribute ("AssemblyVersion"), "Xml-AssemblyVersion");
+#endif
+ Assert.IsNull (se.Attribute ("PublicKeyBlob"), "Xml-PublicKeyBlob");
// because Name == String.Empty, which is illegal using the other constructor
StrongNameIdentityPermission copy = (StrongNameIdentityPermission) snip.Copy ();
Assert.AreEqual (String.Empty, copy.Name, "Copy-Name");
- Assert.IsNull (copy.PublicKey, "Copy-PublicKey");
+#if NET_2_0
+ // Strangely once copied the Name becomes equals to String.Empty in 2.0 [FDBK19351]
+ Assert.IsNull (se.Attribute ("AssemblyVersion"), "Copy-Version");
+#else
Assert.AreEqual ("0.0", copy.Version.ToString (), "Copy-Version");
+#endif
+ Assert.IsNull (copy.PublicKey, "Copy-PublicKey");
}
-
+#if NET_2_0
+ [Test]
+ public void PermissionStateUnrestricted ()
+ {
+ // In 2.0 Unrestricted are permitted for identity permissions
+ StrongNameIdentityPermission snip = new StrongNameIdentityPermission (PermissionState.Unrestricted);
+ Assert.AreEqual (String.Empty, snip.Name, "Name");
+ Assert.IsNull (snip.PublicKey, "PublicKey");
+ Assert.AreEqual ("0.0", snip.Version.ToString (), "Version");
+ SecurityElement se = snip.ToXml ();
+ Assert.IsNull (se.Attribute ("Name"), "Xml-Name");
+ Assert.IsNull (se.Attribute ("PublicKeyBlob"), "Xml-PublicKeyBlob");
+ Assert.IsNull (se.Attribute ("AssemblyVersion"), "Xml-AssemblyVersion");
+ StrongNameIdentityPermission copy = (StrongNameIdentityPermission)snip.Copy ();
+ // Strangely once copied the Name becomes equals to String.Empty in 2.0 [FDBK19351]
+ Assert.AreEqual (String.Empty, copy.Name, "Copy-Name");
+ Assert.IsNull (copy.PublicKey, "Copy-PublicKey");
+ Assert.IsNull (se.Attribute ("AssemblyVersion"), "Copy-Version");
+ // and they aren't equals to None
+ Assert.IsFalse (snip.Equals (new StrongNameIdentityPermission (PermissionState.None)));
+ }
+#else
[Test]
[ExpectedException (typeof (ArgumentException))]
public void PermissionStateUnrestricted ()
{
StrongNameIdentityPermission snip = new StrongNameIdentityPermission (PermissionState.Unrestricted);
}
-
+#endif
[Test]
[ExpectedException (typeof (ArgumentException))]
public void PermissionStateInvalid ()
}
[Test]
-#if NET_2_0
- [ExpectedException (typeof (ArgumentException))]
-#endif
public void Copy_NameEmpty ()
{
StrongNameIdentityPermission snip = new StrongNameIdentityPermission (PermissionState.None);
// because Name == String.Empty, which is illegal using the other constructor
// but (somewhat) required to copy the teo other informations
StrongNameIdentityPermission copy = (StrongNameIdentityPermission)snip.Copy ();
-#if !NET_2_0
- // TODO
-#endif
+ Assert.IsTrue (copy.Equals (snip), "Equals");
}
private void Compare (StrongNameIdentityPermission p1, StrongNameIdentityPermission p2, string prefix)
StrongNameIdentityPermission empty = new StrongNameIdentityPermission (PermissionState.None);
intersect = (StrongNameIdentityPermission)snip.Intersect (empty);
+#if NET_2_0
+ Assert.IsNull (intersect, "snip N empty");
+#else
Compare (empty, intersect, "snip U empty");
-
+#endif
intersect = (StrongNameIdentityPermission)snip.Intersect (snip);
Compare (snip, intersect, "snip U snip");
}
[Test]
+#if NET_2_0
+ [ExpectedException (typeof (ArgumentException))]
+#endif
public void Intersect_DifferentPermissions ()
{
StrongNameIdentityPermission a = new StrongNameIdentityPermission (PermissionState.None);
StrongNameIdentityPermission samePk = new StrongNameIdentityPermission (blob, null, null);
union = (StrongNameIdentityPermission)snip.Union (samePk);
+#if !NET_2_0
+ // can't compare the properties with multiple entries
Compare (snip, union, "snip U samePk");
+#endif
Assert.IsTrue (snip.IsSubsetOf (union), "snip.IsSubsetOf (union)");
union = (StrongNameIdentityPermission)samePk.Union (snip);
+#if !NET_2_0
+ // can't compare the properties with multiple entries
Compare (snip, union, "samePk U snip");
+#endif
Assert.IsTrue (samePk.IsSubsetOf (union), "snip.IsSubsetOf (union)");
}
[Test]
-#if NET_2_0
- [ExpectedException (typeof (ArgumentException))]
-#endif
public void Union_DifferentPk ()
{
StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob (ecma);
StrongNamePublicKeyBlob blob2 = new StrongNamePublicKeyBlob (new byte [16]);
StrongNameIdentityPermission diffPk = new StrongNameIdentityPermission (blob2, "mono", new Version (1, 2, 3, 4));
StrongNameIdentityPermission result = (StrongNameIdentityPermission) snip.Union (diffPk);
-#if !NET_2_0
- // TODO
+#if NET_2_0
+ Assert.IsNotNull (result, "DifferentPk");
+ // new XML format is used to contain more than one site
+ SecurityElement se = result.ToXml ();
+ Assert.AreEqual (2, se.Children.Count, "Childs");
+ Assert.AreEqual ("00000000000000000400000000000000", (se.Children [0] as SecurityElement).Attribute ("PublicKeyBlob"), "Blob#1");
+ Assert.AreEqual ("00000000000000000000000000000000", (se.Children [1] as SecurityElement).Attribute ("PublicKeyBlob"), "Blob#2");
+ // strangely it is still versioned as 'version="1"'.
+ Assert.AreEqual ("1", se.Attribute ("version"), "Version");
#endif
}
[Test]
-#if NET_2_0
- [ExpectedException (typeof (ArgumentException))]
-#endif
public void Union_SamePublicKey_DifferentName ()
{
StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob (ecma);
StrongNameIdentityPermission snip = new StrongNameIdentityPermission (blob, "mono", new Version (1, 2, 3, 4));
StrongNameIdentityPermission diffName = new StrongNameIdentityPermission (blob, "novell", null);
StrongNameIdentityPermission result = (StrongNameIdentityPermission) snip.Union (diffName);
-#if !NET_2_0
- // TODO
+#if NET_2_0
+ Assert.IsNotNull (result, "DifferentName");
+ // new XML format is used to contain more than one site
+ SecurityElement se = result.ToXml ();
+ Assert.AreEqual (2, se.Children.Count, "Childs");
+ Assert.AreEqual ("mono", (se.Children [0] as SecurityElement).Attribute ("Name"), "Name#1");
+ Assert.AreEqual ("novell", (se.Children [1] as SecurityElement).Attribute ("Name"), "Name#2");
+ // strangely it is still versioned as 'version="1"'.
+ Assert.AreEqual ("1", se.Attribute ("version"), "Version");
#endif
}
[Test]
-#if NET_2_0
- [ExpectedException (typeof (ArgumentException))]
-#endif
public void Union_SamePublicKey_DifferentVersion ()
{
StrongNamePublicKeyBlob blob = new StrongNamePublicKeyBlob (ecma);
StrongNameIdentityPermission snip = new StrongNameIdentityPermission (blob, "mono", new Version (1, 2, 3, 4));
StrongNameIdentityPermission diffVersion = new StrongNameIdentityPermission (blob, null, new Version (1, 2));
StrongNameIdentityPermission result = (StrongNameIdentityPermission) snip.Union (diffVersion);
-#if !NET_2_0
- // TODO
+#if NET_2_0
+ Assert.IsNotNull (result, "DifferentVersion");
+ // new XML format is used to contain more than one site
+ SecurityElement se = result.ToXml ();
+ Assert.AreEqual (2, se.Children.Count, "Childs");
+ Assert.AreEqual ("1.2.3.4", (se.Children [0] as SecurityElement).Attribute ("AssemblyVersion"), "AssemblyVersion#1");
+ Assert.AreEqual ("1.2", (se.Children [1] as SecurityElement).Attribute ("AssemblyVersion"), "AssemblyVersion#2");
+ // strangely it is still versioned as 'version="1"'.
+ Assert.AreEqual ("1", se.Attribute ("version"), "Version");
#endif
}
}
[Test]
+#if !NET_2_0
[ExpectedException (typeof (ArgumentException))]
+#endif
public void Unrestricted ()
{
UrlIdentityPermissionAttribute a = new UrlIdentityPermissionAttribute (SecurityAction.Assert);
{
UrlIdentityPermission uip = new UrlIdentityPermission (PermissionState.None);
#if NET_2_0
+ // that cause a NullReferenceException before 2.0
Assert.AreEqual (String.Empty, uip.Url, "Url");
#endif
SecurityElement se = uip.ToXml ();
Assert.AreEqual (2, se.Attributes.Count, "Xml-Attributes");
Assert.IsNull (se.Children, "Xml-Children");
-// UrlIdentityPermission copy = (UrlIdentityPermission)uip.Copy ();
-// Assert.IsFalse (Object.ReferenceEquals (uip, copy), "ReferenceEquals");
+ UrlIdentityPermission copy = (UrlIdentityPermission)uip.Copy ();
+ Assert.IsFalse (Object.ReferenceEquals (uip, copy), "ReferenceEquals");
}
#if !NET_2_0
}
#endif
+#if NET_2_0
+ [Test]
+ public void PermissionStateUnrestricted ()
+ {
+ // In 2.0 Unrestricted are permitted for identity permissions
+ UrlIdentityPermission uip = new UrlIdentityPermission (PermissionState.Unrestricted);
+ Assert.AreEqual (String.Empty, uip.Url, "Url");
+ SecurityElement se = uip.ToXml ();
+ // only class and version are present
+ Assert.AreEqual (3, se.Attributes.Count, "Xml-Attributes");
+ Assert.IsNull (se.Children, "Xml-Children");
+ // and they aren't equals to None
+ Assert.IsFalse (uip.Equals (new UrlIdentityPermission (PermissionState.None)));
+ }
+#else
[Test]
[ExpectedException (typeof (ArgumentException))]
public void PermissionState_Unrestricted ()
{
UrlIdentityPermission uip = new UrlIdentityPermission (PermissionState.Unrestricted);
}
-
+#endif
[Test]
[ExpectedException (typeof (ArgumentException))]
public void PermissionState_Bad ()
}
[Test]
+#if NET_2_0
+ // this was working in beta1 but is broken in Nov CTP
+ [ExpectedException (typeof (NullReferenceException))]
+#else
[ExpectedException (typeof (ArgumentNullException))]
+#endif
public void Url_Null ()
{
UrlIdentityPermission uip = new UrlIdentityPermission (PermissionState.None);
}
[Test]
-#if NET_2_0
- [ExpectedException (typeof (ArgumentException))]
-#endif
public void Union_Different ()
{
UrlIdentityPermission uip1 = new UrlIdentityPermission (GoodUrls [0]);
UrlIdentityPermission uip2 = new UrlIdentityPermission (GoodUrls [1]);
UrlIdentityPermission result = (UrlIdentityPermission)uip1.Union (uip2);
+#if NET_2_0
+ Assert.IsNotNull (result, "Mono U Novell");
+ // new XML format is used to contain more than one site
+ SecurityElement se = result.ToXml ();
+ Assert.AreEqual (2, se.Children.Count, "Childs");
+ Assert.AreEqual (GoodUrls [0], (se.Children [0] as SecurityElement).Attribute ("Url"), "Url#1");
+ Assert.AreEqual (GoodUrls [1], (se.Children [1] as SecurityElement).Attribute ("Url"), "Url#2");
+ // strangely it is still versioned as 'version="1"'.
+ Assert.AreEqual ("1", se.Attribute ("version"), "Version");
+#else
Assert.IsNull (result, "Mono U Novell");
+#endif
}
[Test]
ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.None);
Assert.AreEqual (SecurityZone.NoZone, zip.SecurityZone);
}
-
+#if NET_2_0
+ [Test]
+ public void PermissionStateUnrestricted ()
+ {
+ // In 2.0 Unrestricted are permitted for identity permissions
+ ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.Unrestricted);
+ Assert.AreEqual (SecurityZone.NoZone, zip.SecurityZone);
+ SecurityElement se = zip.ToXml ();
+ Assert.AreEqual (5, se.Children.Count, "Count");
+ // and they aren't equals to None
+ Assert.IsFalse (zip.Equals (new ZoneIdentityPermission (PermissionState.None)));
+ }
+#else
[Test]
[ExpectedException (typeof (ArgumentException))]
public void PermissionStateUnrestricted ()
{
ZoneIdentityPermission zip = new ZoneIdentityPermission (PermissionState.Unrestricted);
}
-
+#endif
[Test]
[ExpectedException (typeof (ArgumentException))]
public void PermissionStateInvalid ()
Assert.IsTrue (Same (a, z), "NoZone+Trusted");
Assert.IsFalse (Object.ReferenceEquals (a, z), "!ReferenceEquals4");
}
-#if NET_2_0
+
[Test]
- [ExpectedException (typeof (ArgumentException))]
public void Union_DifferentIdentities ()
{
ZoneIdentityPermission a = new ZoneIdentityPermission (SecurityZone.Trusted);
ZoneIdentityPermission b = new ZoneIdentityPermission (SecurityZone.Untrusted);
- a.Union (b);
- }
+ IPermission result = a.Union (b);
+#if NET_2_0
+ Assert.IsNotNull (result, "Union");
+ // new XML format is used to contain more than one site
+ SecurityElement se = result.ToXml ();
+ Assert.AreEqual (2, se.Children.Count, "Childs");
+ Assert.AreEqual (a.SecurityZone.ToString (), (se.Children [0] as SecurityElement).Attribute ("Zone"), "Zone#1");
+ Assert.AreEqual (b.SecurityZone.ToString (), (se.Children [1] as SecurityElement).Attribute ("Zone"), "Zone#2");
+ // strangely it is still versioned as 'version="1"'.
+ Assert.AreEqual ("1", se.Attribute ("version"), "Version");
#else
- [Test]
- public void Union_DifferentIdentities ()
- {
- ZoneIdentityPermission a = new ZoneIdentityPermission (SecurityZone.Trusted);
- ZoneIdentityPermission b = new ZoneIdentityPermission (SecurityZone.Untrusted);
- Assert.IsNull (a.Union (b));
- }
+ Assert.IsNull (result);
#endif
+ }
+
[Test]
[ExpectedException (typeof (ArgumentException))]
public void Union_DifferentPermissions ()
projects / mono.git / commitdiff