public void Intersect_Unrestricted()
        {
            // Intersection with unrestricted == Copy
            // a. source (this) is unrestricted
            PrintingPermission sp1 = new PrintingPermission(PermissionState.Unrestricted);
            PrintingPermission sp2 = new PrintingPermission(PermissionState.None);

            foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel)
            {
                sp2.Level = ppl;
                PrintingPermission result = (PrintingPermission)sp1.Intersect(sp2);
                Assert.AreEqual(sp2.Level, result.Level, "target " + ppl.ToString());
            }
            // b. destination (target) is unrestricted
            foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel)
            {
                sp2.Level = ppl;
                PrintingPermission result = (PrintingPermission)sp2.Intersect(sp1);
                Assert.AreEqual(sp2.Level, result.Level, "source " + ppl.ToString());
            }
            // exceptions for NoLevel
            sp2.Level = PrintingPermissionLevel.NoPrinting;
            Assert.IsNull(sp1.Intersect(sp2), "target NoLevel");
            Assert.IsNull(sp2.Intersect(sp1), "source NoLevel");
        }
        public void Level_PrintingPermissionLevels_Bad()
        {
            PrintingPermissionLevel ppl = (PrintingPermissionLevel)(PrintingPermissionLevel.AllPrinting + 1);
            PrintingPermission      pp  = new PrintingPermission(PermissionState.None);

            pp.Level = ppl;
        }
Пример #3
0
            protected override IStackWalk CreateStackWalk()
            {
                PrintingPermission permission = new PrintingPermission(PermissionState.Unrestricted);

                permission.Level = attribute.Level;
                return(permission);
            }
        public void Union_None()
        {
            // Union with none is same
            PrintingPermission pp1   = new PrintingPermission(PermissionState.None);
            PrintingPermission pp2   = new PrintingPermission(PermissionState.None);
            PrintingPermission union = null;

            // a. source (this) is none
            pp2.Level = PrintingPermissionLevel.NoPrinting;
            union     = (PrintingPermission)pp1.Union(pp2);
            Assert.IsNull(union, "target NoPrinting");
            foreach (PrintingPermissionLevel ppl in AllLevelExceptNoAndAllLevel)
            {
                pp2.Level = ppl;
                union     = (PrintingPermission)pp1.Union(pp2);
                Assert.IsFalse(union.IsUnrestricted(), "target " + ppl.ToString());
            }
            pp2.Level = PrintingPermissionLevel.AllPrinting;
            union     = (PrintingPermission)pp1.Union(pp2);
            Assert.IsTrue(union.IsUnrestricted(), "target AllPrinting");

            // b. destination (target) is none
            pp2.Level = PrintingPermissionLevel.NoPrinting;
            union     = (PrintingPermission)pp2.Union(pp1);
            Assert.IsNull(union, "source NoPrinting");
            foreach (PrintingPermissionLevel ppl in AllLevelExceptNoAndAllLevel)
            {
                pp2.Level = ppl;
                union     = (PrintingPermission)pp2.Union(pp1);
                Assert.IsFalse(union.IsUnrestricted(), "source " + ppl.ToString());
            }
            pp2.Level = PrintingPermissionLevel.AllPrinting;
            union     = (PrintingPermission)pp2.Union(pp1);
            Assert.IsTrue(union.IsUnrestricted(), "source AllPrinting");
        }
