public void PermissionStateUnrestricted ()
{
RegistryPermission ep = new RegistryPermission (PermissionState.Unrestricted);
Assert.IsNotNull (ep, "RegistryPermission(PermissionState.Unrestricted)");
Assert.IsTrue (ep.IsUnrestricted (), "IsUnrestricted");
RegistryPermission copy = (RegistryPermission)ep.Copy ();
Assert.AreEqual (ep.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = ep.ToXml ();
Assert.AreEqual ("true", se.Attribute ("Unrestricted"), "ToXml-Unrestricted");
}
public void PermissionStateUnrestricted ()
{
RegistryPermission ep = new RegistryPermission (PermissionState.Unrestricted);
AssertNotNull ("RegistryPermission(PermissionState.Unrestricted)", ep);
Assert ("IsUnrestricted", ep.IsUnrestricted ());
RegistryPermission copy = (RegistryPermission)ep.Copy ();
AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
SecurityElement se = ep.ToXml ();
AssertEquals ("ToXml-Unrestricted", "true", se.Attribute ("Unrestricted"));
}
public void PermissionStateNone ()
{
RegistryPermission ep = new RegistryPermission (PermissionState.None);
Assert.IsNotNull (ep, "RegistryPermission(PermissionState.None)");
Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
RegistryPermission copy = (RegistryPermission)ep.Copy ();
Assert.AreEqual (ep.IsUnrestricted (), copy.IsUnrestricted (), "Copy.IsUnrestricted");
SecurityElement se = ep.ToXml ();
Assert.IsTrue (se.Attribute ("class").StartsWith (className), "ToXml-class");
Assert.AreEqual ("1", se.Attribute ("version"), "ToXml-version");
}
public void PermissionStateNone ()
{
RegistryPermission ep = new RegistryPermission (PermissionState.None);
AssertNotNull ("RegistryPermission(PermissionState.None)", ep);
Assert ("IsUnrestricted", !ep.IsUnrestricted ());
RegistryPermission copy = (RegistryPermission)ep.Copy ();
AssertEquals ("Copy.IsUnrestricted", ep.IsUnrestricted (), copy.IsUnrestricted ());
SecurityElement se = ep.ToXml ();
Assert ("ToXml-class", se.Attribute ("class").StartsWith (className));
AssertEquals ("ToXml-version", "1", se.Attribute ("version"));
}
public override IPermission Union(IPermission other)
{
if (other == null)
{
return(this.Copy());
}
if (!base.VerifyType(other))
{
throw new ArgumentException(Environment.GetResourceString("Argument_WrongType", new object[]
{
base.GetType().FullName
}));
}
RegistryPermission registryPermission = (RegistryPermission)other;
if (this.IsUnrestricted() || registryPermission.IsUnrestricted())
{
return(new RegistryPermission(PermissionState.Unrestricted));
}
StringExpressionSet stringExpressionSet = (this.m_read == null) ? registryPermission.m_read : this.m_read.Union(registryPermission.m_read);
StringExpressionSet stringExpressionSet2 = (this.m_write == null) ? registryPermission.m_write : this.m_write.Union(registryPermission.m_write);
StringExpressionSet stringExpressionSet3 = (this.m_create == null) ? registryPermission.m_create : this.m_create.Union(registryPermission.m_create);
StringExpressionSet stringExpressionSet4 = (this.m_viewAcl == null) ? registryPermission.m_viewAcl : this.m_viewAcl.Union(registryPermission.m_viewAcl);
StringExpressionSet stringExpressionSet5 = (this.m_changeAcl == null) ? registryPermission.m_changeAcl : this.m_changeAcl.Union(registryPermission.m_changeAcl);
if ((stringExpressionSet == null || stringExpressionSet.IsEmpty()) && (stringExpressionSet2 == null || stringExpressionSet2.IsEmpty()) && (stringExpressionSet3 == null || stringExpressionSet3.IsEmpty()) && (stringExpressionSet4 == null || stringExpressionSet4.IsEmpty()) && (stringExpressionSet5 == null || stringExpressionSet5.IsEmpty()))
{
return(null);
}
return(new RegistryPermission(PermissionState.None)
{
m_unrestricted = false,
m_read = stringExpressionSet,
m_write = stringExpressionSet2,
m_create = stringExpressionSet3,
m_viewAcl = stringExpressionSet4,
m_changeAcl = stringExpressionSet5
});
}
public override IPermission Union(IPermission other)
{
RegistryPermission rp = Cast(other);
if (rp == null)
{
return(Copy());
}
if (IsUnrestricted() || rp.IsUnrestricted())
{
return(new RegistryPermission(PermissionState.Unrestricted));
}
if (IsEmpty() && rp.IsEmpty())
{
return(null);
}
RegistryPermission result = (RegistryPermission)Copy();
string path = rp.GetPathList(RegistryPermissionAccess.Create);
if (path != null)
{
result.AddPathList(RegistryPermissionAccess.Create, path);
}
path = rp.GetPathList(RegistryPermissionAccess.Read);
if (path != null)
{
result.AddPathList(RegistryPermissionAccess.Read, path);
}
path = rp.GetPathList(RegistryPermissionAccess.Write);
if (path != null)
{
result.AddPathList(RegistryPermissionAccess.Write, path);
}
return(result);
}
/// <summary>Creates and returns a permission that is the intersection of the current permission and the specified permission.</summary>
/// <returns>A new permission that represents the intersection of the current permission and the specified permission. This new permission is null if the intersection is empty.</returns>
/// <param name="target">A permission to intersect with the current permission. It must be of the same type as the current permission. </param>
/// <exception cref="T:System.ArgumentException">The <paramref name="target" /> parameter is not null and is not of the same type as the current permission. </exception>
public override IPermission Intersect(IPermission target)
{
RegistryPermission registryPermission = this.Cast(target);
if (registryPermission == null)
{
return(null);
}
if (this.IsUnrestricted())
{
return(registryPermission.Copy());
}
if (registryPermission.IsUnrestricted())
{
return(this.Copy());
}
RegistryPermission registryPermission2 = new RegistryPermission(PermissionState.None);
this.IntersectKeys(this.createList, registryPermission.createList, registryPermission2.createList);
this.IntersectKeys(this.readList, registryPermission.readList, registryPermission2.readList);
this.IntersectKeys(this.writeList, registryPermission.writeList, registryPermission2.writeList);
return((!registryPermission2.IsEmpty()) ? registryPermission2 : null);
}
public void ReadAccess ()
{
RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Read, keyLocalMachine);
Assert.IsTrue (!ep.IsUnrestricted (), "IsUnrestricted");
}
public void CreateAccess ()
{
RegistryPermission ep = new RegistryPermission (RegistryPermissionAccess.Create, keyLocalMachine);
Assert ("IsUnrestricted", !ep.IsUnrestricted ());
}
