// Load an existing extension
        internal void edit(policyConstraints pc)
        {
            polCon = pc;

            if (pc.Critical)
            {
                cbCritical.Checked = true;
            }
            else
            {
                cbCritical.Checked = false;
            }

            if (polCon.InhibitPolicyMapping >= 0)
            {
                cbInhibPolMap.Checked = true;
                tbInPolMapSkip.Text   = polCon.InhibitPolicyMapping.ToString();
            }
            else
            {
                cbInhibPolMap.Checked = false;
                tbInPolMapSkip.Text   = "0";
            }

            if (polCon.RequireExplicitPolicy >= 0)
            {
                cbReqExpPol.Checked  = true;
                tbReqExpPolSkip.Text = polCon.RequireExplicitPolicy.ToString();
            }
            else
            {
                cbReqExpPol.Checked  = false;
                tbReqExpPolSkip.Text = "0";
            }
        }
        public void policyConstraintsConstructorTest1()
        {
            bool Critical            = false; // TODO: Initialize to an appropriate value
            policyConstraints target = new policyConstraints(Critical);

            Assert.IsFalse(target.Critical);
        }
        public void PolicyConstraintTest2()
        {
            policyConstraints target = new policyConstraints(testData2);
            Asn1Sequence      actual;

            actual = target.PolicyConstraint;
            Assert.AreEqual(extValue2, actual.ToString());
        }
        public void policyConstraintsConstructorTest2()
        {
            XElement          xml    = testData1; // TODO: Initialize to an appropriate value
            policyConstraints target = new policyConstraints(xml);

            Assert.IsTrue(target.Critical);
            Assert.AreEqual(0, target.RequireExplicitPolicy);
            Assert.AreEqual(2, target.InhibitPolicyMapping);
        }
        public void ToXmlTest()
        {
            policyConstraints target   = new policyConstraints(testData1);
            XNode             expected = testData1;
            XNode             actual;

            actual = target.ToXml();
            Assert.AreEqual(expected.ToString(), actual.ToString());
        }
        public void InhibitPolicyMappingTest()
        {
            policyConstraints target = new policyConstraints(testData2);
            int expected             = -1;
            int actual;

            target.InhibitPolicyMapping = expected;
            actual = target.InhibitPolicyMapping;
            Assert.AreEqual(expected, actual);
        }
        public void RequireExplicitPolicyTest()
        {
            policyConstraints target = new policyConstraints();
            int expected             = 3;
            int actual;

            target.RequireExplicitPolicy = expected;
            actual = target.RequireExplicitPolicy;
            Assert.AreEqual(expected, actual);
        }
        public PolicyConstraints(policyConstraints pc)
        {
            InitializeComponent();

            if (pc == null)
            {
                create();
            }
            else
            {
                edit(pc);
            }
        }
        public void policyConstraintsConstructorTest4()
        {
            // Build an extension
            BcV3CertGen       gen     = new BcV3CertGen();
            policyConstraints testExt = new policyConstraints(testData2);

            gen.AddExtension(testExt.OID, testExt.Critical, testExt.DerEncoding);
            X509Certificate cert = CertTestHarness.RunCertGenerator(gen);
            X509Extension   ext  = CertTestHarness.ExtractExtension(cert, X509Extensions.PolicyConstraints);

            // Test code
            policyConstraints target = new policyConstraints(ext);

            Assert.IsTrue(target.Critical);
            Assert.AreEqual(-1, target.RequireExplicitPolicy);
            Assert.AreEqual(2, target.InhibitPolicyMapping);
        }
        public void policyConstraintsConstructorTest()
        {
            policyConstraints target = new policyConstraints();

            Assert.IsTrue(target.Critical);
        }
Exemple #11
0
 // Create a new extension
 internal void create()
 {
     polCon = new policyConstraints();
 }