Пример #5
0
        }// PutValuesinPage

        internal override IPermission GetCurrentPermission()
        {
            PrintingPermission perm = null;

            if (m_radUnrestricted.Checked == true)
            {
                perm = new PrintingPermission(PermissionState.Unrestricted);
            }
            else
            {
                perm = new PrintingPermission(PermissionState.None);
                PrintingPermissionLevel ppl = PrintingPermissionLevel.NoPrinting;
                if (m_cbOptions.SelectedIndex == 1)
                {
                    ppl = PrintingPermissionLevel.SafePrinting;
                }
                else if (m_cbOptions.SelectedIndex == 2)
                {
                    ppl = PrintingPermissionLevel.DefaultPrinting;
                }
                else if (m_cbOptions.SelectedIndex == 3)
                {
                    ppl = PrintingPermissionLevel.AllPrinting;
                }

                perm.Level = ppl;
            }
            return(perm);
        } // GetCurrentPermission
 public void PermissionState_Bad()
 {
     Assert.Throws <ArgumentException>(() =>
     {
         PermissionState ps    = (PermissionState)77;
         PrintingPermission pp = new PrintingPermission(ps);
     });
 }
 public void FromXml_Null()
 {
     Assert.Throws <ArgumentNullException>(() =>
     {
         PrintingPermission pp = new PrintingPermission(PermissionState.None);
         pp.FromXml(null);
     });
 }
 public void PrintingPermissionLevels_Bad()
 {
     Assert.Throws <ArgumentException>(() =>
     {
         PrintingPermissionLevel ppl = (PrintingPermissionLevel)(PrintingPermissionLevel.AllPrinting + 1);
         PrintingPermission pp       = new PrintingPermission(ppl);
     });
 }
        public void FromXml_WrongVersion()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);
            SecurityElement    se = pp.ToXml();

            se.Attributes.Remove("version");
            se.Attributes.Add("version", "2");
            pp.FromXml(se);
        }
 public void Level_PrintingPermissionLevels_Bad()
 {
     Assert.Throws <ArgumentException>(() =>
     {
         PrintingPermissionLevel ppl = (PrintingPermissionLevel)(PrintingPermissionLevel.AllPrinting + 1);
         PrintingPermission pp       = new PrintingPermission(PermissionState.None);
         pp.Level = ppl;
     });
 }
        public void FromXml_NoVersion()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);
            SecurityElement    se = pp.ToXml();

            SecurityElement w = new SecurityElement(se.Tag);

            w.AddAttribute("class", se.Attribute("class"));
            pp.FromXml(w);
        }
Пример #12
0
        internal CPrintingPermControls(IPermission perm, Object oParent) : base(perm, oParent)
        {
            // If they don't have a permission for this permission set, we will
            // feed our property page a 'none' permission state.

            if (perm == null)
            {
                m_perm = new PrintingPermission(PermissionState.None);
            }
        }// CPrintingPermControls
        public void FromXml_WrongTagCase()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);
            SecurityElement    se = pp.ToXml();

            se.Tag = "IPERMISSION";             // instead of IPermission
            pp.FromXml(se);
            // note: normally IPermission classes (in corlib) DO care about the
            // IPermission tag
        }
Пример #14
0
 internal static bool HasPermission(PrintingPermission permission)
 {
     try {
         permission.Demand();
         return(true);
     }
     catch (SecurityException) {
         return(false);
     }
 }
        public void IsSubset_Null()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);

            Assert.IsTrue(pp.IsSubsetOf(null), "NoLevel");
            foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel)
            {
                pp.Level = ppl;
                Assert.IsFalse(pp.IsSubsetOf(null), ppl.ToString());
            }
        }
 public void FromXml_WrongVersion()
 {
     Assert.Throws <ArgumentException>(() =>
     {
         PrintingPermission pp = new PrintingPermission(PermissionState.None);
         SecurityElement se    = pp.ToXml();
         se.Attributes.Remove("version");
         se.Attributes.Add("version", "2");
         pp.FromXml(se);
     });
 }
        public void IsSubset_Self()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);

            foreach (PrintingPermissionLevel ppl in AllLevel)
            {
                pp.Level = ppl;
                PrintingPermission result = (PrintingPermission)pp.Intersect(pp);
                Assert.IsTrue(pp.IsSubsetOf(pp), ppl.ToString());
            }
        }
        public void Intersect_Self()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);

            foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel)
            {
                pp.Level = ppl;
                PrintingPermission result = (PrintingPermission)pp.Intersect(pp);
                Assert.AreEqual(ppl, result.Level, ppl.ToString());
            }
        }
        public void Intersect_Null()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);

            // No intersection with null
            foreach (PrintingPermissionLevel ppl in AllLevel)
            {
                pp.Level = ppl;
                Assert.IsNull(pp.Intersect(null), ppl.ToString());
            }
        }
        public void Copy()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);

            foreach (PrintingPermissionLevel ppl in AllLevel)
            {
                pp.Level = ppl;
                PrintingPermission copy = (PrintingPermission)pp.Copy();
                Assert.AreEqual(ppl, copy.Level, ppl.ToString());
            }
        }
