/// <summary>
 /// Delete a cookie in the browser by passing in a copy of a cookie
 /// </summary>
 /// <param name="cookie">An object that represents a copy of the cookie that needs to be deleted</param>
 public void DeleteCookie(Cookie cookie)
 {
     if (cookie != null)
     {
         this.DeleteCookieNamed(cookie.Name);
     }
 }

 public bool GetFormsCredentials(out Cookie authCookie, out string user, out string password, out string authority)
 {
     // not use FormsCredentials unless you have implements a custom autentication.
     authCookie = null;
     user = password = authority = null;
     return false;
 }

        public void GetCookies_AddCookiesWithImplicitDomain_CookiesReturnedOnlyForExactDomainMatch()
        {
            const string SchemePrefix = "http://";
            const string OriginalDomain = "contoso.com";

            var container = new CookieContainer();
            var cookie1 = new Cookie(CookieName1, CookieValue1);
            var cookie2 = new Cookie(CookieName2, CookieValue2) { Version = 1 };
            var uri = new Uri(SchemePrefix + OriginalDomain);
            container.Add(uri, cookie1);
            container.Add(uri, cookie2);

            var cookies = container.GetCookies(uri);
            Assert.Equal(2, cookies.Count);
            Assert.Equal(OriginalDomain, cookies[CookieName1].Domain);
            Assert.Equal(OriginalDomain, cookies[CookieName2].Domain);

            uri = new Uri(SchemePrefix + "www." + OriginalDomain);
            cookies = container.GetCookies(uri);
            Assert.Equal(0, cookies.Count);

            uri = new Uri(SchemePrefix + "x.www." + OriginalDomain);
            cookies = container.GetCookies(uri);
            Assert.Equal(0, cookies.Count);

            uri = new Uri(SchemePrefix + "y.x.www." + OriginalDomain);
            cookies = container.GetCookies(uri);
            Assert.Equal(0, cookies.Count);

            uri = new Uri(SchemePrefix + "z.y.x.www." + OriginalDomain);
            cookies = container.GetCookies(uri);
            Assert.Equal(0, cookies.Count);
        }

 public bool GetFormsCredentials(out Cookie authCookie, out string user,
  out string password, out string authority)
 {
     authCookie = null;
     user = password = authority = null;
     return false;
 }

    private static void AddAuthenticationCookies(HttpContext context, System.Net.HttpWebRequest req)
    {
        // Copy user identity to new cookie
        if (context.User != null && context.User.Identity != null)
        {
            var cookiesString0 = req.Headers[HttpRequestHeader.Cookie];
            var cookies = CookieParser.Parse(cookiesString0).ToList();

            // Pass username
            var userCookie = new Cookie("") { Name = "username", Value = context.User.Identity.Name };
            cookies.Add(userCookie);// Always add because this

            // Pass user groups
            var windowsIdentity = context.User.Identity as System.Security.Principal.WindowsIdentity;
            var groupNames = new string[] { };
            if (windowsIdentity.Groups != null)
                groupNames = windowsIdentity.Groups.Select(g => g.Translate(typeof(System.Security.Principal.NTAccount)).Value).ToArray();
            var groupsCookie = new Cookie("") { Name = "usergroups", Value = string.Join(",", groupNames) };
            cookies.Add(groupsCookie);

            // Authentication ticket
            var ticket = TicketHandler.IssueTicket();
            var ticketCookie = new Cookie("") { Name = "winauthticket", Value = ticket };
            cookies.Add(ticketCookie);

            var cookiesString = CookieParser.ToString(cookies.ToArray());
            req.Headers[HttpRequestHeader.Cookie] = cookiesString;
        }
    }

        public void GetCookies_AddCookieVersion0WithExplicitDomain_CookieReturnedForDomainAndSubdomains()
        {
            const string SchemePrefix = "http://";
            const string OriginalDomain = "contoso.com";

            var container = new CookieContainer();
            var cookie1 = new Cookie(CookieName1, CookieValue1) { Domain = OriginalDomain };
            container.Add(new Uri(SchemePrefix + OriginalDomain), cookie1);

            var uri = new Uri(SchemePrefix + OriginalDomain);
            var cookies = container.GetCookies(uri);
            Assert.Equal(1, cookies.Count);
            Assert.Equal(OriginalDomain, cookies[CookieName1].Domain);

            uri = new Uri(SchemePrefix + "www." + OriginalDomain);
            cookies = container.GetCookies(uri);
            Assert.Equal(1, cookies.Count);

            uri = new Uri(SchemePrefix + "x.www." + OriginalDomain);
            cookies = container.GetCookies(uri);
            Assert.Equal(1, cookies.Count);

            uri = new Uri(SchemePrefix + "y.x.www." + OriginalDomain);
            cookies = container.GetCookies(uri);
            Assert.Equal(1, cookies.Count);

            uri = new Uri(SchemePrefix + "z.y.x.www." + OriginalDomain);
            cookies = container.GetCookies(uri);
            Assert.Equal(1, cookies.Count);
        }

 public static void Ctor_NameValuePath_Success()
 {
     Cookie c = new Cookie("hello", "goodbye", "foo");
     Assert.Equal("hello", c.Name);
     Assert.Equal("goodbye", c.Value);
     Assert.Equal("foo", c.Path);
 }

        public void CookieJar_Example_Weighted(int total, int choc1, int choc2, int expectedNumerator, int expectedDenominator)
        {
            // Given we have 2 jars
            // jar one contains 10 choc and 30 vanilla
            // jar two contains 20 choc and 20 vanilla
            // what is the probability of drawing a 
            // vanilla cookie from jar 1

            var sample1 = new WeightedSample<Cookie>("Jar1");
            var sample2 = new WeightedSample<Cookie>("Jar2");
            var hypos = new HypoSet<Cookie>("All");

            hypos.Add(sample1, sample2);

            var chocx = new Cookie() { F = 'C' };
            var vanix = new Cookie() { F = 'V' };

            var choc = It.Is(chocx);
            var vani = It.Is(vanix);

            sample1[chocx] = choc1;
            sample1[vanix] = total - choc1;
            sample2[chocx] = choc2;
            sample2[vanix] = total - choc2;

            sample1.ProbabilityOfEvent(choc);
            sample2.ProbabilityOfEvent(choc);

            var postProb = hypos.PosterierProbability(sample1, vani);

            Assert.That(postProb.Numerator, Is.EqualTo(expectedNumerator));
            Assert.That(postProb.Denominator, Is.EqualTo(expectedDenominator));
        }

 public HTTPWrapper(Cookie sharedCookie)
 {
     UseGZip = true;
     UseProxy = false;
     lastReq = new LastRequest();
     cookies = sharedCookie;
     retries = DEFAULT_RETRIES;
 }

 public CookiePortTest()
 {
     _cc = new CookieContainer();
     _cookie = new Cookie("name", "value1", "/path", "localhost");
     // use both space and comma as delimiter
     _cookie.Port = "\"80 110,1050, 1090 ,1100\"";
     _cc.Add(new Uri("http://localhost/path"), _cookie);
 }

        public static void CommentUri_GetSet_Success()
        {
            Cookie c = new Cookie();
            Assert.Null(c.CommentUri);

            c.CommentUri = new Uri("http://hello.com");
            Assert.Equal(new Uri("http://hello.com"), c.CommentUri);
        }

 public void ShouldAddCookie()
 {
     driver.Get(macbethPage);
     Cookie cookie = new Cookie("cookie", "monster");
     driver.Manage().AddCookie(cookie);
     Assert.That(driver.Manage().GetCookies().ContainsKey(cookie.Name),
         "Cookie was not added successfully");
 }

        void OnAuthRequestFinished(HTTPRequest req, HTTPResponse resp)
        {
            AuthRequest = null;
            string failReason = string.Empty;

            switch (req.State)
            {
                // The request finished without any problem.
                case HTTPRequestStates.Finished:
                    if (resp.IsSuccess)
                    {
                        Cookie = resp.Cookies != null ? resp.Cookies.Find(c => c.Name.Equals(".ASPXAUTH")) : null;

                        if (Cookie != null)
                        {
                            HTTPManager.Logger.Information("CookieAuthentication", "Auth. Cookie found!");

                            if (OnAuthenticationSucceded != null)
                                OnAuthenticationSucceded(this);

                            // return now, all other paths are authentication failures
                            return;
                        }
                        else
                            HTTPManager.Logger.Warning("CookieAuthentication", failReason = "Auth. Cookie NOT found!");
                    }
                    else
                        HTTPManager.Logger.Warning("CookieAuthentication", failReason = string.Format("Request Finished Successfully, but the server sent an error. Status Code: {0}-{1} Message: {2}",
                                                        resp.StatusCode,
                                                        resp.Message,
                                                        resp.DataAsText));
                    break;

                // The request finished with an unexpected error. The request's Exception property may contain more info about the error.
                case HTTPRequestStates.Error:
                    HTTPManager.Logger.Warning("CookieAuthentication", failReason = "Request Finished with Error! " + (req.Exception != null ? (req.Exception.Message + "\n" + req.Exception.StackTrace) : "No Exception"));
                    break;

                // The request aborted, initiated by the user.
                case HTTPRequestStates.Aborted:
                    HTTPManager.Logger.Warning("CookieAuthentication", failReason = "Request Aborted!");
                    break;

                // Ceonnecting to the server is timed out.
                case HTTPRequestStates.ConnectionTimedOut:
                    HTTPManager.Logger.Error("CookieAuthentication", failReason = "Connection Timed Out!");
                    break;

                // The request didn't finished in the given time.
                case HTTPRequestStates.TimedOut:
                    HTTPManager.Logger.Error("CookieAuthentication", failReason = "Processing the request Timed Out!");
                    break;
            }

            if (OnAuthenticationFailed != null)
                OnAuthenticationFailed(this, failReason);
        }

 public HttpResponseState(HttpStatusCode statusCode, string statusDescription, Uri requestUrl, Header[] headers, Cookie[] cookies, string contentType)
 {
     StatusCode = statusCode;
     StatusDescription = statusDescription;
     RequestUrl = requestUrl;
     Headers = headers;
     Cookies = cookies;
     ContentType = contentType;
 }

 public void Save(Cookie cookie)
 {
     if (Response.Cookies.AllKeys.Contains(cookie.Name)) {
             // Class was not designed to handle multiple Saves()
             // Need it? _You_ implement it!
             throw new Exception("Cookie has already been saved this session.");
         }
         Response.Cookies.Add(cookie.HttpCookie());
 }

 private static Dictionary<string, object> ProcessCookie(Cookie singleCookie)
 {
     Dictionary<string, object> rawCookie = new Dictionary<string, object>();
     rawCookie.Add("name", singleCookie.Name);
     rawCookie.Add("value", singleCookie.Value);
     rawCookie.Add("path", singleCookie.Path);
     rawCookie.Add("domain", singleCookie.Domain);
     rawCookie.Add("secure", singleCookie.Secure);
     return rawCookie;
 }

        public void Add_CookieVersion1AndRootDomainWithNoLeadingDot_ThrowsCookieException()
        {
            const string SchemePrefix = "http://";
            const string OriginalDomain = "contoso.com";

            var container = new CookieContainer();
            var cookie = new Cookie(CookieName1, CookieValue1) { Version = 1, Domain = OriginalDomain };
            var uri = new Uri(SchemePrefix + OriginalDomain);
            Assert.Throws<CookieException>(() => container.Add(uri, cookie));
        }

        public static void Comment_GetSet_Success()
        {
            Cookie c = new Cookie();
            Assert.Equal(string.Empty, c.Comment);

            c.Comment = "hello";
            Assert.Equal("hello", c.Comment);

            c.Comment = null;
            Assert.Equal(string.Empty, c.Comment);
        }

        public void CookiePropertiesAreSetWhenInitializedThroughCtor()
        {
            // Arrange
            var cookie = new Cookie("name", "value", "www.foo.com", "/");

            // Assert
            Assert.Equal("name", cookie.Name);
            Assert.Equal("value", cookie.Value);
            Assert.Equal("www.foo.com", cookie.Domain);
            Assert.Equal("/", cookie.Path);
        }

        public static void HttpOnly_GetSet_Success()
        {
            Cookie c = new Cookie();
            Assert.False(c.HttpOnly);

            c.HttpOnly = true;
            Assert.True(c.HttpOnly);

            c.HttpOnly = false;
            Assert.False(c.HttpOnly);
        }