mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-18 17:02:10 -10:00
It was once part of a special Java target profile, but this is no longer used today.
363 lines
9.8 KiB
C#
363 lines
9.8 KiB
C#
//
|
|
// PermissionSetCollectionTest.cs
|
|
// - NUnit Test Cases for PermissionSetCollection
|
|
//
|
|
// Author:
|
|
// Sebastien Pouliot <[email protected]>
|
|
//
|
|
// Copyright (C) 2005 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.
|
|
//
|
|
|
|
#if NET_2_0
|
|
|
|
using NUnit.Framework;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Security;
|
|
using System.Security.Permissions;
|
|
|
|
namespace MonoTests.System.Security {
|
|
|
|
// "alternate" IList implementation
|
|
class TestList : IList {
|
|
|
|
private IList l;
|
|
|
|
public TestList ()
|
|
{
|
|
l = (IList) new ArrayList ();
|
|
}
|
|
|
|
public int Add (object value)
|
|
{
|
|
return l.Add (value);
|
|
}
|
|
|
|
public void Clear ()
|
|
{
|
|
l.Clear ();
|
|
}
|
|
|
|
public bool Contains (object value)
|
|
{
|
|
return l.Contains (value);
|
|
}
|
|
|
|
public int IndexOf (object value)
|
|
{
|
|
return l.IndexOf (value);
|
|
}
|
|
|
|
public void Insert (int index, object value)
|
|
{
|
|
l.Insert (index, value);
|
|
}
|
|
|
|
public bool IsFixedSize {
|
|
get { return l.IsFixedSize; }
|
|
}
|
|
|
|
public bool IsReadOnly {
|
|
get { return l.IsReadOnly; }
|
|
}
|
|
|
|
public void Remove (object value)
|
|
{
|
|
l.Remove (value);
|
|
}
|
|
|
|
public void RemoveAt (int index)
|
|
{
|
|
l.RemoveAt (index);
|
|
}
|
|
|
|
public object this [int index] {
|
|
get { return l [index]; }
|
|
set { l [index] = value; }
|
|
}
|
|
|
|
public void CopyTo (Array array, int index)
|
|
{
|
|
l.CopyTo (array, index);
|
|
}
|
|
|
|
public int Count {
|
|
get { return l.Count; }
|
|
}
|
|
|
|
public bool IsSynchronized {
|
|
get { return l.IsSynchronized; }
|
|
}
|
|
|
|
public object SyncRoot {
|
|
get { return l.SyncRoot; }
|
|
}
|
|
|
|
public IEnumerator GetEnumerator ()
|
|
{
|
|
return l.GetEnumerator ();
|
|
}
|
|
}
|
|
|
|
[TestFixture]
|
|
public class PermissionSetCollectionTest {
|
|
|
|
[Test]
|
|
public void Constructor ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
Assert.AreEqual (0, psc.Count, "Count");
|
|
Assert.IsFalse (psc.IsSynchronized, "IsSynchronized");
|
|
Assert.AreEqual (0, psc.PermissionSets.Count, "PermissionSets.Count");
|
|
Assert.AreEqual (psc.ToXml ().ToString (), psc.ToString (), "ToXml().ToString()==ToString()");
|
|
Assert.IsNotNull (psc.GetEnumerator (), "GetEnumerator");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotSupportedException))]
|
|
public void SyncRoot ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
Assert.IsNull (psc.SyncRoot, "SyncRoot");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException))]
|
|
public void Add_Null ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
psc.Add (null);
|
|
}
|
|
|
|
[Test]
|
|
public void Add ()
|
|
{
|
|
PermissionSet none = new PermissionSet (PermissionState.None);
|
|
PermissionSet unr = new PermissionSet (PermissionState.Unrestricted);
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
Assert.AreEqual (0, psc.PermissionSets.Count, "Count-0");
|
|
Assert.AreEqual (0, psc.Count, "Count-0");
|
|
psc.Add (none);
|
|
Assert.AreEqual (1, psc.PermissionSets.Count, "Count-1");
|
|
// re-add same permissionset
|
|
psc.Add (none);
|
|
Assert.AreEqual (2, psc.PermissionSets.Count, "Count-2");
|
|
psc.Add (unr);
|
|
Assert.AreEqual (3, psc.PermissionSets.Count, "Count-3");
|
|
Assert.AreEqual (3, psc.Count, "Count-3");
|
|
}
|
|
|
|
[Test]
|
|
public void Copy ()
|
|
{
|
|
PermissionSet none = new PermissionSet (PermissionState.None);
|
|
PermissionSet unr = new PermissionSet (PermissionState.Unrestricted);
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
PermissionSetCollection copy = psc.Copy ();
|
|
Assert.AreEqual (0, copy.PermissionSets.Count, "Count-0");
|
|
psc.Add (none);
|
|
Assert.AreEqual (0, copy.PermissionSets.Count, "Count-0b");
|
|
copy = psc.Copy ();
|
|
Assert.AreEqual (1, copy.PermissionSets.Count, "Count-1");
|
|
psc.Add (none); // re-add same permissionset
|
|
Assert.AreEqual (1, copy.PermissionSets.Count, "Count-1b");
|
|
copy = psc.Copy ();
|
|
Assert.AreEqual (2, copy.PermissionSets.Count, "Count-2");
|
|
psc.Add (unr);
|
|
Assert.AreEqual (2, copy.PermissionSets.Count, "Count-2b");
|
|
copy = psc.Copy ();
|
|
Assert.AreEqual (3, copy.PermissionSets.Count, "Count-3");
|
|
Assert.AreEqual (3, copy.Count, "Count-3");
|
|
}
|
|
|
|
[Test]
|
|
public void Copy_References ()
|
|
{
|
|
PermissionSet none = new PermissionSet (PermissionState.None);
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
psc.Add (none);
|
|
PermissionSetCollection copy = psc.Copy ();
|
|
Assert.AreEqual (1, copy.PermissionSets.Count, "Count-1");
|
|
|
|
string before = psc.ToString ();
|
|
none.AddPermission (new SecurityPermission (SecurityPermissionFlag.Assertion));
|
|
|
|
Assert.AreEqual (none.ToString (), psc.PermissionSets[0].ToString (), "psc");
|
|
Assert.AreEqual (before, copy.ToString (), "copy");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotSupportedException))]
|
|
public void CopyTo ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
psc.CopyTo (null, 0);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (NotSupportedException))]
|
|
public void CopyTo_ICollection ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
ICollection c = (psc as ICollection);
|
|
c.CopyTo (null, 0);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException))]
|
|
public void FromXml_Null ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
psc.FromXml (null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void FromXml_BadName ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
SecurityElement se = new SecurityElement ("PermissionZetCollection");
|
|
psc.FromXml (se);
|
|
}
|
|
|
|
[Test]
|
|
public void FromXml_Roundtrip ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
string expected = psc.ToString ();
|
|
SecurityElement se = psc.ToXml ();
|
|
psc.FromXml (se);
|
|
string actual = psc.ToString ();
|
|
Assert.AreEqual (expected, actual, "Empty");
|
|
|
|
PermissionSet none = new PermissionSet (PermissionState.None);
|
|
psc.Add (none);
|
|
expected = psc.ToString ();
|
|
se = psc.ToXml ();
|
|
psc.FromXml (se);
|
|
actual = psc.ToString ();
|
|
Assert.AreEqual (expected, actual, "1-None");
|
|
|
|
none.AddPermission (new SecurityPermission (SecurityPermissionFlag.Assertion));
|
|
expected = psc.ToString ();
|
|
se = psc.ToXml ();
|
|
psc.FromXml (se);
|
|
actual = psc.ToString ();
|
|
Assert.AreEqual (expected, actual, "1-Assertion");
|
|
Assert.AreEqual (1, psc.Count, "1");
|
|
|
|
PermissionSet unr = new PermissionSet (PermissionState.Unrestricted);
|
|
psc.Add (unr);
|
|
expected = psc.ToString ();
|
|
se = psc.ToXml ();
|
|
psc.FromXml (se);
|
|
actual = psc.ToString ();
|
|
Assert.AreEqual (expected, actual, "2-Assertion+Unrestricted");
|
|
Assert.AreEqual (2, psc.Count, "2");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentOutOfRangeException))]
|
|
public void GetSet_Negative ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
psc.GetSet (-1);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentOutOfRangeException))]
|
|
public void GetSet_Zero_Empty ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
psc.GetSet (0);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentOutOfRangeException))]
|
|
public void GetSet_MaxInt ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
psc.GetSet (Int32.MaxValue);
|
|
}
|
|
|
|
[Test]
|
|
public void GetSet ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
PermissionSet unr = new PermissionSet (PermissionState.Unrestricted);
|
|
psc.Add (unr);
|
|
PermissionSet ps = psc.GetSet (0);
|
|
Assert.AreEqual (unr.ToString (), ps.ToString (), "Same XML");
|
|
Assert.IsTrue (Object.ReferenceEquals (unr, ps), "Same Object Reference");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentOutOfRangeException))]
|
|
public void RemoveSet_Negative ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
psc.RemoveSet (-1);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentOutOfRangeException))]
|
|
public void RemoveSet_Zero_Empty ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
psc.RemoveSet (0);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentOutOfRangeException))]
|
|
public void RemoveSet_MaxInt ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
psc.RemoveSet (Int32.MaxValue);
|
|
}
|
|
|
|
[Test]
|
|
public void RemoveSet ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
PermissionSet unr = new PermissionSet (PermissionState.Unrestricted);
|
|
psc.Add (unr);
|
|
psc.RemoveSet (0);
|
|
Assert.AreEqual (0, psc.Count, "Count");
|
|
}
|
|
|
|
[Test]
|
|
public void ToXml ()
|
|
{
|
|
PermissionSetCollection psc = new PermissionSetCollection ();
|
|
SecurityElement se = psc.ToXml ();
|
|
Assert.IsNull (se.Children, "Children==null for 0");
|
|
PermissionSet unr = new PermissionSet (PermissionState.Unrestricted);
|
|
psc.Add (unr);
|
|
se = psc.ToXml ();
|
|
Assert.AreEqual (1, se.Children.Count, "Children==1");
|
|
Assert.AreEqual (unr.ToString (), se.Children[0].ToString (), "XML");
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|