/// <summary>
 ///     Initializes UnmanagedCodePermission for the <see cref="Credential" /> class.
 /// </summary>
 static Credential()
 {
     lock (LockObject)
     {
         UnmanagedCodePermission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
     }
 }

        public void ReflectionFormatterReadSecurityExceptionPropertiesWithoutPermissionTest()
        {
            SecurityPermission denyPermission
                = new SecurityPermission(SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence);
            PermissionSet permissions = new PermissionSet(PermissionState.None);
            permissions.AddPermission(denyPermission);
            permissions.Deny();

            StringBuilder sb = new StringBuilder();
            StringWriter writer = new StringWriter(sb);

            SecurityException exception = null;
            try
            {
                DemandException(denyPermission);
            }
            catch (SecurityException e)
            {
                exception = e;
            }

            MockTextExceptionFormatter formatter = new MockTextExceptionFormatter(writer, exception, Guid.Empty);
            formatter.Format();

            CodeAccessPermission.RevertDeny();

            formatter = new MockTextExceptionFormatter(writer, exception, Guid.Empty);
            formatter.Format();
            Assert.AreEqual(exception.Demanded.ToString(), formatter.properties["Demanded"]);
        }

		public void Correctly_determines_permissions()
		{
			// Execution has to be always granted. Otherwise this code wouldn't run in the first place.
			var securityPermission = new SecurityPermission(SecurityPermissionFlag.Execution);

			Assert.IsTrue(securityPermission.IsGranted());
		}

        public override void Install(IDictionary stateSaver)
        {
            try
            {
                SecurityPermission permission =
                    new SecurityPermission(PermissionState.Unrestricted);
                permission.Demand();
            }
            catch (SecurityException)
            {
                throw new InstallException(
                    "You have insufficient privileges to " +
                    "register a trust relationship. Start Excel " +
                    "and confirm the trust dialog to run the addin.");
            }
            Uri deploymentManifestLocation = null;

            // NodeXLModification
            //
            // "deploymentManifestLocation" parameter name changed to
            // "deploymentLocation" to make it consistent with
            // ClickOnceInstaller.cs.

            if (Uri.TryCreate(Context.Parameters["deploymentLocation"],
                UriKind.RelativeOrAbsolute, out deploymentManifestLocation) == false)
            {
                throw new InstallException(
                    "The location of the deployment manifest is missing or invalid.");
            }
            AddInSecurityEntry entry = new AddInSecurityEntry(
                            deploymentManifestLocation, RSA_PublicKey);
            UserInclusionList.Add(entry);
            stateSaver.Add("entryKey", deploymentManifestLocation);
            base.Install(stateSaver);
        }

        public void RunApp(string FileName, string arg)
        {
            SecurityPermission SP = new SecurityPermission(SecurityPermissionFlag.AllFlags);
            SP.Assert();

            //ProcessStartInfo process = new ProcessStartInfo("cmd", "/c " + FileName ));
            System.Diagnostics.Process process = new System.Diagnostics.Process();
            process.StartInfo.WindowStyle = ProcessWindowStyle.Normal;
            //process.StartInfo.UseShellExecute = false;
            //process.StartInfo.RedirectStandardOutput = true;
            //process.StartInfo.RedirectStandardError = true;
            //process.StartInfo.CreateNoWindow = true;
            process.StartInfo.FileName = FileName;
            process.StartInfo.Arguments = arg;
            process.StartInfo.WorkingDirectory = System.IO.Path.GetDirectoryName(FileName);

            //Vista or higher check
            if (System.Environment.OSVersion.Version.Major >= 6)
                process.StartInfo.Verb = "runas";

            try
            {
                process.Start();
                process.WaitForExit();
                process.Close();
            }
            catch (InvalidOperationException)
            {
                //e.ExceptionObject.ToString();
            }
        }

		public void CanReflectOnSecurityExceptionWithoutPermission()
		{
			SecurityPermission denyPermission
				= new SecurityPermission(SecurityPermissionFlag.ControlPolicy | SecurityPermissionFlag.ControlEvidence);
			PermissionSet permissions = new PermissionSet(PermissionState.None);
			permissions.AddPermission(denyPermission);
			permissions.Deny();

			SecurityException exception = null;
			try
			{
				DemandException(denyPermission);
			}
			catch (SecurityException e)
			{
				exception = e;
			}
			
			ExceptionFormatter formatter = new ExceptionFormatter();

			String message = formatter.GetMessage(exception);
			Match demandedMatch = DemandedEntryRegex.Match(message);
			Assert.IsNotNull(demandedMatch);
			Assert.AreEqual(Resources.PropertyAccessFailed, demandedMatch.Groups[1].Value);

			CodeAccessPermission.RevertDeny();

			message = formatter.GetMessage(exception);
			demandedMatch = DemandedEntryRegex.Match(message);
			Assert.IsNotNull(demandedMatch);
			Assert.AreNotEqual(Resources.PropertyAccessFailed, demandedMatch.Groups[1].Value);
		}

 static BaseCredentialsPrompt()
 {
     lock (_lockObject)
     {
         _unmanagedCodePermission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
     }
 }

 public Clerk(string compensator, string description, CompensatorOptions flags)
 {
     SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
     permission.Demand();
     permission.Assert();
     this.Init(compensator, description, flags);
 }

        public static void SetAppDomainData()
        {
            SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.ControlAppDomain);
            sp.Assert();

            AppDomain.CurrentDomain.SetData("SQLServerCompactEditionUnderWebHosting", true);
        }

        // static default constructor. This will be called before any of the static members are accessed.
        static CodeAccessSecurityEngine()
        {
#pragma warning disable 618
            AssertPermission = new SecurityPermission(SecurityPermissionFlag.Assertion);
#pragma warning restore 618
            AssertPermissionToken = PermissionToken.GetToken(AssertPermission);
        }

 public ClerkMonitor()
 {
     SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
     permission.Demand();
     permission.Assert();
     this._monitor = new CrmMonitor();
     this._version = 0;
 }

 internal static void AnimateWindow(Control control, int time, AnimationFlags flags)
 {
     try
     {
         SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
         sp.Demand();
         AnimateWindow(new HandleRef(control, control.Handle), time, flags);
     }
     catch (SecurityException) { }
 }

	public void Assert()
			{
				// We must have the "Assertion" security flag for this to work.
				SecurityPermission perm;
				perm = new SecurityPermission(SecurityPermissionFlag.Assertion);
				perm.Demand();

				// Assert this permission.
				Assert(2);
			}

 internal static PermissionSet _UnsafeGetAssertPermSet()
 {
     PermissionSet set = new PermissionSet(PermissionState.None);
     RegistryPermission perm = new RegistryPermission(PermissionState.Unrestricted);
     set.AddPermission(perm);
     EnvironmentPermission permission2 = new EnvironmentPermission(PermissionState.Unrestricted);
     set.AddPermission(permission2);
     SecurityPermission permission3 = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
     set.AddPermission(permission3);
     return set;
 }

        internal static void AnimateWindow(Control control, int time, AnimationFlags flags)
        {
            Contract.Requires<ArgumentNullException>(control != null);

            try
            {
                SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
                sp.Demand();
                AnimateWindow(new HandleRef(control, control.Handle), time, flags);
            }
            catch (SecurityException) { }
        }

 [System.Security.SecuritySafeCritical]  // auto-generated
 static RemotingServices() 
 { 
     System.Security.CodeAccessPermission.Assert(true);
     s_RemotingInfrastructurePermission= new SecurityPermission(SecurityPermissionFlag.Infrastructure); 
     s_MscorlibAssembly = typeof(RemotingServices).Assembly;
     s_FieldGetterMB = null;
     s_FieldSetterMB = null;
     s_bRemoteActivationConfigured = false; 
     s_bRegisteredWellKnownChannels = false;
     s_bInProcessOfRegisteringWellKnownChannels = false; 
     s_delayLoadChannelLock = new Object(); 
 }

 public void DoWork()
 {
     // Note that because DoDangerousThing is public, this
      // security check does not resolve the violation.
      // This only checks callers that go through DoWork().
      SecurityPermission secPerm = new SecurityPermission(
     SecurityPermissionFlag.ControlPolicy |
     SecurityPermissionFlag.ControlEvidence
      );
      secPerm.Demand();
      DoDangerousThing();
 }

 /// <summary>
 /// Static Constructor is used to set the CanBinarySerialize value only once for the given security policy
 /// </summary>
 static Serializer()
 {
     SecurityPermission sp =  new SecurityPermission(SecurityPermissionFlag.SerializationFormatter);
     try
     {
         sp.Demand();
         CanBinarySerialize = true;
     }
     catch(SecurityException)
     {
         CanBinarySerialize = false;
     }
 }

		/// <summary>
		/// Creates a new TRACKMOUSEEVENT struct with default settings
		/// </summary>
		public TRACKMOUSEEVENT()
		{
			// Marshal.SizeOf() uses SecurityAction.LinkDemand to prevent 
			// it from being called from untrusted code, so make sure we 
			// have permission to call it
			SecurityPermission permission = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
			permission.Demand();

			this.cbSize = Marshal.SizeOf(typeof(TRACKMOUSEEVENT));
			
			this.dwFlags = 0;
			this.hwndTrack = IntPtr.Zero;
			this.dwHoverTime = 100;
		}

        public override void RemoveEventHandler(object target, Delegate handler) {
            if (Marshal.IsComObject(target)) {
                // retrieve sourceIid and dispid
                Guid sourceIid;
                int dispid;
                GetDataForComInvocation(_innerEventInfo, out sourceIid, out dispid);

                // now validate the caller can call into native and redirect to ComEventHelpers.Combine
                SecurityPermission perm = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
                perm.Demand();
                System.Runtime.InteropServices.ComEventsHelper.Remove(target, sourceIid, dispid, handler);
            } else {
                // we are dealing with a managed object - just add the delegate through relection
                _innerEventInfo.RemoveEventHandler(target, handler);
            }
        }