Пример #21
0
        public void Default()
        {
            PrintingPermissionAttribute a = new PrintingPermissionAttribute(SecurityAction.Assert);

            Assert.AreEqual(a.ToString(), a.TypeId.ToString(), "TypeId");
            Assert.IsFalse(a.Unrestricted, "Unrestricted");
            Assert.AreEqual(PrintingPermissionLevel.NoPrinting, a.Level, "PrintingPermissionLevel");

            PrintingPermission sp = (PrintingPermission)a.CreatePermission();

            Assert.IsFalse(sp.IsUnrestricted(), "IsUnrestricted");
        }
        public void FromXml_NoClass()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);
            SecurityElement    se = pp.ToXml();

            SecurityElement w = new SecurityElement(se.Tag);

            w.AddAttribute("version", se.Attribute("version"));
            pp.FromXml(w);
            // note: normally IPermission classes (in corlib) DO NOT care about
            // attribute "class" name presence in the XML
        }
        public void Union_Null()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);

            // Union with null is a simple copy
            foreach (PrintingPermissionLevel ppl in AllLevel)
            {
                pp.Level = ppl;
                PrintingPermission union = (PrintingPermission)pp.Union(null);
                Assert.AreEqual(ppl, union.Level, ppl.ToString());
            }
        }
        public void FromXml_WrongClass()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);
            SecurityElement    se = pp.ToXml();

            SecurityElement w = new SecurityElement(se.Tag);

            w.AddAttribute("class", "Wrong" + se.Attribute("class"));
            w.AddAttribute("version", se.Attribute("version"));
            pp.FromXml(w);
            // doesn't care of the class name at that stage
            // anyway the class has already be created so...
        }
Пример #25
0
        public void Unrestricted()
        {
            PrintingPermissionAttribute a = new PrintingPermissionAttribute(SecurityAction.Assert);

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

            Assert.IsTrue(wp.IsUnrestricted(), "IsUnrestricted");
            Assert.AreEqual(PrintingPermissionLevel.NoPrinting, a.Level, "NoPrinting");

            a.Unrestricted = false;
            wp             = (PrintingPermission)a.CreatePermission();
            Assert.IsFalse(wp.IsUnrestricted(), "!IsUnrestricted");
        }
        public void Union_Self()
        {
            PrintingPermission pp = new PrintingPermission(PermissionState.None);

            foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel)
            {
                pp.Level = ppl;
                PrintingPermission result = (PrintingPermission)pp.Union(pp);
                Assert.AreEqual(ppl, result.Level, ppl.ToString());
            }
            // union of NoPrinting with NoPrinting == null
            pp.Level = PrintingPermissionLevel.NoPrinting;
            Assert.IsNull(pp.Union(pp), "NoPrinting");
        }
        public void Intersect_None()
        {
            PrintingPermission sp1 = new PrintingPermission(PermissionState.None);
            PrintingPermission sp2 = new PrintingPermission(PermissionState.None);

            foreach (PrintingPermissionLevel ppl in AllLevelExceptNoLevel)
            {
                sp2.Level = ppl;
                // 1. Intersect None with ppl
                PrintingPermission result = (PrintingPermission)sp1.Intersect(sp2);
                Assert.IsNull(result, "None N " + ppl.ToString());
                // 2. Intersect ppl with None
                result = (PrintingPermission)sp2.Intersect(sp1);
                Assert.IsNull(result, "None N " + ppl.ToString());
            }
        }
