public void MachineName()
        {
            EventLogPermissionAttribute a = new EventLogPermissionAttribute(SecurityAction.Assert);

            for (int i = 0; i < 256; i++)
            {
                try {
                    a.MachineName = Convert.ToChar(i).ToString();
                    Assert.AreEqual(i, (int)a.MachineName [0], i.ToString());
                }
                catch {
                    switch (i)
                    {
                    case 9:
                    case 10:
                    case 11:
                    case 12:
                    case 13:
                    case 32:
                    case 92:
                    case 133:
                    case 160:
                        // known invalid chars
                        break;

                    default:
                        Assert.Fail(i.ToString());
                        break;
                    }
                }
            }
            // all first 256 characters seems to be valid
            // is there other rules ?
        }
        public void PermissionAccess_Invalid()
        {
            EventLogPermissionAttribute a = new EventLogPermissionAttribute(SecurityAction.Assert);

            a.PermissionAccess = (EventLogPermissionAccess)Int32.MinValue;
            Assert.AreEqual((EventLogPermissionAccess)Int32.MinValue, a.PermissionAccess, "None");
            // no exception thrown
        }
        public void Default()
        {
            EventLogPermissionAttribute a = new EventLogPermissionAttribute(SecurityAction.Assert);

            Assert.AreEqual(a.ToString(), a.TypeId.ToString(), "TypeId");
            Assert.IsFalse(a.Unrestricted, "Unrestricted");
            Assert.AreEqual(".", a.MachineName, "MachineName");
            Assert.AreEqual(EventLogPermissionAccess.Write, a.PermissionAccess, "PermissionAccess");
            EventLogPermission sp = (EventLogPermission)a.CreatePermission();

            Assert.IsFalse(sp.IsUnrestricted(), "IsUnrestricted");
        }
        public void Unrestricted()
        {
            EventLogPermissionAttribute a = new EventLogPermissionAttribute(SecurityAction.Assert);

            a.Unrestricted = true;
            EventLogPermission wp = (EventLogPermission)a.CreatePermission();

            Assert.IsTrue(wp.IsUnrestricted(), "IsUnrestricted");

            a.Unrestricted = false;
            wp             = (EventLogPermission)a.CreatePermission();
            Assert.IsFalse(wp.IsUnrestricted(), "!IsUnrestricted");
        }
        public void PermissionAccess()
        {
            EventLogPermissionAttribute a = new EventLogPermissionAttribute(SecurityAction.Assert);

            a.PermissionAccess = EventLogPermissionAccess.Audit;
            Assert.AreEqual(EventLogPermissionAccess.Audit, a.PermissionAccess, "Audit");
            a.PermissionAccess = EventLogPermissionAccess.Browse;
            Assert.AreEqual(EventLogPermissionAccess.Browse, a.PermissionAccess, "Browse");
            a.PermissionAccess = EventLogPermissionAccess.Instrument;
            Assert.AreEqual(EventLogPermissionAccess.Instrument, a.PermissionAccess, "Instrument");
            a.PermissionAccess = EventLogPermissionAccess.None;
            Assert.AreEqual(EventLogPermissionAccess.None, a.PermissionAccess, "None");
            a.PermissionAccess = EventLogPermissionAccess.Administer;
            Assert.AreEqual(EventLogPermissionAccess.Administer, a.PermissionAccess, "Administer");
            a.PermissionAccess = EventLogPermissionAccess.Write;
            Assert.AreEqual(EventLogPermissionAccess.Write, a.PermissionAccess, "Write");
        }
        public void Action()
        {
            EventLogPermissionAttribute a = new EventLogPermissionAttribute(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");
        }
 public void Action_Invalid()
 {
     EventLogPermissionAttribute a = new EventLogPermissionAttribute((SecurityAction)Int32.MinValue);
     // no validation in attribute
 }
        public void MachineName_Empty()
        {
            EventLogPermissionAttribute a = new EventLogPermissionAttribute(SecurityAction.Assert);

            a.MachineName = String.Empty;
        }
        public void MachineName_Null()
        {
            EventLogPermissionAttribute a = new EventLogPermissionAttribute(SecurityAction.Assert);

            a.MachineName = null;
        }