/// <summary>
        /// Combines the given URI components into a string that is properly encoded for use in HTTP headers.
        /// Note that unicode in the HostString will be encoded as punycode.
        /// </summary>
        /// <param name="scheme">http, https, etc.</param>
        /// <param name="host">The host portion of the uri normally included in the Host header. This may include the port.</param>
        /// <param name="pathBase">The first portion of the request path associated with application root.</param>
        /// <param name="path">The portion of the request path that identifies the requested resource.</param>
        /// <param name="query">The query, if any.</param>
        /// <param name="fragment">The fragment, if any.</param>
        /// <returns></returns>
        public static string BuildAbsolute(
            string scheme,
            HostString host,
            PathString pathBase = new PathString(),
            PathString path = new PathString(),
            QueryString query = new QueryString(),
            FragmentString fragment = new FragmentString())
        {
            var combinedPath = (pathBase.HasValue || path.HasValue) ? (pathBase + path).ToString() : "/";

            var encodedHost = host.ToString();
            var encodedQuery = query.ToString();
            var encodedFragment = fragment.ToString();

            // PERF: Calculate string length to allocate correct buffer size for StringBuilder.
            var length = scheme.Length + SchemeDelimiter.Length + encodedHost.Length
                + combinedPath.Length + encodedQuery.Length + encodedFragment.Length;

            return new StringBuilder(length)
                .Append(scheme)
                .Append(SchemeDelimiter)
                .Append(encodedHost)
                .Append(combinedPath)
                .Append(encodedQuery)
                .Append(encodedFragment)
                .ToString();
        }

    public virtual IPromise<IHttpResponse> Execute(string method, string baseUrl, QueryString queryString, System.Net.ICredentials credentials, bool async, Action<IHttpRequest> configure)
    {
      var uri = baseUrl + (queryString == null ? "" : queryString.ToString());

      var req = (HttpWebRequest)System.Net.WebRequest.Create(uri);
      req.AllowAutoRedirect = this.AllowAutoRedirect;
      if (this.AutomaticDecompression) req.AutomaticDecompression = (DecompressionMethods.GZip | DecompressionMethods.Deflate);
      if (this.StoreCookies) req.CookieContainer = _cookieContainer;
      req.Method = method;
      req.ReadWriteTimeout = 300000;
      req.Timeout = DefaultTimeout;
      if (method == "POST")
      {
        req.CachePolicy = new RequestCachePolicy(RequestCacheLevel.NoCacheNoStore);
      }
      req.Credentials = credentials;
      var result = new WebRequest(req, this.Compression);
      if (configure != null) configure.Invoke(result);

      var st = Stopwatch.StartNew();
      return result.Execute(async).Convert(r => {
        if (r.Core.Cookies.Count > 0) SetCookies(r.Core.Cookies);
        return (IHttpResponse)r;
      }).Always(() => {
        st.Stop();
        _httpTracing.TraceData(TraceEventType.Verbose, 0, st.ElapsedMilliseconds);
      });
    }

        public ActionResult Login(string returnUrl)
        {
            if (!User.Identity.IsAuthenticated)
            {
                // User is not authenticated.
                // WSFederationAuthenticationModule is configured to kick in
                // when in EndRequest a request indicates "unauthorized access".
                // Therefore, the following call will start the login process,
                // and after completion, will come back to this address.
                return new HttpUnauthorizedResult();
            }

            // The user successfully authenticated.

            string nameIdentifier = this.GetUserNameIdentifier();
            if (!_userRepo.IsExistingUser(nameIdentifier))
            {
                // New user. Redirect to page for recording user name.
                var queryString = new QueryString { { "returnUrl", returnUrl } };
                return new RedirectResult("/Account/UserData" + queryString);
            }

            // user exists.
            // Redirect back to the page the user was querying.
            return new RedirectResult(returnUrl);
        }

            public void Creating_from_empty_map()
            {
                var args = new Dictionary<string, string>();
                var qs = new QueryString(args);

                qs.ToString().ShouldBe(string.Empty);
            }

        public ActionResult Process(HttpRequestBase request, ModelStateDictionary modelState)
        {
            IpnVerificationBinder binder = new IpnVerificationBinder();
            Transaction tx = binder.Bind(request.Form, modelState);

            ContentResult cr = new ContentResult();
            cr.ContentEncoding = Encoding.UTF8;
            cr.ContentType = "text/html";
            cr.Content = "INVALID";

            if (tx != null)
            {
                Transaction dbTx = m_txRepository.GetAll().Where(x => x.Tx == tx.Tx).FirstOrDefault();
                if (dbTx != null)
                {
                    string expected = dbTx.ToIpnQueryString().ToString();
                    QueryString actualQs = new QueryString();
                    actualQs.Add(request.Form);
                    actualQs.Remove("cmd");
                    string actual = actualQs.ToString();

                    if (expected == actual)
                    {
                        cr.Content = "VERIFIED";
                    }
                }
            }

            return cr;
        }

 /// <summary>
 /// Combines the given URI components into a string that is properly encoded for use in HTTP headers.
 /// </summary>
 /// <param name="pathBase"></param>
 /// <param name="path"></param>
 /// <param name="query"></param>
 /// <param name="fragment"></param>
 /// <returns></returns>
 public static string Encode(PathString pathBase = new PathString(),
     PathString path = new PathString(),
     QueryString query = new QueryString(),
     FragmentString fragment = new FragmentString())
 {
     string combinePath = (pathBase.HasValue || path.HasValue) ? (pathBase + path).ToString() : "/";
     return combinePath + query + fragment;
 }

        public void MyFact()
        {
            var queryString = new QueryString();

            queryString.Add("q", "mcdonald");

            Assert.Equal("q=mcdonald", queryString.ToString());
        }

        public void AppendOtherObjectsWithCanBeConvertedToStrings()
        {
            string actual = new QueryString().
                Append("foo", 10).
                Append("bar", "20.00").ToString();

            Assert.AreEqual("foo=10&bar=20.00", actual);
        }

        public void ParseQueryString_001()
        {
            var QueryString = new QueryString("abc?a=b");

            Assert.AreEqual(1,   QueryString.Count());
            Assert.AreEqual("a", QueryString.First().Key);
            Assert.AreEqual("b", QueryString.First().Value.First());
        }

            public void With_no_parameters()
            {
                var uri = new Uri("http://foo/bar");
                var qs = new QueryString(uri);

                qs.ToString().ShouldBe(string.Empty);
                qs.ToString(canonical: true).ShouldBe(string.Empty);
            }

        public void ShouldNotEncodeWhenAdding()
        {
            // arrange
            QueryString qs = new QueryString();
            qs.Add("1", "http://");

            // act and assert
            Assert.AreEqual("http://", qs["1"]);
        }

        public void ShouldEncodeWhenConvertingToString()
        {
            // arrange
            QueryString qs = new QueryString();
            qs.Add("1", "http://");

            // act and assert
            Assert.AreEqual("?1=http%3a%2f%2f", qs.ToString());
        }

        public void ShouldDecodeWhenGettingValue()
        {
            // arrange
            QueryString qs = new QueryString();
            qs.Add("1", "http%3a%2f%2f");

            // act and assert
            Assert.AreEqual("http://", qs["1"]);
        }

        public void ParseQueryString_002()
        {
            var QueryString = new QueryString("?a=b&a=c");

            Assert.AreEqual(1, QueryString.Count());
            Assert.AreEqual("a", QueryString.First().Key);
            Assert.AreEqual("b", QueryString.First().Value.First());
            Assert.AreEqual("c", QueryString.First().Value.Skip(1).First());
        }

        public void ShouldBuildHttpPostString()
        {
            // arrange
            QueryString qs = new QueryString();
            qs.Add("1", "2");
            qs.Add("3", "4");

            // act and assert
            Assert.AreEqual("1=2&3=4", qs.ToString(HttpAction.Post));
        }

        /// <summary>
        /// Renders the meta view of the view associated with the specified <paramref name="viewContext"/> 
        /// and <paramref name="writer"/>.
        /// </summary>
        /// <param name="viewContext">The view context.</param>
        /// <param name="writer">The writer to write to.</param>
        public override void Render(ViewContext viewContext, TextWriter writer)
        {
            SageController controller = (SageController) viewContext.Controller;
            XmlDocument requestXml = controller.PrepareViewXml(viewContext);

            QueryString query = new QueryString(viewContext.HttpContext.Request.QueryString);
            bool prettyPrint = query.HasValid("pretty", "1|true|yes");
            viewContext.HttpContext.Response.ContentType = this.Info.ContentType;
            writer.Write(requestXml.DocumentElement.ToJson(prettyPrint));
        }

        public void ShouldContainClassNamesFromQueryString()
        {
            var uri = new Uri("/TestHarness.htm?xap=One&Class=NS.Class&class=  Class2.&CLASS=  &class=Class3  ", UriKind.Relative);
            var model = new QueryString(uri.GetQueryString());
            model.ClassNames.Count().ShouldBe(3);

            model.ClassNames.ElementAt(0).ShouldBe("NS.Class");
            model.ClassNames.ElementAt(1).ShouldBe("Class2.");
            model.ClassNames.ElementAt(2).ShouldBe("Class3");
        }

        public void ParseQueryString_003()
        {
            var QueryString = new QueryString("a=b&c=d");

            Assert.AreEqual(2, QueryString.Count());
            Assert.AreEqual("a", QueryString.First().Key);
            Assert.AreEqual("b", QueryString.First().Value.First());
            Assert.AreEqual("c", QueryString.Skip(1).First().Key);
            Assert.AreEqual("d", QueryString.Skip(1).First().Value.First());
        }

 /// <summary>
 /// Create a new HTTP request.
 /// </summary>
 public HTTPRequestBuilder()
 {
     this.HTTPStatusCode  = HTTPStatusCode.OK;
     this.HTTPMethod      = HTTPMethod.GET;
     this.UrlPath         = "/";
     this._QueryString    = new QueryString();
     this.Accept          = new AcceptTypes();
     this.ProtocolName    = "HTTP";
     this.ProtocolVersion = new HTTPVersion(1, 1);
 }

        public Task<Stream> MonitorEventsAsync(MonitorDockerEventsParameters parameters, CancellationToken cancellationToken)
        {
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            const string path = "events";
            IQueryString queryParameters = new QueryString<MonitorDockerEventsParameters>(parameters);
            return this.Client.MakeRequestForStreamAsync(this.Client.NoErrorHandlers, HttpMethod.Get, path, queryParameters, null, cancellationToken);
        }