Пример #28
0
        }// GetTextForIndex

        protected override void PutValuesinPage()
        {
            // Put in the text for the radio buttons
            m_radUnrestricted.Text             = CResourceStore.GetString("PrintingPermission:GrantUnrestrict");
            m_radGrantFollowingPermission.Text = CResourceStore.GetString("PrintingPermission:GrantFollowing");

            m_cbOptions.Items.Clear();
            m_cbOptions.Items.Add(CResourceStore.GetString("PrintingPermission:NoPrinting"));
            m_cbOptions.Items.Add(CResourceStore.GetString("PrintingPermission:SafePrinting"));
            m_cbOptions.Items.Add(CResourceStore.GetString("PrintingPermission:DefaultPrinting"));
            m_cbOptions.Items.Add(CResourceStore.GetString("PrintingPermission:AllPrinting"));

            PrintingPermission perm = (PrintingPermission)m_perm;

            CheckUnrestricted(perm);

            if (!perm.IsUnrestricted())
            {
                if ((perm.Level & PrintingPermissionLevel.AllPrinting) == PrintingPermissionLevel.AllPrinting)
                {
                    m_cbOptions.SelectedIndex = 3;
                }
                else if ((perm.Level & PrintingPermissionLevel.DefaultPrinting) == PrintingPermissionLevel.DefaultPrinting)
                {
                    m_cbOptions.SelectedIndex = 2;
                }
                else if ((perm.Level & PrintingPermissionLevel.SafePrinting) == PrintingPermissionLevel.SafePrinting)
                {
                    m_cbOptions.SelectedIndex = 1;
                }
                else
                {
                    m_cbOptions.SelectedIndex = 0;
                }
            }
            else
            {
                m_cbOptions.SelectedIndex = 3;
            }

            onOptionChange(null, null);
        }// PutValuesinPage
        public void PermissionState_Unrestricted()
        {
            PermissionState    ps = PermissionState.Unrestricted;
            PrintingPermission pp = new PrintingPermission(ps);

            Assert.AreEqual(PrintingPermissionLevel.AllPrinting, pp.Level, "Level");
            Assert.IsTrue(pp.IsUnrestricted(), "IsUnrestricted");

            SecurityElement se = pp.ToXml();

            // only class and version are present
            Assert.AreEqual("true", se.Attribute("Unrestricted"), "Xml-Unrestricted");
            Assert.IsNull(se.Children, "Xml-Children");

            PrintingPermission copy = (PrintingPermission)pp.Copy();

            Assert.IsFalse(Object.ReferenceEquals(pp, copy), "ReferenceEquals");
            Assert.AreEqual(pp.Level, copy.Level, "Level");
            Assert.AreEqual(pp.IsUnrestricted(), copy.IsUnrestricted(), "IsUnrestricted ()");
        }
        public void Union_Unrestricted()
        {
            // Union with unrestricted is unrestricted
            PrintingPermission sp1 = new PrintingPermission(PermissionState.Unrestricted);
            PrintingPermission sp2 = new PrintingPermission(PermissionState.None);

            // a. source (this) is unrestricted
            foreach (PrintingPermissionLevel ppl in AllLevel)
            {
                sp2.Level = ppl;
                PrintingPermission union = (PrintingPermission)sp1.Union(sp2);
                Assert.IsTrue(union.IsUnrestricted(), "target " + ppl.ToString());
            }
            // b. destination (target) is unrestricted
            foreach (PrintingPermissionLevel ppl in AllLevel)
            {
                sp2.Level = ppl;
                PrintingPermission union = (PrintingPermission)sp2.Union(sp1);
                Assert.IsTrue(union.IsUnrestricted(), "source " + ppl.ToString());
            }
        }