public HttpBrowserCapabilitiesWrapper(HttpBrowserCapabilities httpBrowserCapabilities)
 {
     if (httpBrowserCapabilities == null) {
         throw new ArgumentNullException("httpBrowserCapabilities");
     }
     _browser = httpBrowserCapabilities;
 }

        public TestWebContext(string virtualPath, string page)
        {
            _out = new StringWriter();
            HttpWorkerRequest wr;
            AppDomain domain = Thread.GetDomain();

            // are we running within a valid AspNet AppDomain?
            string appPath = (string) domain.GetData(".appPath");
            if (appPath != null)
            {
                wr = new SimpleWorkerRequest(page, string.Empty, _out);
            }
            else
            {
                appPath = domain.BaseDirectory + "\\";
                wr = new SimpleWorkerRequest(virtualPath, appPath, page, string.Empty, _out);
            }
            HttpContext ctx = new HttpContext(wr);
            HttpContext.Current = ctx;
            HttpBrowserCapabilities browser = new HttpBrowserCapabilities();
            browser.Capabilities = new CaseInsensitiveHashtable(); //CollectionsUtil.CreateCaseInsensitiveHashtable();
            browser.Capabilities[string.Empty] = "Test User Agent"; // string.Empty is the key for "user agent"

            // avoids NullReferenceException when accessing HttpRequest.FilePath
            object virtualPathObject = ExpressionEvaluator.GetValue(null, "T(System.Web.VirtualPath).Create('/')");
            object cachedPathData = ExpressionEvaluator.GetValue(null, "T(System.Web.CachedPathData).GetRootWebPathData()");
            ExpressionEvaluator.SetValue(cachedPathData, "_virtualPath", virtualPathObject);
            ExpressionEvaluator.SetValue(cachedPathData, "_physicalPath", appPath);

            ctx.Request.Browser = browser;
            string filePath = ctx.Request.FilePath;
            _wr = wr;
        }

 /// <summary>
 /// Constructs an instance of <cref see="FiftyOneBrowserCapabilities"/>
 /// </summary>
 public FiftyOneBrowserCapabilities(HttpBrowserCapabilities defaultBrowserCapabilities, HttpRequest request, Match match)
     : base()
 {
     _defaultBrowserCapabilities = defaultBrowserCapabilities;
     _request = request;
     _match = match;
 }

        public static HttpContext CreateHttpContext()
        {
            HttpRequest request = new HttpRequest("", "http://localhost:19175/domain/", "p=1&n&=k");
            Hashtable browserCapabilities = new Hashtable { { "cookies", "true" } };
            HttpBrowserCapabilities browser = new HttpBrowserCapabilities();
            HttpResponse response = new HttpResponse(new StringWriter());
            HttpContext httpContext = new HttpContext(request, response);
            browser.Capabilities = browserCapabilities;
            request.Browser = browser;

            RouteValueDictionary routeValues = request.RequestContext.RouteData.Values;
            routeValues["area"] = "administration";
            routeValues["controller"] = "accounts";
            routeValues["action"] = "details";
            routeValues["language"] = "en";
            MapRoutes();

            IIdentity identity = Substitute.For<IIdentity>();
            identity.IsAuthenticated.Returns(true);
            identity.Name.Returns("1");

            httpContext.User = Substitute.For<IPrincipal>();
            httpContext.User.Identity.Returns(identity);

            return httpContext;
        }

 /// <summary>
 /// Constructs a new instance of ClientCapability.
 /// See http://51degrees.mobi/Products/DeviceData/PropertyDictionary.aspx
 /// for a full list of available properties.
 /// All the properties used are non-lists and therefore the first
 /// item contained in the values list contains the only available value.
 /// </summary>
 public FiftyOneClientCapability(HttpBrowserCapabilities browserCaps)
 {
     if (browserCaps != null)
     {
         Initialise(browserCaps.Capabilities[Constants.FiftyOneDegreesProperties] as SortedList<string, string[]>);
     }
 }

        private void CreateSimulatedRequest(Uri url)
        {
            var simulator = new Instance.Utilities.HttpSimulator.HttpSimulator();
            simulator.SimulateRequest(url);

            var browserCaps = new HttpBrowserCapabilities { Capabilities = new Hashtable() };
            HttpContext.Current.Request.Browser = browserCaps;
        }

 /// <summary>
 /// Constructs a new instance of ClientCapability.
 /// See http://51degrees.mobi/Products/DeviceData/PropertyDictionary.aspx
 /// for a full list of available properties.
 /// All the properties used are non-lists and therefore the first
 /// item contained in the values list contains the only available value.
 /// </summary>
 public FiftyOneClientCapability(HttpBrowserCapabilities browserCaps)
 {
     if (browserCaps != null)
     {
         Initialise(
             browserCaps.Capabilities[FiftyOne.Foundation.Mobile.Detection.Constants.FiftyOneDegreesProperties] 
                 as SortedList<string, List<string>>);
     }
 }

        public async Task CreateAsync(AuthenticationTokenCreateContext context)
        {
            try
            {
                var clientid = context.Ticket.Properties.Dictionary["as:client_id"];

                if (string.IsNullOrEmpty(clientid))
                    return;

                // Gera um ID unico para o RefreshToken
                var refreshTokenId = Guid.NewGuid().ToString("n");

                // Pega o tempo de expiração (em minuto) do token do contexto do Owin
                var refreshTokenLifeTime = context.OwinContext.Get<string>("as:clientRefreshTokenLifeTime");

                // Identifica o Browser
                var userAgent = HttpContext.Current.Request.UserAgent;
                var userBrowser = new HttpBrowserCapabilities { Capabilities = new Hashtable { { string.Empty, userAgent } } };
                var factory = new BrowserCapabilitiesFactory();
                factory.ConfigureBrowserCapabilities(new NameValueCollection(), userBrowser);
                var browser = userBrowser.Browser;

                var issuedUtc = DateTime.UtcNow;
                var expiresUtc = issuedUtc.AddMinutes(3); //issuedUtc.AddMonths(Convert.ToInt32(refreshTokenLifeTime));

                // Define os dados do RefreshToken
                var token = new RefreshToken
                {
                    Id = HashHelper.GetHash(refreshTokenId),
                    ClientId = clientid,
                    Browser = browser,
                    Subject = context.Ticket.Identity.Name,
                    IssuedUtc = issuedUtc,
                    ExpiresUtc = expiresUtc
                };

                // Define o IssuedUtc e o ExpiresUtc do ticket para determinar o quanto tempo o token vai ser válido
                context.Ticket.Properties.IssuedUtc = token.IssuedUtc;
                context.Ticket.Properties.ExpiresUtc = token.ExpiresUtc;

                // Serializa o ticket para ser gravado na base de dados
                var ticketSerializer = new TicketSerializer();
                token.ProtectedTicket = ticketSerializer.Serialize(context.Ticket);

                // Grava o ticket na base de dados
                var refreshTokenDomain = DependecyConfig.Container.GetInstance<IRefreshTokenDomain>();
                var result = await refreshTokenDomain.CreateAsync(token);

                if (result)
                    context.SetToken(refreshTokenId);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        /// <summary>
        /// Show list of input
        /// </summary>
        /// <param name="inputPlace1"> div of clolumn 1 </param>
        /// <param name="inputPlace2"> div of clolumn 2 </param>
        /// <param name="inputParam"> list of Parameter Object </param>
        /// <param name="browser"> Detect Browser </param>
        public static void ShowInput(PlaceHolder inputPlace1, PlaceHolder inputPlace2, List<AMLParam> inputParam, HttpBrowserCapabilities browser)
        {
            if (inputParam == null || inputParam.Count == 0)
            {
                inputPlace1.Controls.Add(new LiteralControl("<h3>No web service input</h3>"));
                return;
            }
            int count = 0;
            for (int i = 0; i < inputParam.Count; i++) //MLParameter param in inputParam)
            {
                Literal lcssFormGroup = new Literal();
                lcssFormGroup.Text = "<div class=\"form-group\">";
                Literal ldiv = new Literal();
                ldiv.Text = "</div>";

                AMLParam param = inputParam[i];
                Label lbl = new Label();
                if(string.IsNullOrEmpty(param.Alias))
                    lbl.Text = textInfo.ToTitleCase(param.Name);
                else lbl.Text = textInfo.ToTitleCase(param.Alias);
                lbl.ID = "lbl" + param + count++;
                lbl.Attributes.Add("Class", "fieldname");

                int numberOnPlace1 = inputParam.Count / 2;
                if(inputPlace2 == null)
                {
                    numberOnPlace1 = inputParam.Count;
                }

                if (i <= numberOnPlace1)
                {
                    inputPlace1.Controls.Add(lcssFormGroup);
                    inputPlace1.Controls.Add(lbl);

                    foreach (var control in GenerateInputControl(param, browser))
                    {
                        inputPlace1.Controls.Add(control);
                    }

                    if (!string.IsNullOrEmpty(param.Description)) inputPlace1.Controls.Add(new LiteralControl(string.Format("<div style=\"width=:100%\"><samp>{0}</samp></div>", param.Description)));
                    inputPlace1.Controls.Add(ldiv);

                }
                else
                {
                    inputPlace2.Controls.Add(lcssFormGroup);
                    inputPlace2.Controls.Add(lbl);
                    foreach (var control in GenerateInputControl(param, browser))
                    {
                        inputPlace2.Controls.Add(control);
                    }
                    if (!string.IsNullOrEmpty(param.Description)) inputPlace2.Controls.Add(new LiteralControl(string.Format("<div style=\"width=:100%\"><samp>{0}</samp></div>", param.Description)));
                    inputPlace2.Controls.Add(ldiv);
                }
            }
        }

 /// <summary>
 /// Returns a HttpBrowserCapabilities object from a UserAgent string
 /// </summary>
 /// <param name="userAgent">UserAgent from Browser</param>
 public BrowserCap(string userAgent)
 {
     var browser = new HttpBrowserCapabilities
     {
         Capabilities = new Hashtable { { string.Empty, userAgent } }
     };
     var factory = new BrowserCapabilitiesFactory();
     factory.ConfigureBrowserCapabilities(new NameValueCollection(), browser);
     Browser = browser;
 }

        public static HttpBrowserCapabilities GetClientBrowser(this string useragent)
        {
            var browser = new HttpBrowserCapabilities
            {
                Capabilities = new Hashtable { { string.Empty, useragent } }
            };
            var factory = new BrowserCapabilitiesFactory();
            factory.ConfigureBrowserCapabilities(new NameValueCollection(), browser);

            return browser;
        }

        /// <summary>
        /// Gets the browser capabilities.
        /// </summary>
        /// <param name="userAgent">The user agent.</param>
        /// <param name="headers">The headers.</param>
        /// <returns></returns>
        public HttpBrowserCapabilities GetBrowserCapabilities(string userAgent, NameValueCollection headers)
        {
            HttpBrowserCapabilities browserCaps = new HttpBrowserCapabilities();
            Hashtable hashtable = new Hashtable(180, StringComparer.OrdinalIgnoreCase);
            hashtable[string.Empty] = userAgent; // The actual method uses client target
            browserCaps.Capabilities = hashtable;

            var capsFactory = new System.Web.Configuration.BrowserCapabilitiesFactory();
            capsFactory.ConfigureBrowserCapabilities(headers, browserCaps);
            capsFactory.ConfigureCustomCapabilities(headers, browserCaps);
            return browserCaps;
        }

		public static HttpCapabilitiesBase GetConfigCapabilities (string configKey, HttpRequest request)
		{
			string ua = request.ClientTarget;
			if (ua == null)
				ua = request.UserAgent;

			HttpBrowserCapabilities bcap = new HttpBrowserCapabilities ();
			bcap.useragent = ua;
			bcap.capabilities = CapabilitiesLoader.GetCapabilities (ua);
			bcap.Init ();
			return bcap;
		}

        /// <summary>
        /// Creates a dictionary of capabilites for the requesting device based on both the 
        /// current capabilities assigned by Microsoft, and the results from 51Degrees.
        /// </summary>
        /// <param name="results">The detection results.</param>
        /// <param name="currentCapabilities">The current capabilities assigned by .NET.</param>
        /// <returns>A dictionary of capabilities for the request.</returns>
        internal static IDictionary EnhancedCapabilities(SortedList<string, string[]> results, HttpBrowserCapabilities currentCapabilities)
        {
            // Use the base class to create the initial list of capabilities.
            IDictionary capabilities = new Hashtable();

            // Add the capabilities for the device.
            EnhancedCapabilities(results, capabilities, currentCapabilities);

            // Initialise any capability values that rely on the settings
            // from the device data source.
            Init(capabilities);

            return capabilities;
        }

        /// <summary>
        /// Checks the properties of the HttpBrowserCapabilities instance passed
        /// into the method for the property name contained in the property parameters
        /// string value.
        /// </summary>
        /// <param name="property">Property name to be found.</param>
        /// <param name="capabilities">Capabilities collection to be used.</param>
        /// <returns>If the property exists then return the associated value, otherwise null.</returns>
        private static string GetHttpBrowserCapabilitiesPropertyValue(string property, HttpBrowserCapabilities capabilities)
        {
            Type controlType = capabilities.GetType();
            System.Reflection.PropertyInfo propertyInfo = controlType.GetProperty(property);
            if (propertyInfo != null && propertyInfo.CanRead)
                return propertyInfo.GetValue(capabilities, null).ToString();

            // Try browser capabilities next.
            string value = capabilities[property];
            if (value != null)
                return value;

            return null;
        }

 internal HttpBrowserCapabilities GetHttpBrowserCapabilities(HttpRequest request)
 {
     if (request == null)
     {
         throw new ArgumentNullException("request");
     }
     NameValueCollection headers = request.Headers;
     HttpBrowserCapabilities browserCaps = new HttpBrowserCapabilities();
     Hashtable hashtable = new Hashtable(180, StringComparer.OrdinalIgnoreCase);
     hashtable[string.Empty] = HttpCapabilitiesDefaultProvider.GetUserAgent(request);
     browserCaps.Capabilities = hashtable;
     this.ConfigureBrowserCapabilities(headers, browserCaps);
     this.ConfigureCustomCapabilities(headers, browserCaps);
     return browserCaps;
 }

        /// <summary>
        /// Constructs an instance of <cref see="FiftyOneBrowserCapabilities"/>
        /// </summary>
        /// <param name="currentCapabilities">Capabilities provided by Microsoft.</param>
        /// <param name="overrideCapabilities">New capabilities provided by 51Degrees.mobi. Can not be null.</param>
        public FiftyOneBrowserCapabilities(HttpBrowserCapabilities currentCapabilities, IDictionary overrideCapabilities)
        {
            // Initialise the hashtable for capabilities.
            Capabilities = new Hashtable();

            // Copy the keys from both the original and new capabilities.
            foreach (object key in currentCapabilities.Capabilities.Keys)
                Capabilities[key] = currentCapabilities.Capabilities[key];
            foreach (object key in overrideCapabilities.Keys)
                Capabilities[key] = overrideCapabilities[key];

            // Copy the adapters from the original.
            foreach (object key in currentCapabilities.Adapters.Keys)
                Adapters.Add(key, currentCapabilities.Adapters[key]);

            // Copy the browsers from the original to prevent the Browsers
            // property returning null.
            if (currentCapabilities.Browsers != null)
                foreach (string browser in currentCapabilities.Browsers)
                    AddBrowser(browser);
        }

 private bool BlackberryProcess(NameValueCollection headers, HttpBrowserCapabilities browserCaps)
 {
     IDictionary capabilities = browserCaps.Capabilities;
     string target = browserCaps[string.Empty];
     RegexWorker worker = new RegexWorker(browserCaps);
     if (!worker.ProcessRegex(target, @"BlackBerry(?'deviceName'\w+)/(?'version'(?'major'\d+)(\.(?'minor'\d+)?)\w*)"))
     {
         return false;
     }
     capabilities["layoutEngine"] = "BlackBerry";
     capabilities["browser"] = "BlackBerry";
     capabilities["majorversion"] = worker["${major}"];
     capabilities["minorversion"] = worker["${minor}"];
     capabilities["type"] = worker["BlackBerry${major}"];
     capabilities["mobileDeviceModel"] = worker["${deviceName}"];
     capabilities["isMobileDevice"] = "true";
     capabilities["version"] = worker["${version}"];
     capabilities["ecmascriptversion"] = "3.0";
     capabilities["javascript"] = "true";
     capabilities["javascriptversion"] = "1.3";
     capabilities["w3cdomversion"] = "1.0";
     capabilities["supportsAccesskeyAttribute"] = "true";
     capabilities["tagwriter"] = "System.Web.UI.HtmlTextWriter";
     capabilities["cookies"] = "true";
     capabilities["frames"] = "true";
     capabilities["javaapplets"] = "true";
     capabilities["supportsCallback"] = "true";
     capabilities["supportsDivNoWrap"] = "false";
     capabilities["supportsFileUpload"] = "true";
     capabilities["supportsMultilineTextBoxDisplay"] = "true";
     capabilities["supportsXmlHttp"] = "true";
     capabilities["tables"] = "true";
     capabilities["canInitiateVoiceCall"] = "true";
     browserCaps.AddBrowser("BlackBerry");
     this.BlackberryProcessGateways(headers, browserCaps);
     bool ignoreApplicationBrowsers = false;
     this.BlackberryProcessBrowsers(ignoreApplicationBrowsers, headers, browserCaps);
     return true;
 }

 private bool ChromeProcess(NameValueCollection headers, HttpBrowserCapabilities browserCaps)
 {
     IDictionary capabilities = browserCaps.Capabilities;
     string target = browserCaps[string.Empty];
     RegexWorker worker = new RegexWorker(browserCaps);
     if (!worker.ProcessRegex(target, @"Chrome/(?'version'(?'major'\d+)(\.(?'minor'\d+)?)\w*)"))
     {
         return false;
     }
     worker.ProcessRegex(browserCaps[string.Empty], @"AppleWebKit/(?'layoutVersion'\d+)");
     capabilities["layoutEngine"] = "WebKit";
     capabilities["layoutEngineVersion"] = worker["${layoutVersion}"];
     capabilities["browser"] = "Chrome";
     capabilities["majorversion"] = worker["${major}"];
     capabilities["minorversion"] = worker["${minor}"];
     capabilities["type"] = worker["Chrome${major}"];
     capabilities["version"] = worker["${version}"];
     capabilities["ecmascriptversion"] = "3.0";
     capabilities["javascript"] = "true";
     capabilities["javascriptversion"] = "1.7";
     capabilities["w3cdomversion"] = "1.0";
     capabilities["supportsAccesskeyAttribute"] = "true";
     capabilities["tagwriter"] = "System.Web.UI.HtmlTextWriter";
     capabilities["cookies"] = "true";
     capabilities["frames"] = "true";
     capabilities["javaapplets"] = "true";
     capabilities["supportsCallback"] = "true";
     capabilities["supportsDivNoWrap"] = "false";
     capabilities["supportsFileUpload"] = "true";
     capabilities["supportsMaintainScrollPositionOnPostback"] = "true";
     capabilities["supportsMultilineTextBoxDisplay"] = "true";
     capabilities["supportsXmlHttp"] = "true";
     capabilities["tables"] = "true";
     browserCaps.AddBrowser("Chrome");
     this.ChromeProcessGateways(headers, browserCaps);
     bool ignoreApplicationBrowsers = false;
     this.ChromeProcessBrowsers(ignoreApplicationBrowsers, headers, browserCaps);
     return true;
 }

        public HttpContextProxy(String fileName, String queryString)
            : base()
        {
            MemoryStream responseStream = new MemoryStream();
            TextWriter responseWriter = new StreamWriter(responseStream);
            HttpWorkerRequest wr = new SimpleWorkerRequest("/", @"C:\inetpub\wwwroot\", fileName, queryString, responseWriter);
            HttpContext context = new HttpContext(wr);
            HttpBrowserCapabilities browser = new HttpBrowserCapabilities();
            browser.SetFieldValue("_items", new Hashtable());
            context.Request.Browser = browser;

            HttpContext previousContext = HttpContext.Current;
            HttpContext.Current = context;

            this._context = context;
            this._previousContext = previousContext;
            this._responseStream = responseStream;
            this._responseWriter = responseWriter;

            IHttpSessionState container = new HttpSessionStateContainer(Guid.NewGuid().ToString(), new SessionStateItemCollection(), new HttpStaticObjectsCollection(), 20, true, HttpCookieMode.AutoDetect, SessionStateMode.InProc, false);
            this.SetSessionState(container);
        }