public void CopyFrom_BadData ()
		{
			byte[] data = { 0x30, 0x18, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x03, 0x30, 0x0B, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01 };
			AsnEncodedData aed = new AsnEncodedData (data);
			Pkcs9MessageDigest md = new Pkcs9MessageDigest ();
			md.CopyFrom (aed);
		}

		public void CopyFrom ()
		{
			byte[] data = { 0x04, 0x10, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
			AsnEncodedData aed = new AsnEncodedData (data);
			Pkcs9MessageDigest md = new Pkcs9MessageDigest ();
			md.CopyFrom (aed);
		}

		private void CommonStuff (CryptographicAttributeObjectCollection coll)
		{
			Assert.IsFalse (coll.IsSynchronized, "IsSynchronized");
			Assert.AreSame (coll, coll.SyncRoot, "SyncRoot");
			Assert.IsNotNull (coll.GetEnumerator (), "GetEnumerator");

			int i = coll.Count;
			Oid o1 = new Oid ("1.2.840.113549.1.7.3");
			AsnEncodedData aed = new AsnEncodedData (o1, new byte[] { 0x05, 0x00 });
			Assert.AreEqual (i, coll.Add (aed), "Add(AsnEncodedData)");
			Assert.IsTrue ((coll[i++] is CryptographicAttributeObject), "converted");

			Oid o2 = new Oid ("1.2.840.113549.1.7.2");
			CryptographicAttributeObject cao = new CryptographicAttributeObject (o2);
			Assert.AreEqual (i, coll.Add (cao), "Add(CryptographicAttributeObject)");

			CryptographicAttributeObject[] array = new CryptographicAttributeObject [coll.Count];
			coll.CopyTo (array, 0);

			Array a = (Array) new object [coll.Count];
			ICollection c = (ICollection) coll;
			c.CopyTo (a, 0);

			IEnumerable e = (IEnumerable) coll;
			Assert.IsNotNull (e.GetEnumerator (), "GetEnumerator");

			coll.Remove (cao);
			Assert.AreEqual (i, coll.Count, "Remove(CryptographicAttributeObject)");
		}

		// methods

		public int Add (AsnEncodedData asnEncodedData)
		{
			if (asnEncodedData == null)
				throw new ArgumentNullException ("asnEncodedData");

			return _list.Add (asnEncodedData);
		}

        public int Add(AsnEncodedData asnEncodedData)
        {
            if (asnEncodedData == null)
                throw new ArgumentNullException(nameof(asnEncodedData));

            return Add(new CryptographicAttributeObject(asnEncodedData.Oid, new AsnEncodedDataCollection(asnEncodedData)));
        }

		public void ConstructorAsnEncodedData_BadAsn ()
		{
			AsnEncodedData aed = new AsnEncodedData ("1.2.3", new byte[0]);
			X509EnhancedKeyUsageExtension eku = new X509EnhancedKeyUsageExtension (aed, true);
			Assert.AreEqual (String.Empty, eku.Format (true), "Format(true)");
			Assert.AreEqual (String.Empty, eku.Format (false), "Format(false)");
			OidCollection oc = eku.EnhancedKeyUsages;
		}

 public void Remove(AsnEncodedData asnEncodedData)
 {
     if (asnEncodedData == null)
     {
         throw new ArgumentNullException("asnEncodedData");
     }
     this.m_list.Remove(asnEncodedData);
 }

 public static void Pkcs9AttributeCopyFromAsnNotAPkcs9Attribute()
 {
     // Pkcs9AttributeObject.CopyFrom(AsnEncodedData) refuses to accept any AsnEncodedData that isn't a Pkcs9AttributeObject-derived class. 
     Pkcs9AttributeObject p = new Pkcs9AttributeObject();
     byte[] rawData = "041e4d00790020004400650073006300720069007000740069006f006e000000".HexToByteArray();
     AsnEncodedData a = new AsnEncodedData(Oids.DocumentName, rawData);
     Assert.Throws<ArgumentException>(() => p.CopyFrom(a));
 }

 public virtual void CopyFrom(AsnEncodedData asnEncodedData)
 {
     if (asnEncodedData == null)
     {
         throw new ArgumentNullException("asnEncodedData");
     }
     this.Reset(asnEncodedData.m_oid, asnEncodedData.m_rawData);
 }

		public void Constructor_StringData ()
		{
			AsnEncodedData aed = new AsnEncodedData ("oid", asnNullBytes);
			Assert.AreEqual ("oid", aed.Oid.Value, "Oid.Value");
			Assert.IsNull (aed.Oid.FriendlyName, "Oid.FriendlyName");
			Assert.AreEqual (BitConverter.ToString (asnNullBytes), BitConverter.ToString (aed.RawData), "RawData");
			Assert.AreEqual (asnNullString, aed.Format (true), "Format");
		}

 public int Add(AsnEncodedData asnEncodedData)
 {
     if (asnEncodedData == null)
     {
         throw new ArgumentNullException("asnEncodedData");
     }
     return this.Add(new CryptographicAttributeObject(asnEncodedData));
 }

		public void CopyFrom ()
		{
			/* byte[] data = ASN1Convert.FromOid ("1.2.840.113549.1.7.1").GetBytes (); */
			byte[] data = { 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01 };
			AsnEncodedData aed = new AsnEncodedData (data);
			Pkcs9ContentType ct = new Pkcs9ContentType ();
			ct.CopyFrom (aed);
		}

		public void LinkDemand_Deny_Unrestricted ()
		{
			Type[] types = new Type[2] { typeof (AsnEncodedData), typeof (bool) };
			ConstructorInfo ci = typeof (X509Extension).GetConstructor (types);
			Assert.IsNotNull (ci, ".ctor(AsnEncodedData,bool)");
			AsnEncodedData aed = new AsnEncodedData (new Oid ("2.5.29.37"), new byte[] { 0x30, 0x05, 0x06, 0x03, 0x2A, 0x03, 0x04 });
			Assert.IsNotNull (ci.Invoke (new object [2] { aed, false }), "invoke");
		}

		public void ConstructorAsnEncodedData_BadAsn ()
		{
			AsnEncodedData aed = new AsnEncodedData ("1.2.3", new byte[0]);
			X509SubjectKeyIdentifierExtension ski = new X509SubjectKeyIdentifierExtension (aed, true);
			Assert.AreEqual (String.Empty, ski.Format (true), "Format(true)");
			Assert.AreEqual (String.Empty, ski.Format (false), "Format(false)");
			string s = ski.SubjectKeyIdentifier;
		}

		public AsnEncodedData (AsnEncodedData asnEncodedData)
		{
			if (asnEncodedData == null)
				throw new ArgumentNullException ("asnEncodedData");

			Oid = new Oid (asnEncodedData._oid);
			RawData = asnEncodedData._raw;
		}

 public override void CopyFrom (AsnEncodedData asnEncodedData) {
     if (asnEncodedData == null)
         throw new ArgumentNullException("asnEncodedData");
     Pkcs9AttributeObject att = asnEncodedData as Pkcs9AttributeObject;
     if (att == null)
         throw new ArgumentException(SecurityResources.GetResourceString("Cryptography_Pkcs9_AttributeMismatch"));
     base.CopyFrom(asnEncodedData);
 }

		public void ConstructorAsnEncodedData_BadAsn ()
		{
			AsnEncodedData aed = new AsnEncodedData ("1.2.3", new byte[0]);
			X509KeyUsageExtension ku = new X509KeyUsageExtension (aed, true);
			Assert.AreEqual (String.Empty, ku.Format (true), "Format(true)");
			Assert.AreEqual (String.Empty, ku.Format (false), "Format(false)");
			X509KeyUsageFlags kuf = ku.KeyUsages;
		}

        public static void Pkcs9AttributeAsnEncodedDataCtorEmptyOidValue()
        {
            Oid oid = new Oid(Oids.Aes128);
            oid.Value = string.Empty;

            AsnEncodedData a = new AsnEncodedData(oid, new byte[3]);
            object ign;
            Assert.Throws<ArgumentException>(() => ign = new Pkcs9AttributeObject(a));
        }

        public int Add(AsnEncodedData asnEncodedData)
        {
            if (asnEncodedData == null)
                throw new ArgumentNullException(nameof(asnEncodedData));

            int indexOfNewItem = _list.Count;
            _list.Add(asnEncodedData);
            return indexOfNewItem;
        }

 public Pkcs9AttributeObject (AsnEncodedData asnEncodedData) : base (asnEncodedData) {
     if (asnEncodedData.Oid == null)
         throw new ArgumentNullException("asnEncodedData.Oid");
     string szOid = base.Oid.Value;
     if (szOid == null)
         throw new ArgumentNullException("oid.Value");
     if (szOid.Length == 0)
         throw new ArgumentException(SecurityResources.GetResourceString("Arg_EmptyOrNullString"), "oid.Value");
 }